Пример #1
0
class CLoader(fo.CCompositionBase):
    """
   Base class of collection loader
   that is to be used to set figures' attributes
   from some external data source,
   e.g. file of database
   """

    ########################################
    def __init__(self, collection, **args):
        fo.CCompositionBase.__init__(self, collection, **args)
        self.srcs = []
        self.tmp_draw_attrs = {}
        self.tmp_layout_attrs = {}
########################################
## All default values off class' possible attributes should be defined
## These defaults takes precedence over 'CDrawFigure...' defaults

    attr_defaults = fo.merge_dicts(fo.CCompositionBase.attrDefaults(), {})

    ########################################
    def HasSource(self, src):
        return src in self.srcs

    def AddSource(self, src):
        if self.HasSource(src):
            return False
        self.srcs.append(src)
        return True
########################################
## Override this

    def AcceptFigureAttr(self, attrs, attr_key, attr_val):
        return attr_val

    ## No need to override this
    def SetFigureAttr(self, attrs_key, attr_key, attr_val):
        attrs = getattr(self, attrs_key)

        if self.AcceptFigureAttr(attrs, attr_key, attr_val):
            attrs[attr_key] = fo.merge_dicts(
                attrs[attr_key], attr_val) if attr_key in attrs else attr_val
########################################
## Fill collection with figures attributes
## by calling 'AddFigureAttrs'.
## Override this - only dummy usage example

    def loadFiguresAttrs(self, src, **args):
        self.SetFigureAttr('tmp_layout_attrs', 'layout_key', 'value')
        self.SetFigureAttr('tmp_draw_attrs', 'draw_key', 'value')
        self.AddFigureAttrs()

    ## Check if this 'src' has not been already loaded.
    ## If not, call 'loadAttrs'.
    ## Do not override this
    def LoadFiguresAttrs(self, src, **args):
        if not self.AddSource(src):
            return False
        self.loadFiguresAttrs(src, **args)
        return True
Пример #2
0
class CLayoutMysteriaCardSpell(CLayoutMysteriaCardPlay_):
    """
   Layout class of Mysteria spell cards
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        CLayoutMysteriaCardPlay_.attrDefaults(), {
            'spell_class': 1,
            'spell_class_width_mm': 20,
            'spell_class_height_mm': 20,
            'spell_class_xalign': 'center',
            'spell_class_yloc': 'below',
            'spell_class_add_yoffs_mm': 6,
            'spell_class_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
                'effect_text': {
                    'size_pt': 24,
                    'fg_color': "black"
                },
            },
            'spell_mana': 2,
            'spell_mana_draw_object_args': {
                'effect_fill': {
                    'type': 'color',
                    'color': "blue"
                },
                'effect_text': {
                    'size_pt': 12,
                    'fg_color': "white"
                },
            },
        })

    local_ranks = [0, 11]
    ranks_ = None

    ########################################
    def Layout(self, rank=0):
        CLayoutMysteriaCardPlay_.Layout(self, rank)
        if rank == 0:
            spell_class = self.AddObjectToGroup(
                'spell_class',
                parent=self.back.GetObjectByKeyBase('back_artifacts_group'),
                effect_text={'text': str(self.spell_class)})
        elif rank == 11:
            spell_mana = self.AddObjectToLayout(
                'spell_mana',
                parent=self.front,
                effect_text={'text': str(self.spell_mana)})
            mini = self.front.GetObjectByKeyBase('mini')
            spell_mana.SetSizeFromObject(mini, set_margin=False)
            spell_mana.SetPosFromObject(mini, xloc='mirror')
        return self.ReturnRank(rank)
Пример #3
0
class CLayoutMysteriaCardPlay_(CLayoutMysteriaCardHold_):
    """
   Incomplete layout class of Mysteria play cards
   -> all hold cards except units
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        CLayoutMysteriaCardHold_.attrDefaults(), {
            'flag': False,
            'play_with_yloc': 'below',
            'play_with_add_yoffs_mm': 1,
            'play_with_scale': 0.7,
            'play_with_draw_object_args': {
                'effect_fill': {
                    'color2': "red"
                },
                'effect_text': {
                    'text': ""
                },
            },
            'force_play': False,
            'back_force_play_width_mm': 9,
            'back_force_play_height_mm': 22,
            'back_force_play_xalign': 'center',
            'back_force_play_yloc': 'below',
            'back_force_play_add_yoffs_mm': 3,
            'back_force_play_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
        })

    local_ranks = [0, 1]
    ranks_ = None

    ########################################
    def Layout(self, rank=0):
        CLayoutMysteriaCardHold_.Layout(self, rank)
        if rank == 0:
            if self.play_with_draw_object_args['effect_text']['text'] != "":
                play_with = self.AddObjectCopyToLayout(
                    self.front.GetObjectByKeyBase('label'),
                    new_key='play_with')
                play_with.SetDrawEffectAttrs(
                    'text',
                    text="+" +
                    play_with.draw.AttrsFromEffects()['effect_text']['text'])
        elif rank == 1:
            if self.force_play:
                back_force_play = self.AddObjectToGroup(
                    'back_force_play',
                    parent=self.back.GetObjectByKeyBase(
                        'back_artifacts_group'))
        return self.ReturnRank(rank)
Пример #4
0
class CLayoutMysteriaCardClass(CLayoutMysteriaCardPlay_):
    """
   Layout class of Mysteria class cards
   -> ordinary, special, shared and risc cards
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        CLayoutMysteriaCardPlay_.attrDefaults(), {
            'front_class_width_mm': 10.8,
            'front_class_height_mm': 10.8,
            'front_class_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
            'back_class_width_mm': 18,
            'back_class_height_mm': 18,
            'back_class_xalign': 'center',
            'back_class_yloc': 'below',
            'back_class_add_yoffs_mm': 6,
            'back_class_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
        })

    local_ranks = [0, 11]
    ranks_ = None

    ########################################
    def Layout(self, rank=0):
        CLayoutMysteriaCardPlay_.Layout(self, rank)
        if rank == 0:
            back_class = self.AddObjectToGroup(
                'back_class',
                parent=self.back.GetObjectByKeyBase('back_artifacts_group'))
        elif rank == 11:
            front_class = self.AddObjectToLayout('front_class',
                                                 parent=self.front)
            front_class.SetPosFromObject(self.front.GetObjectByKeyBase('mini'),
                                         xloc='mirror',
                                         yloc=None)
            front_class.SetPosFromObject(
                self.front.GetObjectByKeyBase('label'),
                xloc=None,
                yloc='centerof')
        return self.ReturnRank(rank)
Пример #5
0
class CLayoutMysteriaCardBasic(CLayoutMysteriaCardPlay_):
    """
   Layout class of Mysteria basic cards
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(CLayoutMysteriaCardPlay_.attrDefaults(), {})

    local_ranks = [0]
    ranks_ = None

    ########################################
    def Layout(self, rank=0):
        CLayoutMysteriaCardPlay_.Layout(self, rank)
        return self.ReturnRank(rank)
Пример #6
0
class CLayoutBack(CLayout):
    """
   Layout that adds back root object
   """
    ########################################
    attr_defaults = fo.merge_dicts(CLayout.attrDefaults(), {})

    local_ranks = [0]
    ranks_ = None

    ########################################
    ## Creates very common root figure object
    def Layout(self, rank=0):
        if rank == 0:
            self.ptr.ptr.back = self.AddRootObjectToLayout('back')
        return self.ReturnRank(rank)
Пример #7
0
class CDrawFigurePrint(CDrawFigureBase):
    """
   Draw figure class that uses terminal printing as draw
   """
    ########################################
    default_draw_object_class = fo.CDrawObjectPrint
    ########################################
    ## All default values off class' possible attributes should be defined
    ## Beware - 'CLayoutFigure...' defaults takes precedence over these !
    attr_defaults = fo.merge_dicts(CDrawFigureBase.attrDefaults(), {})

    ########################################
    def PreDrawFigure(self):
        print "\n" + "^" * 40

    def PostDrawFigure(self):
        print "+" * 40
Пример #8
0
class CLoaderDSV(CLoader):
    """
   Collection loader class
   for files with delimiter-separated values (DSV).
   Each record has to be delimited with newline.
   First line is considered as keys.
   It is also possible to load 'dict's
   with the same syntax as in Python,
   but delimiter has to be different from 'dict' symbols [{,:}]
   and the value must start with '{'.
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    ## These defaults takes precedence over 'CDrawFigure...' defaults
    attr_defaults = fo.merge_dicts(CLoader.attrDefaults(), {
        'delim': '\t',
    })

    ########################################
    ## Draw figure attributes should be prefixed with 'd'.
    ## Layout figure attributes can be prefixed with 'l',
    ## but don't have to - it acts as default.
    def loadFiguresAttrs(self, src, delim=None):
        if not delim:
            delim = self.delim
        with open(src) as csvfile:
            reader = csv.DictReader(csvfile, delimiter=delim)

            for row in reader:
                for key in row.keys():
                    split_ = key.split("_", 1)
                    val = row[key]
                    ## Possibly convert to dict
                    if val and val[0] == '{':
                        val = eval(val)

                    is_default = len(split_) == 1 or split_[0] not in [
                        'd', 'l'
                    ]
                    is_layout = split_[0] == 'l'
                    attrs_key = 'tmp_layout_attrs' if is_default or is_layout else 'tmp_draw_attrs'
                    attr_key = key if is_default else split_[1]

                    self.SetFigureAttr(attrs_key, attr_key, val)
                self.AddFigureAttrs()
Пример #9
0
class CDrawFigureBase(fo.CCompositionBase):
    """
   Dummy draw figure class that defines interface
   between 'CFigure' and 'CDrawFigure..' objects.
   Its purpose is to set draw routines independently
   on figure layout - i.e. it should set
   concrete draw tool specific attributes
   and functions.
   It should not contain attributes that are
   under layout responsibility nor those
   which indeed relates to draw but it is certain
   that they should be used by all kinds of draw tool
   (i.e. fill color, pattern or image of background).
   """
    ########################################
    default_draw_object_class = fo.CDrawObjectBase

    ########################################
    ## Do not override contructor
    ## More attributes are possible to set through '**args',
    ## concrete attributes are set in 'SetAttrs',
    ## default values should be defined in class variable 'attr_defaults'
    def __init__(self, figure, draw_object_class, **args):
        fo.CCompositionBase.__init__(self, figure, **args)
        self.draw_object_class = draw_object_class
########################################

    def __copy__(self):
        return self.__class__(self.ptr, self.draw_object_class, **self.attrs)
########################################
## All default values off class' possible attributes should be defined
## Beware - 'CLayoutFigure...' defaults takes precedence over these !

    attr_defaults = fo.merge_dicts(fo.CCompositionBase.attrDefaults(), {})

    ########################################
    ## Override this - things that need to be set up before any drawing done
    def PreDrawFigure(self):
        pass

    ## Override this - things that need to be set up after all drawing done
    def PostDrawFigure(self):
        pass
Пример #10
0
class CLayoutMysteriaCardAddKind(CLayoutMysteriaCardPlay_):
    """
   Additional (it does not inherit behaviour) layout class of Mysteria kind cards
   -> kind, basic and unit cards
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        CLayoutMysteriaCardPlay_.attrDefaults(), {
            'kind_label_add_yoffs_mm': -0.5,
            'kind_label_new_width_mm': 15,
            'kind_label_scale': 0.75,
            'kind_label_draw_object_args': {
                'effect_fill': {
                    'color2': "cyan"
                },
                'effect_text': {
                    'text': "Kind name"
                },
            },
            'back_kind_label_xalign': 'center',
            'back_kind_label_yloc': 'below',
            'back_kind_label_add_yoffs_mm': 5,
            'back_kind_label_scale': 1.5,
            'no_steal_scale': 0.15,
            'no_steal_add_xoffs_mm': 1,
            'no_steal_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
            'no_dump': True,
            'no_dump_scale': 0.15,
            'no_dump_add_xoffs_mm': 1,
            'no_dump_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
        })

    local_ranks = [0]
    ranks_ = None

    ########################################
    def AddObjectKindLabelToLayout(self,
                                   label_obj,
                                   add_yoffs_mm=fo.DEFAULT,
                                   scale=fo.DEFAULT,
                                   **draw_object_args):
        key = 'kind_label'
        obj = self.AddObjectCopyToLayout(label_obj,
                                         new_key=key,
                                         yloc='above',
                                         add_yoffs_mm=add_yoffs_mm,
                                         scale=scale,
                                         **draw_object_args)
        return obj
########################################

    def Layout(self, rank=0):
        if rank == 0:
            front_kind_label_obj = self.AddObjectKindLabelToLayout(
                self.front.GetObjectByKeyBase('label'))
            back_kind_label_obj = self.AddObjectCopyToLayout(
                front_kind_label_obj,
                new_key='back_kind_label',
                new_parent=self.back,
                xloc=None,
                add_xoffs_mm=0,
                yloc=None,
                add_yoffs_mm=0,
            )
            self.addObjectToGroup(
                parent=self.back.GetObjectByKeyBase('back_artifacts_group'),
                object_=back_kind_label_obj)

            no_steal_obj = self.AddObjectIconToLayout(
                'no_steal',
                self.back.GetObjectByKeyBase('category_icons_group'))
            if self.no_dump:
                no_dump_obj = self.AddObjectIconToLayout(
                    'no_dump',
                    self.back.GetObjectByKeyBase('category_icons_group'))
        return self.ReturnRank(rank)
Пример #11
0
class CLayoutFigureMysteriaCard(fig.CLayoutFigureBase):
    """
   Layout class of all kinds of Mysteria cards
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        fig.CLayoutFigureBase.attrDefaults(), {
            'layout_front': {
                'front_margin_mm': 3,
                'front_draw_object_args': {
                    'effect_fill': {
                        'type': 'gradient',
                        'color1': "black",
                        'color2': "white",
                        'angle': 90,
                        'ratio': 1.2
                    },
                    'effect_border': {
                        'type': 'color',
                        'color': "white"
                    },
                },
            },
            'layout_back': {
                'back_margin_mm': 7.5,
                'back_draw_object_args': {
                    'effect_fill': {
                        'type': 'pattern'
                    },
                    'effect_border': {
                        'type': 'color',
                        'color': "white"
                    },
                },
            },
            'layout_mysteria_card_basic': {
                'flag': False,
                'rank': 5,
                'module': __name__,
            },
            'layout_mysteria_card_class': {
                'flag': False,
                'rank': 5,
                'module': __name__,
            },
            'layout_mysteria_card_spell': {
                'flag': False,
                'rank': 5,
                'module': __name__,
            },
            'layout_mysteria_card_mana': {
                'flag': False,
                'rank': 5,
                'module': __name__,
            },
            'layout_mysteria_card_add_kind': {
                'flag': False,
                'rank': 7,
                'module': __name__,
            },
        })
Пример #12
0
 def AttrsWithLayouts(self):
     return fo.merge_dicts(self.AttrsFromLayouts(), self.attrs)
Пример #13
0
class CLayoutFigureBase(fo.CCompositionBase):
    """
   Dummy figure layout class that defines interface
   between 'CFigure' and 'CLayoutFigure...' objects.
   It should contain attributes
   that are common for any used draw tool.
   """

    ########################################
    ## Do not override contructor
    ## More attributes are possible to set through '**args',
    ## concrete attributes are set in 'SetAttrs',
    ## default values should be defined in class variable 'attr_defaults'
    def __init__(self, figure, **args):
        self.ClearLayouts()
        fo.CCompositionBase.__init__(self, figure, **args)
########################################

    def __copy__(self):
        layout = self.__class__(self.ptr, **self.attrs)
########################################

    def __getattr__(self, attr_key):
        try:
            return fo.CCompositionBase.__getattr__(self, attr_key)
        except AttributeError:
            if hasattr(self.LastLayout, attr_key):
                return getattr(self.LastLayout, attr_key)
            raise
########################################

    def ClearLayouts(self):
        self.layouts = {}
        self.layouts_ordered = []
        self.layouts_pos = -1
        self.layouts_rank = 0
        self.layouts_next_rank = None
########################################

    def CreateLayout(self, layout_class, **layout_args):
        return layout_class(self, **layout_args)

    def AddLayoutByClass(self, layout_class, **layout_args):
        self.AddLayout(self.CreateLayout(layout_class, **layout_args))

    def AddLayout(self, layout):
        self.layouts[layout.LayoutKey] = layout
        self.layouts_ordered.append(layout)
########################################

    def AttrsFromLayouts(self):
        attrs = {}
        for layout_key in self.layouts:
            attrs['layout_' + layout_key] = self.layouts[layout_key].attrs
        return attrs

    def AttrsWithLayouts(self):
        return fo.merge_dicts(self.AttrsFromLayouts(), self.attrs)

    def AddLayoutsFromAttrs(self):
        self.attrs = self.AttrsWithLayouts()
        self.ClearLayouts()
        layouts = self.DictsFromAttrs('layout',
                                      sort_f=lambda l: 0
                                      if not 'rank' in l[1] else l[1]['rank'])
        for l in layouts:
            key = l[0]
            attrs = l[1]
            if 'module' in attrs:
                module = __import__(attrs['module'])
            else:
                module = sys.modules[__name__]
            class_ = getattr(module, "CLayout" + fo.str_title(key))
            self.AddLayoutByClass(class_, **attrs)
########################################
## Do not override this

    def SetAttrs(self, attrs=None):
        fo.CCompositionBase.SetAttrs(self, attrs)
        self.AddLayoutsFromAttrs()
########################################
## All default values off class' possible attributes should be defined
## These defaults takes precedence over 'CDrawFigure...' defaults

    attr_defaults = fo.merge_dicts(fo.CCompositionBase.attrDefaults(), {
        'layout_front': {
            'rank': 1
        },
        'layout_back': {
            'rank': 2
        },
    })
    ########################################
    @property
    def LayoutsPos(self):
        return self.layouts_pos

    @property
    def LayoutsCount(self):
        return len(self.layouts_ordered)

    @property
    def LastLayout(self):
        return self.layouts_ordered[self.LayoutsPos]

    ## Executes range of layouts,
    ## if there are any left,
    ## which inserts figure objects.
    ## It is designed to be called multiple times
    ## and to step either by layout or whole rank.
    ## Do not override this.
    ## By default, process all layouts and ranks
    ## (when step is 'None').
    ## Returns whether any layout was processed.
    def LayoutFigure(self, rank_step=None, layout_step=None):
        start = self.LayoutsPos + 1
        end = self.LayoutsCount if layout_step == None else min(
            start + layout_step, self.LayoutsCount)
        layouts = self.layouts_ordered[start:end]

        if not layouts or (rank_step != None and rank_step <= 0):
            return False

        flag = False
        for layout in layouts:
            if layout.flag:
                flag = True
                next_rank = layout.Layout(self.layouts_rank)
                if (next_rank != None and next_rank > self.layouts_rank
                        and (self.layouts_next_rank == None
                             or next_rank < self.layouts_next_rank)):
                    self.layouts_next_rank = next_rank
        self.layouts_pos = end - 1

        if (self.LayoutsPos == self.LayoutsCount - 1
                and self.layouts_next_rank != None
                and self.layouts_next_rank > self.layouts_rank):
            ## All layouts processed, but not all ranks -> next cycle
            self.layouts_rank = self.layouts_next_rank
            self.layouts_next_rank = None
            self.layouts_pos = -1
            if rank_step != None:
                rank_step -= 1
                if rank_step <= 0:
                    ## Given step of ranks exceeded
                    return flag
            flag |= self.LayoutFigure(rank_step, layout_step)
        return flag
Пример #14
0
class CLayout(fo.CCompositionBase):
    """
   Class of single layout that is or is not applied
   to figure layout
   -> it adds methods to create objects relating to layout
   and inserts the most common ones automatically.
   One can inherit layout classes in two ways:
     1) Inherit only superclass' default attributes and methods,
        but do not use superclass' 'Layout'. These classes are treated as 'additional'
        as their behaviour does not overlay with superclass.
        One may possibly have included sth. like 'Add' to class' identifier to notify this feature.
     2) As 1), but use superclass' 'Layout'. These classes should represent
        concrete end standalone layouts, that are mutually disjunct,
        thus one should use only one class 'chain',
        but additional layouts should be still used at no harm.
   In both cases, one may want to define an 'incomplete' class
   that is to be extended. These classes should have set 'flag' to 'False'
   to avoid multiple calls of 'Layout' from its subclasses
   and possibly have appended an '_' to its identifier to notify this feature.

   Each layout can contain multiple branches that will be executed in order
   according to rank among other layouts - lesser ranks are executed first
   in all layouts. This is necessary when there are any dependencies between figure objects,
   e.g. when one wants to deepcopy figure object,
   it has to be done after insertion of all subobjects into copied object.
   Also, whole layout can have rank, which defines order of layouts
   within an branch rank iteration. This is useful only in cases
   when for some reason multiple layouts has same rank of branch
   and one wants certain layouts to take precedence,
   typically root objects at branch rank 0.
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    ## These defaults takes precedence over 'CDrawFigure...' defaults
    attr_defaults = fo.merge_dicts(
        fo.CCompositionBase.attrDefaults(), {
            'flag': True,
            'width_mm': 0,
            'height_mm': 0,
            'xalign': 'left',
            'yalign': 'top',
            'xoffs_mm': 0,
            'yoffs_mm': 0,
            'xloc': 'sameas',
            'yloc': 'sameas',
            'add_xoffs_mm': 0,
            'add_yoffs_mm': 0,
            'parent': None,
            'margin_mm': 0,
            'opacity': 100,
            'new_opacity': None,
            'new_width_mm': None,
            'new_height_mm': None,
            'new_margin_mm': None,
            'scale': 1,
            'draw_object_args': {},
        })

    ## Branch ranks used only within this class' 'Layout'
    local_ranks = [0]
    ## Disable inheritance if 'ranks_' as it will be merged in 'ranks()'
    ranks_ = None
    ########################################
    @classmethod
    def ranks(cls):
        if not cls.ranks_:
            superclass = cls.__bases__[0]
            cls.ranks_ = fo.merge_lists(
                [] if not hasattr(superclass, 'ranks') else superclass.ranks(),
                cls.local_ranks)
            cls.local_ranks = None
        return cls.ranks_

    def Ranks(self):
        return self.__class__.ranks()
########################################

    @property
    def LayoutKey(self):
        id_ = self.__class__.__name__[len('CLayout'):]
        key = ''
        for c in id_:
            if c.islower():
                key += c
            else:
                key += "_" + c.lower()
        return key[1:] if key[-1] != "_" else key[1:-1]
########################################
## Insert figure object to layout,
## i.e. insert it into its parent
## that may not have been inserted yet,
## or into explicit parent

    def InsertObject(self, object_, parent=None):
        if parent == None:
            parent = object_.parent
        if parent != None:
            parent.InsertObject(object_)
########################################
## Returns newly created figure object,
## which is automatically added into layout
## and will be inserted in next 'DoLayout' call
## 'SetDrawObjectClass' should have beeen called before

    def AddObjectToLayout(self,
                          key,
                          width_mm=fo.DEFAULT,
                          height_mm=fo.DEFAULT,
                          parent=fo.DEFAULT,
                          xalign=fo.DEFAULT,
                          yalign=fo.DEFAULT,
                          xoffs_mm=fo.DEFAULT,
                          yoffs_mm=fo.DEFAULT,
                          margin_mm=fo.DEFAULT,
                          opacity=fo.DEFAULT,
                          **draw_object_args):
        self.SetFunctionAttrDefaults(key, 2)
        parent = self.args.parent
        root_object = self._dummy_object if parent == None else parent.RootObject
        if parent == None:
            parent = root_object

        obj = fo.CFigObject(key,
                            figure=self.ptr,
                            resolution_ppi=self.Resolution_ppi,
                            width_mm=self.args.width_mm,
                            height_mm=self.args.height_mm,
                            xalign=self.args.xalign,
                            yalign=self.args.yalign,
                            xoffs_mm=self.args.xoffs_mm,
                            yoffs_mm=self.args.yoffs_mm,
                            parent=parent,
                            margin_mm=self.args.margin_mm,
                            opacity=self.args.opacity,
                            draw_class=self.draw.draw_object_class,
                            **self.args.draw_object_args)

        self.InsertObject(obj)
        self.CleanFunctionAttrDefaults()
        return obj

    def AddRootObjectToLayout(self,
                              key,
                              margin_mm=fo.DEFAULT,
                              opacity=fo.DEFAULT,
                              **draw_object_args):
        return self.AddObjectToLayout(key,
                                      width_mm=self.Width_mm,
                                      height_mm=self.Height_mm,
                                      margin_mm=margin_mm,
                                      opacity=opacity,
                                      **draw_object_args)

    def AddObjectCopyToLayout(self,
                              object_,
                              deepcopy=True,
                              new_key=None,
                              new_parent=None,
                              xloc=fo.DEFAULT,
                              yloc=fo.DEFAULT,
                              add_xoffs_mm=fo.DEFAULT,
                              add_yoffs_mm=fo.DEFAULT,
                              new_opacity=fo.DEFAULT,
                              new_width_mm=fo.DEFAULT,
                              new_height_mm=fo.DEFAULT,
                              new_margin_mm=fo.DEFAULT,
                              scale=fo.DEFAULT,
                              **draw_object_args):
        obj = cp.copy(object_) if not deepcopy else cp.deepcopy(object_)
        obj.SetKey(new_key)
        if new_parent != None:
            obj.SetParent(new_parent)

        self.SetFunctionAttrDefaults(obj.key, 2)
        obj.SetOpacity(self.args.new_opacity)

        obj.SetSize(scale=self.args.scale,
                    width_mm=self.args.new_width_mm,
                    height_mm=self.args.new_height_mm,
                    margin_mm=self.args.new_margin_mm)
        obj.SetPosFromObject(object_,
                             xloc=self.args.xloc,
                             yloc=self.args.yloc,
                             add_xoffs_mm=self.args.add_xoffs_mm,
                             add_yoffs_mm=self.args.add_yoffs_mm)
        obj.SetDrawObjectAttrs(**self.args.draw_object_args)

        self.InsertObject(obj)
        self.CleanFunctionAttrDefaults()
        return obj

    def AddObjectGroupToLayout(self,
                               key_prefix,
                               parent,
                               xalign=fo.DEFAULT,
                               yalign=fo.DEFAULT,
                               xoffs_mm=fo.DEFAULT,
                               yoffs_mm=fo.DEFAULT,
                               opacity=fo.DEFAULT,
                               **draw_object_args):
        if key_prefix[-1] == '_':
            key_prefix = key_prefix[:-1]
        key = key_prefix + '_group'
        obj = self.AddObjectToLayout(key,
                                     parent=parent,
                                     xalign=xalign,
                                     yalign=yalign,
                                     xoffs_mm=xoffs_mm,
                                     yoffs_mm=yoffs_mm,
                                     opacity=opacity,
                                     **draw_object_args)
        return obj

    ## One often wants to use 'None' in 'xloc' and 'yloc'
    ## (do not discard previous position by default)
    def addObjectToGroup(
        self,
        parent,
        object_,
        xloc=fo.DEFAULT,
        add_xoffs_mm=fo.DEFAULT,
        yloc=fo.DEFAULT,
        add_yoffs_mm=fo.DEFAULT,
    ):
        self.SetFunctionAttrDefaults(object_.key, 3)
        object_.SetParent(parent)
        if parent.ObjectsCount > 1:
            object_.SetPosFromObject(
                parent.objects_ordered[-1],
                xloc=self.args.xloc,
                add_xoffs_mm=self.args.add_xoffs_mm,
                yloc=self.args.yloc,
                add_yoffs_mm=self.args.add_yoffs_mm,
            )
        self.InsertObject(object_)
        self.CleanFunctionAttrDefaults()
        return object_

    def AddObjectToGroup(self,
                         key,
                         parent,
                         width_mm=fo.DEFAULT,
                         height_mm=fo.DEFAULT,
                         xalign=fo.DEFAULT,
                         xoffs_mm=fo.DEFAULT,
                         yalign=fo.DEFAULT,
                         yoffs_mm=fo.DEFAULT,
                         xloc=fo.DEFAULT,
                         add_xoffs_mm=fo.DEFAULT,
                         yloc=fo.DEFAULT,
                         add_yoffs_mm=fo.DEFAULT,
                         margin_mm=fo.DEFAULT,
                         opacity=fo.DEFAULT,
                         **draw_object_args):
        obj = self.AddObjectToLayout(key=key,
                                     width_mm=width_mm,
                                     height_mm=height_mm,
                                     xalign=xalign,
                                     xoffs_mm=xoffs_mm,
                                     yalign=yalign,
                                     yoffs_mm=yoffs_mm,
                                     margin_mm=margin_mm,
                                     opacity=opacity,
                                     **draw_object_args)
        obj = self.addObjectToGroup(
            parent,
            obj,
            xloc=xloc,
            add_xoffs_mm=add_xoffs_mm,
            yloc=yloc,
            add_yoffs_mm=add_yoffs_mm,
        )
        return obj
########################################

    def ReturnRank(self, act_rank):
        for rank in self.Ranks():
            if act_rank < rank:
                return rank
        return None

    ## Each rank is called only once.
    ## Return next rank that is to be called,
    ## or current rank if there it no one.
    ## Override this to set and insert all common objects according to layout
    def Layout(self, rank=0):
        ##! It would be better to use 'cls.local_ranks' to remove redundancy.
        ##! But how to access it independently of the object?
        ##! (Object of some subclass knows only 'local_ranks' of its class,
        ##! not of its superclasses.)
        if rank == 0:
            pass
        return self.ReturnRank(rank)
Пример #15
0
 def AttrsFromShared(self, idx, attr_key, **args):
     shared_attrs = getattr(self, 'shared_' + attr_key)
     figures_attrs_key = 'figures_' + attr_key
     figs_attrs = getattr(self, figures_attrs_key)
     fig_attrs = {} if idx >= len(figs_attrs) else figs_attrs[idx]
     return fo.merge_dicts(shared_attrs, fig_attrs, args)
Пример #16
0
class CLayoutMysteriaCard_(fig.CLayout):
    """
   Incomplete layout class of all kinds of Mysteria cards.
   Incomplete within the meaning of that one certainly wants to use some of its subclasses.
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        fig.CLayout.attrDefaults(), {
            'flag': False,
            'mini_height_mm': 12.5,
            'mini_xloc': 'right',
            'mini_add_xoffs_mm': -1,
            'mini_yloc': 'centerof',
            'mini_2': False,
            'mini_2_xloc': 'mirror',
            'mini_2_scale': 1.2,
            'label_width_mm': 28,
            'label_height_mm': 5,
            'label_margin_mm': 0.4,
            'label_xalign': 'center',
            'label_xoffs_mm': 1.1,
            'label_yoffs_mm': 5,
            'label_draw_object_args': {
                'effect_fill': {
                    'type': 'gradient',
                    'color1': "white",
                    'color2': "lime",
                    'angle': 80,
                    'ratio': 2
                },
                'effect_border': {
                    'type': 'color',
                    'color': "black"
                },
                'effect_text': {
                    'type': '',
                    'text': "Card name",
                    'fg_color': "black",
                    'size_pt': 9.5
                },
                'effect_shear': {
                    'mag_x': -30
                },
            },
            'picture_width_mm': 30,
            'picture_height_mm': 45,
            'picture_xalign': 'left',
            'picture_xoffs_mm': 1,
            'picture_yloc': 'below',
            'picture_add_yoffs_mm': 10,
            'picture_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
        })

    local_ranks = [0, 10]
    ranks_ = None

    ########################################
    def AddObjectBackMiniToLayout(
        self,
        xloc=fo.DEFAULT,
        add_xoffs_mm=fo.DEFAULT,
        add_yoffs_mm=fo.DEFAULT,
    ):
        obj = self.AddObjectCopyToLayout(self.back,
                                         new_key='mini',
                                         new_parent=self.front,
                                         xloc=xloc,
                                         add_xoffs_mm=add_xoffs_mm,
                                         add_yoffs_mm=add_yoffs_mm,
                                         scale=(self.mini_height_mm /
                                                self.back.Height_mm))
        return obj
########################################

    def Layout(self, rank=0):
        if rank == 0:
            label = self.AddObjectToLayout('label', parent=self.front)
            pic = self.AddObjectToLayout('picture', parent=self.front)
            pic.SetPosFromObject(label,
                                 xloc=None,
                                 yloc=self.picture_yloc,
                                 add_yoffs_mm=self.picture_add_yoffs_mm)
        elif rank == 10:
            mini = self.AddObjectBackMiniToLayout()
            mini.SetPosFromObject(self.front.GetObjectByKeyBase('label'),
                                  xloc=None,
                                  yloc=self.mini_yloc)
            if self.mini_2:
                mini_2 = self.AddObjectCopyToLayout(mini, new_key='mini_2')
        return self.ReturnRank(rank)
Пример #17
0
class CLayoutMysteriaCardHold_(CLayoutMysteriaCard_):
    """
   Incomplete layout class of Mysteria hold cards
   -> all cards that players play with directly
   (they hold them in hand or have them in packs)
   """
    ########################################
    ## All default values off class' possible attributes should be defined
    attr_defaults = fo.merge_dicts(
        CLayoutMysteriaCard_.attrDefaults(), {
            'flag': False,
            'back_artifacts_group_xalign': 'center',
            'back_artifacts_group_add_yoffs_mm': 4,
            'category_icons_group_xalign': 'center',
            'category_icons_group_yalign': 'bottom',
            'category_icons_group_yoffs_mm': -3,
            'importance_group_xoffs_mm': 1,
            'importance_group_yoffs_mm': 1,
            'category_importance': 1,
            'category_importance_width_mm': 5,
            'category_importance_height_mm': 5,
            'category_importance_yalign': 'center',
            'category_importance_draw_object_args': {
                'effect_text': {
                    'type': ''
                },
            },
            'class_importance': 1,
            'class_importance_width_mm': 4.5,
            'class_importance_height_mm': 4.5,
            'class_importance_yalign': 'center',
            'class_importance_xloc': 'rightof',
            'class_importance_add_xoffs_mm': 0.2,
            'class_importance_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
            'prestige': 0,
            'prestige_group_xoffs_mm': 0.5,
            'prestige_group_yalign': 'bottom',
            'prestige_group_yoffs_mm': -0.5,
            'prestige_text_width_mm': 6,
            'prestige_text_height_mm': 3,
            'prestige_text_draw_object_args': {
                'effect_text': {
                    'type': ''
                },
            },
            'prestige_class_width_mm': 3,
            'prestige_class_height_mm': 3,
            'prestige_class_draw_object_args': {
                'effect_fill': {
                    'type': 'picture'
                },
            },
        })

    local_ranks = [0]
    ranks_ = None

    ########################################
    def AddObjectIconToLayout(self,
                              key,
                              icons_obj,
                              scale=fo.DEFAULT,
                              add_xoffs_mm=fo.DEFAULT,
                              opacity=fo.DEFAULT,
                              **draw_object_args):
        self.SetFunctionAttrDefaults(key, 3)
        obj = self.AddObjectToGroup(key,
                                    icons_obj,
                                    xloc='rightof',
                                    add_xoffs_mm=add_xoffs_mm,
                                    opacity=opacity,
                                    **draw_object_args)
        obj.SetSizeFromObject(self.back, scale=self.args.scale)
        obj.AddDrawEffectFromObject(self.back, 'border')
        self.CleanFunctionAttrDefaults()
        return obj

    def AddObjectPrestigeToLayout(self):
        key = 'prestige'
        group = self.AddObjectGroupToLayout(key, parent=self.front)

        if self.prestige != 0:
            text_obj = self.AddObjectToGroup(
                parent=group,
                key=key + '_text',
                effect_text={
                    'text': "%+d" % self.prestige,
                    'fg_color': "lime" if self.prestige > 0 else "red"
                })
            ##!class_obj ~ prestiz vrstvy

        return group
########################################

    def Layout(self, rank=0):
        CLayoutMysteriaCard_.Layout(self, rank)
        if rank == 0:
            importance_left = self.AddObjectGroupToLayout('importance',
                                                          parent=self.back)
            category_importance_left = self.AddObjectToGroup(
                'category_importance',
                parent=importance_left,
                effect_text={'text': str(self.category_importance)})
            class_importance_left = self.AddObjectToGroup(
                'class_importance', parent=importance_left)
            importance_right = self.AddObjectCopyToLayout(importance_left,
                                                          xloc='mirror')

            back_artifacts = self.AddObjectGroupToLayout('back_artifacts',
                                                         parent=self.back)
            back_artifacts.SetPosFromObject(
                importance_left,
                xloc=None,
                yloc='below',
                add_yoffs_mm=self.back_artifacts_group_add_yoffs_mm,
            )

            category_icons = self.AddObjectGroupToLayout(
                'category_icons', self.back)

            prestige_group = self.AddObjectPrestigeToLayout()
        return self.ReturnRank(rank)
Пример #18
0
    def SetFigureAttr(self, attrs_key, attr_key, attr_val):
        attrs = getattr(self, attrs_key)

        if self.AcceptFigureAttr(attrs, attr_key, attr_val):
            attrs[attr_key] = fo.merge_dicts(
                attrs[attr_key], attr_val) if attr_key in attrs else attr_val