scribus-calendar-plugin/scribus_calendar/base_objects.py

import scribus
import datetime
import calendar
import re

class Constants(object):
    DefaultFont = ""

class ScribusCalendar(object):
    def __init__(self, objects, year):
        self.objects = objects
        self.year = year

    def createStyles(self):
        existing_styles = scribus.getAllStyles()
        for obj in self.objects:
            obj.createStyles(existing_styles)


    def createLayers(self):
        existingLayers = scribus.getLayers()
        for obj in self.objects:
            obj.createLayer(existingLayers)
            
    def plotStubs(self):
        created = False

        for obj in self.objects:
            created = obj.plotStub() or created

        return created

    def plotObjects(self):
        pass

    def readFromStubs(self):
        for obj in self.objects:
            obj.readFromStub()


class CalendarObject(object):
    def __init__(self, name):
        self.name = name
        self.noStub = False
        self.position = (0,0)
        self.size = (100,100)
        self.paragraphStyle = "DefaultCalenderParagraphStyle"
        self.charStyle = "DefaultCalenderCharStyle"

        self.layer = "CalendarLayer"
        self.defaultFontSize = 8
        self.configParser = None
        
        self.date = datetime.date.today()

    def setDate(self, date):
        self.date = date

    def setDimension(self, pos, size):
        self.position = pos
        self.size = size

    def createLayer(self, existingLayers):
        if self.layer not in existingLayers:
            scribus.createLayer(self.layer)
            existingLayers.append(self.layer)
        
    def createStyles(self, existingStyles):
            charStyles = self.charStyle
            paragraphStyles = self.paragraphStyle
            defaultFontSizes = self.defaultFontSize

            if not type(self.charStyle) is list:
                charStyles = [ self.charStyle ]

            if not type(self.paragraphStyle) is list:
                paragraphStyles = [ self.paragraphStyle ]

            if not type(self.defaultFontSize) is list:
                defaultFontSizes = [ self.defaultFontSize ]


            
            for i in range(0,len(charStyles)):

                if charStyles[i] not in existingStyles:
                    scribus.createCharStyle(charStyles[i], Constants.DefaultFont, defaultFontSizes[i])
                    existingStyles.append(charStyles[i])
                    
                if paragraphStyles[i] not in existingStyles:
                    scribus.createParagraphStyle(paragraphStyles[i] ,1,0,0,0,0,0,0,0,0,0,0,charStyles[i])
                    existingStyles.append(paragraphStyles[i])

    def plotStub(self):
        if self.noStub == True:
            return False

        if not scribus.objectExists(self.name):
            scribus.createText(self.position[0],self.position[1], self.size[0],self.size[1], self.name)
            scribus.setStyle(self.paragraphStyle, self.name)
            scribus.insertText(self.name, 0, self.name)
            scribus.sentToLayer(self.layer, self.name)
            return True
        return False

    def readFromStub(self):
        if self.noStub == True:
            return

        p = scribus.getPosition(self.name)
        s = scribus.getSize(self.name)

        self.setDimension(p, s)

    def plotObject(self):
        pass

    def configure(self, configParser):
        className = self.__class__.__name__
        settings = dict()
        self.configParser = configParser

        try:
            settings = configParser.modules[className]
        except KeyError:
            return

        for key, val in settings.items():
                setattr(self,key, val)

        


class WeekDayNameObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.weekday = datetime.date.today().weekday()
        self.paragraphStyle = "WeekDayNameParagraphStyle"
        self.charStyle = "WeekDayNameCharStyle"

    def getName(self):
        return calendar.day_name[self.date.weekday()]
    
    def getNameAbbrev(self):
        return calendar.day_abbr[self.date.weekday()]

class WeekNameObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.weeknumber = 1
        self.paragraphStyle = "WeekNameParagraphStyle"
        self.charStyle = "WeekNameCharStyle"

    def setDate(self, date):
        CalendarObject.setDate(self, date)
        self.weeknumber = self.date.isocalendar()[1]

    def getName(self):
        return str(self.weeknumber)


    def getNameAbbrev(self):
        return self.getName()

class MonthNameObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self, name)
        self.paragraphStyle = "MonthNameParagraphStyle"
        self.charStyle = "MonthNameCharStyle"

    def getMonthName(self):
        return calendar.month_name[self.date.month]


class UserDefinedObjects(CalendarObject):
    def __init__(self):
        CalendarObject.__init__(self, "UserDefinedObjects")
        self.layer = "UserDefinedObjects"
        self.noStub = True

    def plotObject(self):
        layers = scribus.getLayers()
        currentPage = scribus.currentPage()

        scribus.gotoPage(1)
        objects = scribus.getAllObjects()

        for obj in objects:
            m = re.match(r'^(.+)__(.+)$', obj)
            if m is None:
                continue

            layerName = m.group(1)

            if not layerName in layers:
                scribus.createLayer(layerName)

            scribus.gotoPage(1)
            scribus.copyObject(obj)
            scribus.gotoPage(currentPage)
            scribus.setActiveLayer(layerName)
            #scribus.pasteObject(obj)
            scribus.pasteObject()
        
        


    


class DailyCalendarObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)
        self.isActive = True

    def getName(self):
        return str(self.date.day)

    def setActive(self, state=True):
        self.isActive = state


class MonthlyCalendarObject(CalendarObject):
    def __init__(self, name):
        CalendarObject.__init__(self,name)

    def setDate(self, date):
        CalendarObject.setDate(self, date)
        self.month = self.date.month


    def getName(self):
        return calendar.month_name[self.month]

    def getNameAbbrev(self):
        return calendar.month_abbr[self.month]