Ejemplo n.º 1
0
    def parsePadding(cls, attrs, apply =False, overrides =None, extract = False, group =None,
                     allowFailure =False, defaultValue =None):
        pad, keyData = attrs.get(
            TagAttributesEnum.PADDING,
            defaultValue=ArgsUtils.get('paddingDef', defaultValue, overrides),
            overrides=overrides,
            extract=extract,
            returnKey=True
        )

        if not pad:
            return None

        try:
            if isinstance(pad, basestring):
                pad = pad.lower().replace(u' ', '')
                out = AttributeUtils.parseSizeEnumValues(
                    source=pad,
                    values=cls._PAD_VALUES,
                    minValue=0.0,
                    maxValue=5.0
                )

                if isinstance(out, UnitAttribute):
                    out.setDefaultUnit(u'em')
                    out = out.valueAndUnit
                elif out:
                    out = unicode(out) + u'em'
            else:
                out = []
                for p in pad:
                    pout = AttributeUtils.parseSizeEnumValues(
                        source=p,
                        values=cls._PAD_VALUES,
                        minValue=0.0,
                        maxValue=5.0
                    )

                    if pout:
                        if isinstance(pout, UnitAttribute):
                            pout.setDefaultUnit(u'em')
                            pout = out.valueAndUnit
                        elif pout:
                            pout = unicode(pout) + u'em'
                        out.append(pout)

                out = u' '.join(out)
        except Exception, err:
            if not allowFailure:
                MarkupAttributeError(
                    tag=attrs.tag,
                    errorDef=MarkupAttributeError.BAD_ATTRIBUTE_VALUE,
                    attribute=keyData[0] if keyData else TagAttributesEnum.PADDING[0],
                    attributeData=keyData[1] if keyData else None,
                    attributeGroup=TagAttributesEnum.PADDING,
                    rawValue=pad
                ).log()
            return None
Ejemplo n.º 2
0
    def parseScale(cls, attrs, apply =False, overrides =None, extract =False, useSizeKeys =False,
                   group =None):
        """Doc..."""

        if useSizeKeys:
            keys = TagAttributesEnum.SCALE +  TagAttributesEnum.SIZE
        else:
            keys = TagAttributesEnum.SCALE

        size = attrs.get(keys, None, overrides)

        if size:
            size, bends = AttributeUtils.getValueAndBendCount(size)

            if size.isdigit():
                size = unicode(size) + u'em'
            else:
                sizeUnit = UnitAttribute.createIfValid(size, defaultUnit='em')
                if sizeUnit:
                    size = unicode(sizeUnit.valueAndUnit)
                    attrs.styles.add('font-size', size)
                else:
                    size = AttributeUtils.getAsTShirtEnum(size)
                    if size == GeneralSizeEnum.xxsmall[0]:
                        size = unicode(AttributeUtils.bendValue(0.6, bends, 0.2, 0.8)) + u'em'
                    elif size == GeneralSizeEnum.xsmall[0]:
                        size = unicode(AttributeUtils.bendValue(0.8, bends, 0.6, 1.0)) + u'em'
                    elif size == GeneralSizeEnum.small[0]:
                        size = unicode(AttributeUtils.bendValue(1.0, bends, 0.8, 1.2)) + u'em'
                    elif size == GeneralSizeEnum.medium[0]:
                        size = unicode(AttributeUtils.bendValue(1.2, bends, 1.0, 1.5)) + u'em'
                    elif size == GeneralSizeEnum.large[0]:
                        size = unicode(AttributeUtils.bendValue(1.5, bends, 1.2, 1.8)) + u'em'
                    elif size == GeneralSizeEnum.xlarge[0]:
                        size = unicode(AttributeUtils.bendValue(1.8, bends, 1.5, 2.2)) + u'em'
                    elif size == GeneralSizeEnum.xxlarge[0]:
                        size = unicode(AttributeUtils.bendValue(2.2, bends, 1.8, 3.0)) + u'em'
                    else:
                        size = None

            if size and apply:
                attrs.styles.add('font-size', size, group)

        if extract:
            attrs.remove(keys)

        return size
Ejemplo n.º 3
0
    def _renderImpl(self, **kwargs):
        a = self.attrs

        LayoutAttributeParser.parseScale(a, True)
        LayoutAttributeParser.parseAlignment(a, True)

        self._addColorToGroup(a.styleGroup)

        gutter = a.getAsBool(
            TagAttributesEnum.GUTTER,
            None,
            kwargs,
            allowFailure=True
        )
        if gutter:
            gutter = GeneralSizeEnum.small[0]
        else:
            gutter = a.get(
                TagAttributesEnum.GUTTER,
                None,
                kwargs
            )

        maxW = a.get(
            TagAttributesEnum.MAX_WIDE + TagAttributesEnum.SIZE,
            GeneralSizeEnum.medium[0],
            kwargs
        )

        maxW = AttributeUtils.parseSizeEnumValues(
            maxW,
            [48, 64, 80, 92, 102, 160],
            minValue=24,
            maxValue=240,
            asInt=True
        )
        if isinstance(maxW, UnitAttribute):
            maxW.setDefaultUnit(u'')
            if not maxW.unit:
                maxW = u'~' + unicode(maxW.value)
            else:
                maxW = maxW.valueAndUnit
        elif maxW:
            maxW = u'~' + unicode(maxW)

        if maxW:
            a.vdata.add('maxw', maxW)

        if gutter:
            gutter = AttributeUtils.parseSizeEnumValues(
                gutter,
                [0.25, 0.5, 1.0, 1.5, 2.25, 3.0, 4.0],
                minValue=0.0,
                maxValue=5.0,
            )

            if isinstance(gutter, UnitAttribute):
                gutter.setDefaultUnit(u'em')
                gutter = gutter.valueAndUnit
            elif gutter:
                gutter = unicode(gutter) + u'em'

            if gutter:
                a.styles.add('padding', u'0 ' + unicode(gutter))