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
Exemple #2
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))