class CT_Path2D(BaseOxmlElement): """`a:path` custom element class.""" close = ZeroOrMore("a:close", successors=()) lnTo = ZeroOrMore("a:lnTo", successors=()) moveTo = ZeroOrMore("a:moveTo", successors=()) w = OptionalAttribute("w", ST_PositiveCoordinate) h = OptionalAttribute("h", ST_PositiveCoordinate) def add_close(self): """Return a newly created `a:close` element. The new `a:close` element is appended to this `a:path` element. """ return self._add_close() def add_lnTo(self, x, y): """Return a newly created `a:lnTo` subtree with end point *(x, y)*. The new `a:lnTo` element is appended to this `a:path` element. """ lnTo = self._add_lnTo() pt = lnTo._add_pt() pt.x, pt.y = x, y return lnTo def add_moveTo(self, x, y): """Return a newly created `a:moveTo` subtree with point *(x, y)*. The new `a:moveTo` element is appended to this `a:path` element. """ moveTo = self._add_moveTo() pt = moveTo._add_pt() pt.x, pt.y = x, y return moveTo
class CT_RelativeRect(BaseOxmlElement): """`a:srcRect` element and perhaps others.""" l = OptionalAttribute("l", ST_Percentage, default=0.0) # noqa t = OptionalAttribute("t", ST_Percentage, default=0.0) r = OptionalAttribute("r", ST_Percentage, default=0.0) b = OptionalAttribute("b", ST_Percentage, default=0.0)
class CT_TableCellProperties(BaseOxmlElement): """`a:tcPr` custom element class""" eg_fillProperties = ZeroOrOneChoice( ( Choice("a:noFill"), Choice("a:solidFill"), Choice("a:gradFill"), Choice("a:blipFill"), Choice("a:pattFill"), Choice("a:grpFill"), ), successors=("a:headers", "a:extLst"), ) _tag_seq = ('a:lnL', 'a:lnR', 'a:lnT', 'a:lnB', 'a:solidFill') lnL = ZeroOrOne(nsptagname=_tag_seq[0], successors=_tag_seq[1:]) lnR = ZeroOrOne(nsptagname=_tag_seq[1], successors=_tag_seq[2:]) lnT = ZeroOrOne(nsptagname=_tag_seq[2], successors=_tag_seq[3:]) lnB = ZeroOrOne(nsptagname=_tag_seq[3], successors=_tag_seq[4:]) del _tag_seq anchor = OptionalAttribute("anchor", MSO_VERTICAL_ANCHOR) marL = OptionalAttribute("marL", ST_Coordinate32) marR = OptionalAttribute("marR", ST_Coordinate32) marT = OptionalAttribute("marT", ST_Coordinate32) marB = OptionalAttribute("marB", ST_Coordinate32) def _new_gradFill(self): return CT_GradientFillProperties.new_gradFill()
class CT_LineTailEnd(BaseOxmlElement): """ ''<a:tailEnd>'' """ type = RequiredAttribute('type', ST_LineEndType) w = OptionalAttribute('w', ST_ReletiveSize) len = OptionalAttribute('len', ST_ReletiveSize)
class CT_Placeholder(BaseOxmlElement): """ ``<p:ph>`` custom element class. """ type = OptionalAttribute("type", PP_PLACEHOLDER, default=PP_PLACEHOLDER.OBJECT) orient = OptionalAttribute("orient", ST_Direction, default=ST_Direction.HORZ) sz = OptionalAttribute("sz", ST_PlaceholderSize, default=ST_PlaceholderSize.FULL) idx = OptionalAttribute("idx", XsdUnsignedInt, default=0)
class CT_OleObject(BaseOxmlElement): """`<p:oleObj>` element, container for an OLE object (e.g. Excel file). An OLE object can be either linked or embedded (hence the name). """ progId = OptionalAttribute("progId", XsdString) rId = OptionalAttribute("r:id", XsdString) showAsIcon = OptionalAttribute("showAsIcon", XsdBoolean, default=False) @property def is_embedded(self): """True when this OLE object is embedded, False when it is linked.""" return True if len(self.xpath("./p:embed")) > 0 else False
class CT_NonVisualDrawingProps(BaseOxmlElement): """ ``<p:cNvPr>`` custom element class. """ _tag_seq = ("a:hlinkClick", "a:hlinkHover", "a:extLst") hlinkClick = ZeroOrOne("a:hlinkClick", successors=_tag_seq[1:]) hlinkHover = ZeroOrOne("a:hlinkHover", successors=_tag_seq[2:]) id = RequiredAttribute("id", ST_DrawingElementId) name = RequiredAttribute("name", XsdString) descr = OptionalAttribute("descr", XsdString, default="") hidden = OptionalAttribute("hidden", XsdBoolean, default=False ) title = OptionalAttribute("title", XsdString, default="") del _tag_seq
class CT_TableCellProperties(BaseOxmlElement): """`a:tcPr` custom element class""" eg_fillProperties = ZeroOrOneChoice( (Choice('a:noFill'), Choice('a:solidFill'), Choice('a:gradFill'), Choice('a:blipFill'), Choice('a:pattFill'), Choice('a:grpFill')), successors=('a:headers', 'a:extLst')) anchor = OptionalAttribute('anchor', MSO_VERTICAL_ANCHOR) marL = OptionalAttribute('marL', ST_Coordinate32) marR = OptionalAttribute('marR', ST_Coordinate32) marT = OptionalAttribute('marT', ST_Coordinate32) marB = OptionalAttribute('marB', ST_Coordinate32) def _new_gradFill(self): return CT_GradientFillProperties.new_gradFill()
class CT_PatternFillProperties(BaseOxmlElement): """`a:pattFill` custom element class""" _tag_seq = ('a:fgClr', 'a:bgClr') fgClr = ZeroOrOne('a:fgClr', successors=_tag_seq[1:]) bgClr = ZeroOrOne('a:bgClr', successors=_tag_seq[2:]) del _tag_seq prst = OptionalAttribute('prst', MSO_PATTERN_TYPE) def _new_bgClr(self): """Override default to add minimum subtree.""" xml = ( '<a:bgClr %s>\n' ' <a:srgbClr val="FFFFFF"/>\n' '</a:bgClr>\n' ) % nsdecls('a') bgClr = parse_xml(xml) return bgClr def _new_fgClr(self): """Override default to add minimum subtree.""" xml = ( '<a:fgClr %s>\n' ' <a:srgbClr val="000000"/>\n' '</a:fgClr>\n' ) % nsdecls('a') fgClr = parse_xml(xml) return fgClr
class CT_NonVisualDrawingShapeProps(BaseShapeElement): """ ``<p:cNvSpPr>`` custom element class """ spLocks = ZeroOrOne("a:spLocks") txBox = OptionalAttribute("txBox", XsdBoolean)
class CT_LayoutMode(BaseOxmlElement): """ Used for ``<c:xMode>``, ``<c:yMode>``, ``<c:wMode>``, and ``<c:hMode>`` child elements of CT_ManualLayout. """ val = OptionalAttribute("val", ST_LayoutMode, default=ST_LayoutMode.FACTOR)
class CT_CommonSlideData(BaseOxmlElement): """`p:cSld` element.""" _tag_seq = ("p:bg", "p:spTree", "p:custDataLst", "p:controls", "p:extLst") bg = ZeroOrOne("p:bg", successors=_tag_seq[1:]) spTree = OneAndOnlyOne("p:spTree") del _tag_seq name = OptionalAttribute("name", XsdString, default="") def get_or_add_bgPr(self): """Return `p:bg/p:bgPr` grandchild. If no such grandchild is present, any existing `p:bg` child is first removed and a new default `p:bg` with noFill settings is added. """ bg = self.bg if bg is None or bg.bgPr is None: self._change_to_noFill_bg() return self.bg.bgPr def _change_to_noFill_bg(self): """Establish a `p:bg` child with no-fill settings. Any existing `p:bg` child is first removed. """ self._remove_bg() bg = self.get_or_add_bg() bg.add_noFill_bgPr() return bg
class CT_TextNormalAutofit(BaseOxmlElement): """ <a:normAutofit> element specifying fit text to shape font reduction, etc. """ fontScale = OptionalAttribute('fontScale', ST_TextFontScalePercentOrPercentString, default=100.0)
class CT_NumFmt(BaseOxmlElement): """ ``<c:numFmt>`` element specifying the formatting for number labels on a tick mark or data point. """ formatCode = RequiredAttribute('formatCode', XsdString) sourceLinked = OptionalAttribute('sourceLinked', XsdBoolean)
class CT_LineProperties(BaseOxmlElement): """Custom element class for <a:ln> element""" _tag_seq = ( "a:noFill", "a:solidFill", "a:gradFill", "a:pattFill", "a:prstDash", "a:custDash", "a:round", "a:bevel", "a:miter", "a:headEnd", "a:tailEnd", "a:extLst", ) eg_lineFillProperties = ZeroOrOneChoice( ( Choice("a:noFill"), Choice("a:solidFill"), Choice("a:gradFill"), Choice("a:pattFill"), ), successors=_tag_seq[4:], ) prstDash = ZeroOrOne("a:prstDash", successors=_tag_seq[5:]) custDash = ZeroOrOne("a:custDash", successors=_tag_seq[6:]) del _tag_seq w = OptionalAttribute("w", ST_LineWidth, default=Emu(0)) @property def eg_fillProperties(self): """ Required to fulfill the interface used by dml.fill. """ return self.eg_lineFillProperties @property def prstDash_val(self): """Return value of `val` attribute of `a:prstDash` child. Return |None| if not present. """ prstDash = self.prstDash if prstDash is None: return None return prstDash.val @prstDash_val.setter def prstDash_val(self, val): self._remove_custDash() prstDash = self.get_or_add_prstDash() prstDash.val = val
class CT_Orientation(BaseOxmlElement): """`c:xAx/c:scaling/c:orientation` element, defining category order. Used to reverse the order categories appear in on a bar chart so they start at the top rather than the bottom. Because we read top-to-bottom, the default way looks odd to many and perhaps most folks. Also applicable to value and date axes. """ val = OptionalAttribute("val", ST_Orientation, default=ST_Orientation.MIN_MAX)
class CT_NonVisualDrawingProps(BaseOxmlElement): """ ``<p:cNvPr>`` custom element class. """ _tag_seq = ("a:hlinkClick", "a:hlinkHover", "a:extLst") hlinkClick = ZeroOrOne("a:hlinkClick", successors=_tag_seq[1:]) hlinkHover = ZeroOrOne("a:hlinkHover", successors=_tag_seq[2:]) id = RequiredAttribute("id", ST_DrawingElementId) name = RequiredAttribute("name", XsdString) descr = OptionalAttribute('descr', XsdString) del _tag_seq
class CT_TextCharacterProperties(BaseOxmlElement): """`a:rPr, a:defRPr, and `a:endParaRPr` custom element class. 'rPr' is short for 'run properties', and it corresponds to the |Font| proxy class. """ eg_fillProperties = ZeroOrOneChoice( (Choice('a:noFill'), Choice('a:solidFill'), Choice('a:gradFill'), Choice('a:blipFill'), Choice('a:pattFill'), Choice('a:grpFill')), successors=('a:effectLst', 'a:effectDag', 'a:highlight', 'a:uLnTx', 'a:uLn', 'a:uFillTx', 'a:uFill', 'a:latin', 'a:ea', 'a:cs', 'a:sym', 'a:hlinkClick', 'a:hlinkMouseOver', 'a:rtl', 'a:extLst')) latin = ZeroOrOne('a:latin', successors=('a:ea', 'a:cs', 'a:sym', 'a:hlinkClick', 'a:hlinkMouseOver', 'a:rtl', 'a:extLst')) hlinkClick = ZeroOrOne('a:hlinkClick', successors=('a:hlinkMouseOver', 'a:rtl', 'a:extLst')) lang = OptionalAttribute('lang', MSO_LANGUAGE_ID) sz = OptionalAttribute('sz', ST_TextFontSize) b = OptionalAttribute('b', XsdBoolean) i = OptionalAttribute('i', XsdBoolean) u = OptionalAttribute('u', MSO_TEXT_UNDERLINE_TYPE) def _new_gradFill(self): return CT_GradientFillProperties.new_gradFill() def add_hlinkClick(self, rId): """ Add an <a:hlinkClick> child element with r:id attribute set to *rId*. """ hlinkClick = self.get_or_add_hlinkClick() hlinkClick.rId = rId return hlinkClick
class CT_TableProperties(BaseOxmlElement): """ ``<a:tblPr>`` custom element class """ bandRow = OptionalAttribute('bandRow', XsdBoolean, default=False) bandCol = OptionalAttribute('bandCol', XsdBoolean, default=False) firstRow = OptionalAttribute('firstRow', XsdBoolean, default=False) firstCol = OptionalAttribute('firstCol', XsdBoolean, default=False) lastRow = OptionalAttribute('lastRow', XsdBoolean, default=False) lastCol = OptionalAttribute('lastCol', XsdBoolean, default=False)
class CT_Parent(BaseOxmlElement): """ ``<p:parent>`` element, an invented element for use in testing. """ eg_zooChoice = ZeroOrOneChoice( (Choice('p:choice'), Choice('p:choice2')), successors=('p:oomChild', 'p:oooChild') ) oomChild = OneOrMore('p:oomChild', successors=( 'p:oooChild', 'p:zomChild', 'p:zooChild' )) oooChild = OneAndOnlyOne('p:oooChild') zomChild = ZeroOrMore('p:zomChild', successors=('p:zooChild',)) zooChild = ZeroOrOne('p:zooChild', successors=()) optAttr = OptionalAttribute('p:optAttr', ST_IntegerType) reqAttr = RequiredAttribute('reqAttr', ST_IntegerType)
class CT_Boolean_Explicit(BaseOxmlElement): """Always spells out the `val` attribute, e.g. `val=1`. At least one boolean element is improperly interpreted by one or more versions of PowerPoint. The `c:overlay` element is interpreted as |False| when no `val` attribute is present, contrary to the behavior described in the schema. A remedy for this is to interpret a missing `val` attribute as |True| (consistent with the spec), but always write the attribute whenever there is occasion for changing the element. """ _val = OptionalAttribute('val', XsdBoolean, default=True) @property def val(self): return self._val @val.setter def val(self, value): val_str = '1' if bool(value) is True else '0' self.set('val', val_str)
class CT_TextBodyProperties(BaseOxmlElement): """ <a:bodyPr> custom element class """ eg_textAutoFit = ZeroOrOneChoice( (Choice("a:noAutofit"), Choice("a:normAutofit"), Choice("a:spAutoFit")), successors=("a:scene3d", "a:sp3d", "a:flatTx", "a:extLst"), ) lIns = OptionalAttribute("lIns", ST_Coordinate32, default=Emu(91440)) tIns = OptionalAttribute("tIns", ST_Coordinate32, default=Emu(45720)) rIns = OptionalAttribute("rIns", ST_Coordinate32, default=Emu(91440)) bIns = OptionalAttribute("bIns", ST_Coordinate32, default=Emu(45720)) anchor = OptionalAttribute("anchor", MSO_VERTICAL_ANCHOR) wrap = OptionalAttribute("wrap", ST_TextWrappingType) @property def autofit(self): """ The autofit setting for the text frame, a member of the ``MSO_AUTO_SIZE`` enumeration. """ if self.noAutofit is not None: return MSO_AUTO_SIZE.NONE if self.normAutofit is not None: return MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE if self.spAutoFit is not None: return MSO_AUTO_SIZE.SHAPE_TO_FIT_TEXT return None @autofit.setter def autofit(self, value): if value is not None and value not in MSO_AUTO_SIZE._valid_settings: raise ValueError( "only None or a member of the MSO_AUTO_SIZE enumeration can " "be assigned to CT_TextBodyProperties.autofit, got %s" % value) self._remove_eg_textAutoFit() if value == MSO_AUTO_SIZE.NONE: self._add_noAutofit() elif value == MSO_AUTO_SIZE.TEXT_TO_FIT_SHAPE: self._add_normAutofit() elif value == MSO_AUTO_SIZE.SHAPE_TO_FIT_TEXT: self._add_spAutoFit()
class CT_Blip(BaseOxmlElement): """ <a:blip> element """ rEmbed = OptionalAttribute('r:embed', ST_RelationshipId)
class CT_Boolean(BaseOxmlElement): """ Common complex type used for elements having a True/False value. """ val = OptionalAttribute('val', XsdBoolean, default=True)
class CT_TextCharacterProperties(BaseOxmlElement): """`a:rPr, a:defRPr, and `a:endParaRPr` custom element class. 'rPr' is short for 'run properties', and it corresponds to the |Font| proxy class. """ eg_fillProperties = ZeroOrOneChoice( ( Choice("a:noFill"), Choice("a:solidFill"), Choice("a:gradFill"), Choice("a:blipFill"), Choice("a:pattFill"), Choice("a:grpFill"), ), successors=( "a:effectLst", "a:effectDag", "a:highlight", "a:uLnTx", "a:uLn", "a:uFillTx", "a:uFill", "a:latin", "a:ea", "a:cs", "a:sym", "a:hlinkClick", "a:hlinkMouseOver", "a:rtl", "a:extLst", ), ) latin = ZeroOrOne( "a:latin", successors=( "a:ea", "a:cs", "a:sym", "a:hlinkClick", "a:hlinkMouseOver", "a:rtl", "a:extLst", ), ) hlinkClick = ZeroOrOne("a:hlinkClick", successors=("a:hlinkMouseOver", "a:rtl", "a:extLst")) lang = OptionalAttribute("lang", MSO_LANGUAGE_ID) sz = OptionalAttribute("sz", ST_TextFontSize) b = OptionalAttribute("b", XsdBoolean) i = OptionalAttribute("i", XsdBoolean) baseline = OptionalAttribute("baseline", BaseIntType) u = OptionalAttribute("u", MSO_TEXT_UNDERLINE_TYPE) def _new_gradFill(self): return CT_GradientFillProperties.new_gradFill() def add_hlinkClick(self, rId): """ Add an <a:hlinkClick> child element with r:id attribute set to *rId*. """ hlinkClick = self.get_or_add_hlinkClick() hlinkClick.rId = rId return hlinkClick
class CT_TextParagraphProperties(BaseOxmlElement): """ <a:pPr> custom element class """ _tag_seq = ( "a:lnSpc", "a:spcBef", "a:spcAft", "a:buClrTx", "a:buClr", "a:buSzTx", "a:buSzPct", "a:buSzPts", "a:buFontTx", "a:buFont", "a:buNone", "a:buAutoNum", "a:buChar", "a:buBlip", "a:tabLst", "a:defRPr", "a:extLst", ) lnSpc = ZeroOrOne("a:lnSpc", successors=_tag_seq[1:]) spcBef = ZeroOrOne("a:spcBef", successors=_tag_seq[2:]) spcAft = ZeroOrOne("a:spcAft", successors=_tag_seq[3:]) defRPr = ZeroOrOne("a:defRPr", successors=_tag_seq[16:]) lvl = OptionalAttribute("lvl", ST_TextIndentLevelType, default=0) algn = OptionalAttribute("algn", PP_PARAGRAPH_ALIGNMENT) del _tag_seq @property def line_spacing(self): """ The spacing between baselines of successive lines in this paragraph. A float value indicates a number of lines. A |Length| value indicates a fixed spacing. Value is contained in `./a:lnSpc/a:spcPts/@val` or `./a:lnSpc/a:spcPct/@val`. Value is |None| if no element is present. """ lnSpc = self.lnSpc if lnSpc is None: return None if lnSpc.spcPts is not None: return lnSpc.spcPts.val return lnSpc.spcPct.val @line_spacing.setter def line_spacing(self, value): self._remove_lnSpc() if value is None: return if isinstance(value, Length): self._add_lnSpc().set_spcPts(value) else: self._add_lnSpc().set_spcPct(value) @property def space_after(self): """ The EMU equivalent of the centipoints value in `./a:spcAft/a:spcPts/@val`. """ spcAft = self.spcAft if spcAft is None: return None spcPts = spcAft.spcPts if spcPts is None: return None return spcPts.val @space_after.setter def space_after(self, value): self._remove_spcAft() if value is not None: self._add_spcAft().set_spcPts(value) @property def space_before(self): """ The EMU equivalent of the centipoints value in `./a:spcBef/a:spcPts/@val`. """ spcBef = self.spcBef if spcBef is None: return None spcPts = spcBef.spcPts if spcPts is None: return None return spcPts.val @space_before.setter def space_before(self, value): self._remove_spcBef() if value is not None: self._add_spcBef().set_spcPts(value)
class CT_PresetLineDashProperties(BaseOxmlElement): """`a:prstDash` custom element class""" val = OptionalAttribute("val", MSO_LINE_DASH_STYLE)
class CT_RelativeRect(BaseOxmlElement): """`a:srcRect` element and perhaps others.""" l = OptionalAttribute('l', ST_Percentage, default=0.0) t = OptionalAttribute('t', ST_Percentage, default=0.0) r = OptionalAttribute('r', ST_Percentage, default=0.0) b = OptionalAttribute('b', ST_Percentage, default=0.0)
class CT_TableCell(BaseOxmlElement): """`a:tc` custom element class""" _tag_seq = ("a:txBody", "a:tcPr", "a:extLst") txBody = ZeroOrOne("a:txBody", successors=_tag_seq[1:]) tcPr = ZeroOrOne("a:tcPr", successors=_tag_seq[2:]) del _tag_seq gridSpan = OptionalAttribute("gridSpan", XsdInt, default=1) rowSpan = OptionalAttribute("rowSpan", XsdInt, default=1) hMerge = OptionalAttribute("hMerge", XsdBoolean, default=False) vMerge = OptionalAttribute("vMerge", XsdBoolean, default=False) @property def anchor(self): """ String held in ``anchor`` attribute of ``<a:tcPr>`` child element of this ``<a:tc>`` element. """ if self.tcPr is None: return None return self.tcPr.anchor @anchor.setter def anchor(self, anchor_enum_idx): """ Set value of anchor attribute on ``<a:tcPr>`` child element """ if anchor_enum_idx is None and self.tcPr is None: return tcPr = self.get_or_add_tcPr() tcPr.anchor = anchor_enum_idx def append_ps_from(self, spanned_tc): """Append `a:p` elements taken from *spanned_tc*. Any non-empty paragraph elements in *spanned_tc* are removed and appended to the text-frame of this cell. If *spanned_tc* is left with no content after this process, a single empty `a:p` element is added to ensure the cell is compliant with the spec. """ source_txBody = spanned_tc.get_or_add_txBody() target_txBody = self.get_or_add_txBody() # ---if source is empty, there's nothing to do--- if source_txBody.is_empty: return # ---a single empty paragraph in target is overwritten--- if target_txBody.is_empty: target_txBody.clear_content() for p in source_txBody.p_lst: target_txBody.append(p) # ---neither source nor target can be left without ps--- source_txBody.unclear_content() target_txBody.unclear_content() @property def col_idx(self): """Offset of this cell's column in its table.""" # ---tc elements come before any others in `a:tr` element--- return self.getparent().index(self) @property def is_merge_origin(self): """True if cell is top-left in merged cell range.""" if self.gridSpan > 1 and not self.vMerge: return True if self.rowSpan > 1 and not self.hMerge: return True return False @property def is_spanned(self): """True if cell is in merged cell range but not merge origin cell.""" return self.hMerge or self.vMerge @property def marT(self): """ Read/write integer top margin value represented in ``marT`` attribute of the ``<a:tcPr>`` child element of this ``<a:tc>`` element. If the attribute is not present, the default value ``45720`` (0.05 inches) is returned for top and bottom; ``91440`` (0.10 inches) is the default for left and right. Assigning |None| to any ``marX`` property clears that attribute from the element, effectively setting it to the default value. """ return self._get_marX("marT", 45720) @marT.setter def marT(self, value): self._set_marX("marT", value) @property def marR(self): """ Right margin value represented in ``marR`` attribute. """ return self._get_marX("marR", 91440) @marR.setter def marR(self, value): self._set_marX("marR", value) @property def marB(self): """ Bottom margin value represented in ``marB`` attribute. """ return self._get_marX("marB", 45720) @marB.setter def marB(self, value): self._set_marX("marB", value) @property def marL(self): """ Left margin value represented in ``marL`` attribute. """ return self._get_marX("marL", 91440) @marL.setter def marL(self, value): self._set_marX("marL", value) @classmethod def new(cls): """Return a new `a:tc` element subtree.""" xml = cls._tc_tmpl() tc = parse_xml(xml) return tc @property def row_idx(self): """Offset of this cell's row in its table.""" return self.getparent().row_idx @property def tbl(self): """Table element this cell belongs to.""" return self.xpath("ancestor::a:tbl")[0] @property def text(self): """str text contained in cell""" # ---note this shadows lxml _Element.text--- txBody = self.txBody if txBody is None: return "" return "\n".join([p.text for p in txBody.p_lst]) def _get_marX(self, attr_name, default): """ Generalized method to get margin values. """ if self.tcPr is None: return Emu(default) return Emu(int(self.tcPr.get(attr_name, default))) def _new_txBody(self): return CT_TextBody.new_a_txBody() def _set_marX(self, marX, value): """ Set value of marX attribute on ``<a:tcPr>`` child element. If *marX* is |None|, the marX attribute is removed. *marX* is a string, one of ``('marL', 'marR', 'marT', 'marB')``. """ if value is None and self.tcPr is None: return tcPr = self.get_or_add_tcPr() setattr(tcPr, marX, value) @classmethod def _tc_tmpl(cls): return ( "<a:tc %s>\n" " <a:txBody>\n" " <a:bodyPr/>\n" " <a:lstStyle/>\n" " <a:p/>\n" " </a:txBody>\n" " <a:tcPr/>\n" "</a:tc>" % nsdecls("a") )
class CT_HeadEndProperties(BaseOxmlElement): """`a:headEnd` custom element class""" type = OptionalAttribute('type', MSO_ARROWHEAD_STYLE)