class SortCondition(Serialisable):
tagname = "sortCondition"
descending = Bool(allow_none=True)
sortBy = NoneSet(values=(['value', 'cellColor', 'fontColor', 'icon']))
ref = CellRange()
customList = String(allow_none=True)
dxfId = Integer(allow_none=True)
iconSet = NoneSet(values=([
'3Arrows', '3ArrowsGray', '3Flags', '3TrafficLights1',
'3TrafficLights2', '3Signs', '3Symbols', '3Symbols2', '4Arrows',
'4ArrowsGray', '4RedToBlack', '4Rating', '4TrafficLights', '5Arrows',
'5ArrowsGray', '5Rating', '5Quarters'
]))
iconId = Integer(allow_none=True)
def __init__(
self,
ref=None,
descending=None,
sortBy=None,
customList=None,
dxfId=None,
iconSet=None,
iconId=None,
):
self.descending = descending
self.sortBy = sortBy
self.ref = ref
self.customList = customList
self.dxfId = dxfId
self.iconSet = iconSet
self.iconId = iconId
class Alignment(Serialisable):
"""Alignment options for use in styles."""
tagname = "alignment"
__fields__ = ('horizontal',
'vertical',
'textRotation',
'wrapText',
'shrinkToFit',
'indent',
'relativeIndent',
'justifyLastLine',
'readingOrder',
)
horizontal = NoneSet(values=horizontal_alignments)
vertical = NoneSet(values=vertical_aligments)
textRotation = NoneSet(values=range(181))
textRotation.values.add(255)
text_rotation = Alias('textRotation')
wrapText = Bool(allow_none=True)
wrap_text = Alias('wrapText')
shrinkToFit = Bool(allow_none=True)
shrink_to_fit = Alias('shrinkToFit')
indent = Min(min=0)
relativeIndent = Min(min=0)
justifyLastLine = Bool(allow_none=True)
readingOrder = Min(min=0)
def __init__(self, horizontal=None, vertical=None,
textRotation=0, wrapText=None, shrinkToFit=None, indent=0, relativeIndent=0,
justifyLastLine=None, readingOrder=0, text_rotation=None,
wrap_text=None, shrink_to_fit=None, mergeCell=None):
self.horizontal = horizontal
self.vertical = vertical
self.indent = indent
self.relativeIndent = relativeIndent
self.justifyLastLine = justifyLastLine
self.readingOrder = readingOrder
if text_rotation is not None:
textRotation = text_rotation
if textRotation is not None:
self.textRotation = int(textRotation)
if wrap_text is not None:
wrapText = wrap_text
self.wrapText = wrapText
if shrink_to_fit is not None:
shrinkToFit = shrink_to_fit
self.shrinkToFit = shrinkToFit
# mergeCell is vestigial
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value is not None and value != 0:
yield attr, safe_string(value)
class PivotArea(Serialisable):
tagname = "pivotArea"
references = NestedSequence(expected_type=Reference, count=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
field = Integer(allow_none=True)
type = NoneSet(values=(
['normal', 'data', 'all', 'origin', 'button', 'topEnd', 'topRight']))
dataOnly = Bool(allow_none=True)
labelOnly = Bool(allow_none=True)
grandRow = Bool(allow_none=True)
grandCol = Bool(allow_none=True)
cacheIndex = Bool(allow_none=True)
outline = Bool(allow_none=True)
offset = String(allow_none=True)
collapsedLevelsAreSubtotals = Bool(allow_none=True)
axis = NoneSet(values=(['axisRow', 'axisCol', 'axisPage', 'axisValues']))
fieldPosition = Integer(allow_none=True)
__elements__ = ('references', )
def __init__(
self,
references=(),
extLst=None,
field=None,
type="normal",
dataOnly=True,
labelOnly=None,
grandRow=None,
grandCol=None,
cacheIndex=None,
outline=True,
offset=None,
collapsedLevelsAreSubtotals=None,
axis=None,
fieldPosition=None,
):
self.references = references
self.extLst = extLst
self.field = field
self.type = type
self.dataOnly = dataOnly
self.labelOnly = labelOnly
self.grandRow = grandRow
self.grandCol = grandCol
self.cacheIndex = cacheIndex
self.outline = outline
self.offset = offset
self.collapsedLevelsAreSubtotals = collapsedLevelsAreSubtotals
self.axis = axis
self.fieldPosition = fieldPosition
class ConditionalFormat(Serialisable):
tagname = "conditionalFormat"
scope = Set(values=(['selection', 'data', 'field']))
type = NoneSet(values=(['all', 'row', 'column']))
priority = Integer()
pivotAreas = NestedSequence(expected_type=PivotArea)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('pivotAreas', )
def __init__(
self,
scope=None,
type=None,
priority=None,
pivotAreas=(),
extLst=None,
):
self.scope = scope
self.type = type
self.priority = priority
self.pivotAreas = pivotAreas
self.extLst = extLst
class Filters(Serialisable):
tagname = "filters"
blank = Bool(allow_none=True)
calendarType = NoneSet(values=[
"gregorian", "gregorianUs", "gregorianMeFrench", "gregorianArabic",
"hijri", "hebrew", "taiwan", "japan", "thai", "korea", "saka",
"gregorianXlitEnglish", "gregorianXlitFrench"
])
filter = ValueSequence(expected_type=unicode)
dateGroupItem = Sequence(expected_type=DateGroupItem, allow_none=True)
__elements__ = ('filter', 'dateGroupItem')
def __init__(
self,
blank=None,
calendarType=None,
filter=(),
dateGroupItem=(),
):
self.blank = blank
self.calendarType = calendarType
self.filter = filter
self.dateGroupItem = dateGroupItem
class TwoCellAnchor(_AnchorBase):
tagname = "twoCellAnchor"
editAs = NoneSet(values=(['twoCell', 'oneCell', 'absolute']))
_from = Typed(expected_type=AnchorMarker)
to = Typed(expected_type=AnchorMarker)
sp = _AnchorBase.sp
grpSp = _AnchorBase.grpSp
graphicFrame = _AnchorBase.graphicFrame
cxnSp = _AnchorBase.cxnSp
pic = _AnchorBase.pic
contentPart = _AnchorBase.contentPart
clientData = _AnchorBase.clientData
__elements__ = ('_from', 'to') + _AnchorBase.__elements__
def __init__(self,
editAs=None,
_from=None,
to=None,
**kw
):
self.editAs = editAs
if _from is None:
_from = AnchorMarker()
self._from = _from
if to is None:
to = AnchorMarker()
self.to = to
super(TwoCellAnchor, self).__init__(**kw)
class OLAPSet(Serialisable):
tagname = "set"
count = Integer()
maxRank = Integer()
setDefinition = String()
sortType = NoneSet(values=([
'ascending', 'descending', 'ascendingAlpha', 'descendingAlpha',
'ascendingNatural', 'descendingNatural'
]))
queryFailed = Bool()
tpls = Typed(expected_type=TupleList, allow_none=True)
sortByTuple = Typed(expected_type=TupleList, allow_none=True)
__elements__ = ('tpls', 'sortByTuple')
def __init__(
self,
count=None,
maxRank=None,
setDefinition=None,
sortType=None,
queryFailed=None,
tpls=None,
sortByTuple=None,
):
self.count = count
self.maxRank = maxRank
self.setDefinition = setDefinition
self.sortType = sortType
self.queryFailed = queryFailed
self.tpls = tpls
self.sortByTuple = sortByTuple
class SortState(Serialisable):
tagname = "sortState"
columnSort = Bool(allow_none=True)
caseSensitive = Bool(allow_none=True)
sortMethod = NoneSet(values=(['stroke', 'pinYin']))
ref = CellRange()
sortCondition = Sequence(expected_type=SortCondition, allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('sortCondition', )
def __init__(
self,
columnSort=None,
caseSensitive=None,
sortMethod=None,
ref=None,
sortCondition=(),
extLst=None,
):
self.columnSort = columnSort
self.caseSensitive = caseSensitive
self.sortMethod = sortMethod
self.ref = ref
self.sortCondition = sortCondition
def __bool__(self):
return self.ref is not None
__nonzero__ = __bool__
class CalcProperties(Serialisable):
tagname = "calcPr"
calcId = Integer()
calcMode = NoneSet(values=(['manual', 'auto', 'autoNoTable']))
fullCalcOnLoad = Bool(allow_none=True)
refMode = NoneSet(values=(['A1', 'R1C1']))
iterate = Bool(allow_none=True)
iterateCount = Integer(allow_none=True)
iterateDelta = Float(allow_none=True)
fullPrecision = Bool(allow_none=True)
calcCompleted = Bool(allow_none=True)
calcOnSave = Bool(allow_none=True)
concurrentCalc = Bool(allow_none=True)
concurrentManualCount = Integer(allow_none=True)
forceFullCalc = Bool(allow_none=True)
def __init__(self,
calcId=124519,
calcMode=None,
fullCalcOnLoad=True,
refMode=None,
iterate=None,
iterateCount=None,
iterateDelta=None,
fullPrecision=None,
calcCompleted=None,
calcOnSave=None,
concurrentCalc=None,
concurrentManualCount=None,
forceFullCalc=None,
):
self.calcId = calcId
self.calcMode = calcMode
self.fullCalcOnLoad = fullCalcOnLoad
self.refMode = refMode
self.iterate = iterate
self.iterateCount = iterateCount
self.iterateDelta = iterateDelta
self.fullPrecision = fullPrecision
self.calcCompleted = calcCompleted
self.calcOnSave = calcOnSave
self.concurrentCalc = concurrentCalc
self.concurrentManualCount = concurrentManualCount
self.forceFullCalc = forceFullCalc
class FontReference(Serialisable):
idx = NoneSet(values=(['major', 'minor']))
def __init__(
self,
idx=None,
):
self.idx = idx
class LineEndProperties(Serialisable):
tagname = "end"
namespace = DRAWING_NS
type = NoneSet(
values=(['none', 'triangle', 'stealth', 'diamond', 'oval', 'arrow']))
w = NoneSet(values=(['sm', 'med', 'lg']))
len = NoneSet(values=(['sm', 'med', 'lg']))
def __init__(
self,
type=None,
w=None,
len=None,
):
self.type = type
self.w = w
self.len = len
class PhoneticProperties(Serialisable):
tagname = "phoneticPr"
fontId = Integer()
type = NoneSet(values=(
['halfwidthKatakana', 'fullwidthKatakana', 'Hiragana', 'noConversion']
))
alignment = NoneSet(
values=(['noControl', 'left', 'center', 'distributed']))
def __init__(
self,
fontId=None,
type=None,
alignment=None,
):
self.fontId = fontId
self.type = type
self.alignment = alignment
class BookView(Serialisable):
tagname = "workbookView"
visibility = NoneSet(values=(['visible', 'hidden', 'veryHidden']))
minimized = Bool(allow_none=True)
showHorizontalScroll = Bool(allow_none=True)
showVerticalScroll = Bool(allow_none=True)
showSheetTabs = Bool(allow_none=True)
xWindow = Integer(allow_none=True)
yWindow = Integer(allow_none=True)
windowWidth = Integer(allow_none=True)
windowHeight = Integer(allow_none=True)
tabRatio = Integer(allow_none=True)
firstSheet = Integer(allow_none=True)
activeTab = Integer(allow_none=True)
autoFilterDateGrouping = Bool(allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
visibility="visible",
minimized=False,
showHorizontalScroll=True,
showVerticalScroll=True,
showSheetTabs=True,
xWindow=None,
yWindow=None,
windowWidth=None,
windowHeight=None,
tabRatio=600,
firstSheet=0,
activeTab=0,
autoFilterDateGrouping=True,
extLst=None,
):
self.visibility = visibility
self.minimized = minimized
self.showHorizontalScroll = showHorizontalScroll
self.showVerticalScroll = showVerticalScroll
self.showSheetTabs = showSheetTabs
self.xWindow = xWindow
self.yWindow = yWindow
self.windowWidth = windowWidth
self.windowHeight = windowHeight
self.tabRatio = tabRatio
self.firstSheet = firstSheet
self.activeTab = activeTab
self.autoFilterDateGrouping = autoFilterDateGrouping
class SmartTagProperties(Serialisable):
tagname = "smartTagPr"
embed = Bool(allow_none=True)
show = NoneSet(values=(['all', 'noIndicator']))
def __init__(
self,
embed=None,
show=None,
):
self.embed = embed
self.show = show
class Selection(Serialisable):
pane = NoneSet(values=("bottomRight", "topRight", "bottomLeft", "topLeft"))
activeCell = String(allow_none=True)
activeCellId = Integer(allow_none=True)
sqref = String(allow_none=True)
def __init__(self,
pane=None,
activeCell="A1",
activeCellId=None,
sqref="A1"):
self.pane = pane
self.activeCell = activeCell
self.activeCellId = activeCellId
self.sqref = sqref
class PatternFill(Fill):
"""Area fill patterns for use in styles.
Caution: if you do not specify a fill_type, other attributes will have
no effect !"""
tagname = "patternFill"
__elements__ = ('fgColor', 'bgColor')
patternType = NoneSet(values=fills)
fill_type = Alias("patternType")
fgColor = ColorDescriptor()
start_color = Alias("fgColor")
bgColor = ColorDescriptor()
end_color = Alias("bgColor")
def __init__(self, patternType=None, fgColor=Color(), bgColor=Color(),
fill_type=None, start_color=None, end_color=None):
if fill_type is not None:
patternType = fill_type
self.patternType = patternType
if start_color is not None:
fgColor = start_color
self.fgColor = fgColor
if end_color is not None:
bgColor = end_color
self.bgColor = bgColor
@classmethod
def _from_tree(cls, el):
attrib = dict(el.attrib)
for child in el:
desc = localname(child)
attrib[desc] = Color.from_tree(child)
return cls(**attrib)
def to_tree(self, tagname=None, idx=None):
parent = Element("fill")
el = Element(self.tagname)
if self.patternType is not None:
el.set('patternType', self.patternType)
for c in self.__elements__:
value = getattr(self, c)
if value != Color():
el.append(value.to_tree(c))
parent.append(el)
return parent
class ExternalCell(Serialisable):
r = String()
t = NoneSet(values=(['b', 'd', 'n', 'e', 's', 'str', 'inlineStr']))
vm = Integer(allow_none=True)
v = NestedText(allow_none=True, expected_type=unicode)
def __init__(self,
r=None,
t=None,
vm=None,
v=None,
):
self.r = r
self.t = t
self.vm = vm
self.v = v
class CustomFilter(Serialisable):
tagname = "customFilter"
operator = NoneSet(values=([
'equal', 'lessThan', 'lessThanOrEqual', 'notEqual',
'greaterThanOrEqual', 'greaterThan'
]))
val = String()
def __init__(
self,
operator=None,
val=None,
):
self.operator = operator
self.val = val
class Side(Serialisable):
"""Border options for use in styles.
Caution: if you do not specify a border_style, other attributes will
have no effect !"""
__fields__ = ('style', 'color')
color = ColorDescriptor(allow_none=True)
style = NoneSet(values=('dashDot', 'dashDotDot', 'dashed', 'dotted',
'double', 'hair', 'medium', 'mediumDashDot',
'mediumDashDotDot', 'mediumDashed', 'slantDashDot',
'thick', 'thin'))
border_style = Alias('style')
def __init__(self, style=None, color=None, border_style=None):
if border_style is not None:
style = border_style
self.style = style
self.color = color
class Bevel(Serialisable):
tagname = "bevel"
w = Integer()
h = Integer()
prst = NoneSet(values=[
'relaxedInset', 'circle', 'slope', 'cross', 'angle', 'softRound',
'convex', 'coolSlant', 'divot', 'riblet', 'hardEdge', 'artDeco'
])
def __init__(
self,
w=None,
h=None,
prst=None,
):
self.w = w
self.h = h
self.prst = prst
class Format(Serialisable):
tagname = "format"
action = NoneSet(values=(['blank', 'formatting', 'drill', 'formula']))
dxfId = Integer()
pivotArea = Typed(expected_type=PivotArea, )
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('pivotArea', )
def __init__(
self,
action=None,
dxfId=None,
pivotArea=None,
extLst=None,
):
self.action = action
self.dxfId = dxfId
self.pivotArea = pivotArea
self.extLst = extLst
class Shape3D(Serialisable):
namespace = DRAWING_NS
z = Typed(expected_type=Coordinate, allow_none=True)
extrusionH = Integer(allow_none=True)
contourW = Integer(allow_none=True)
prstMaterial = NoneSet(values=[
'legacyMatte', 'legacyPlastic', 'legacyMetal', 'legacyWireframe',
'matte', 'plastic', 'metal', 'warmMatte', 'translucentPowder',
'powder', 'dkEdge', 'softEdge', 'clear', 'flat', 'softmetal'
])
bevelT = Typed(expected_type=Bevel, allow_none=True)
bevelB = Typed(expected_type=Bevel, allow_none=True)
extrusionClr = Typed(expected_type=Color, allow_none=True)
contourClr = Typed(expected_type=Color, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
def __init__(
self,
z=None,
extrusionH=None,
contourW=None,
prstMaterial=None,
bevelT=None,
bevelB=None,
extrusionClr=None,
contourClr=None,
extLst=None,
):
self.z = z
self.extrusionH = extrusionH
self.contourW = contourW
self.prstMaterial = prstMaterial
self.bevelT = bevelT
self.bevelB = bevelB
self.extrusionClr = extrusionClr
self.contourClr = contourClr
self.extLst = extLst
class Path2D(Serialisable):
w = Float()
h = Float()
fill = NoneSet(
values=(['norm', 'lighten', 'lightenLess', 'darken', 'darkenLess']))
stroke = Bool(allow_none=True)
extrusionOk = Bool(allow_none=True)
def __init__(
self,
w=None,
h=None,
fill=None,
stroke=None,
extrusionOk=None,
):
self.w = w
self.h = h
self.fill = fill
self.stroke = stroke
self.extrusionOk = extrusionOk
class GroupShapeProperties(Serialisable):
tagname = "grpSpPr"
bwMode = NoneSet(values=([
'clr', 'auto', 'gray', 'ltGray', 'invGray', 'grayWhite', 'blackGray',
'blackWhite', 'black', 'white', 'hidden'
]))
xfrm = Typed(expected_type=GroupTransform2D, allow_none=True)
scene3d = Typed(expected_type=Scene3D, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
def __init__(
self,
bwMode=None,
xfrm=None,
scene3d=None,
extLst=None,
):
self.bwMode = bwMode
self.xfrm = xfrm
self.scene3d = scene3d
self.extLst = extLst
class WebPublishing(Serialisable):
tagname = "webPublishing"
css = Bool(allow_none=True)
thicket = Bool(allow_none=True)
longFileNames = Bool(allow_none=True)
vml = Bool(allow_none=True)
allowPng = Bool(allow_none=True)
targetScreenSize = NoneSet(values=(['544x376', '640x480', '720x512', '800x600',
'1024x768', '1152x882', '1152x900', '1280x1024', '1600x1200',
'1800x1440', '1920x1200']))
dpi = Integer(allow_none=True)
codePage = Integer(allow_none=True)
characterSet = String(allow_none=True)
def __init__(self,
css=None,
thicket=None,
longFileNames=None,
vml=None,
allowPng=None,
targetScreenSize='800x600',
dpi=None,
codePage=None,
characterSet=None,
):
self.css = css
self.thicket = thicket
self.longFileNames = longFileNames
self.vml = vml
self.allowPng = allowPng
self.targetScreenSize = targetScreenSize
self.dpi = dpi
self.codePage = codePage
self.characterSet = characterSet
class PrintPageSetup(Serialisable):
""" Worksheet print page setup """
tagname = "pageSetup"
orientation = NoneSet(values=("default", "portrait", "landscape"))
paperSize = Integer(allow_none=True)
scale = Integer(allow_none=True)
fitToHeight = Integer(allow_none=True)
fitToWidth = Integer(allow_none=True)
firstPageNumber = Integer(allow_none=True)
useFirstPageNumber = Bool(allow_none=True)
paperHeight = UniversalMeasure(allow_none=True)
paperWidth = UniversalMeasure(allow_none=True)
pageOrder = NoneSet(values=("downThenOver", "overThenDown"))
usePrinterDefaults = Bool(allow_none=True)
blackAndWhite = Bool(allow_none=True)
draft = Bool(allow_none=True)
cellComments = NoneSet(values=("asDisplayed", "atEnd"))
errors = NoneSet(values=("displayed", "blank", "dash", "NA"))
horizontalDpi = Integer(allow_none=True)
verticalDpi = Integer(allow_none=True)
copies = Integer(allow_none=True)
id = Relation()
def __init__(self,
worksheet=None,
orientation=None,
paperSize=None,
scale=None,
fitToHeight=None,
fitToWidth=None,
firstPageNumber=None,
useFirstPageNumber=None,
paperHeight=None,
paperWidth=None,
pageOrder=None,
usePrinterDefaults=None,
blackAndWhite=None,
draft=None,
cellComments=None,
errors=None,
horizontalDpi=None,
verticalDpi=None,
copies=None,
id=None):
self._parent = worksheet
self.orientation = orientation
self.paperSize = paperSize
self.scale = scale
self.fitToHeight = fitToHeight
self.fitToWidth = fitToWidth
self.firstPageNumber = firstPageNumber
self.useFirstPageNumber = useFirstPageNumber
self.paperHeight = paperHeight
self.paperWidth = paperWidth
self.pageOrder = pageOrder
self.usePrinterDefaults = usePrinterDefaults
self.blackAndWhite = blackAndWhite
self.draft = draft
self.cellComments = cellComments
self.errors = errors
self.horizontalDpi = horizontalDpi
self.verticalDpi = verticalDpi
self.copies = copies
self.id = id
@property
def sheet_properties(self):
"""
Proxy property
"""
return self._parent.sheet_properties.pageSetUpPr
@property
def fitToPage(self):
return self.sheet_properties.fitToPage
@fitToPage.setter
def fitToPage(self, value):
self.sheet_properties.fitToPage = value
@property
def autoPageBreaks(self):
return self.sheet_properties.autoPageBreaks
@autoPageBreaks.setter
def autoPageBreaks(self, value):
self.sheet_properties.autoPageBreaks = value
@classmethod
def from_tree(cls, node):
self = super(PrintPageSetup, cls).from_tree(node)
self.id = None # strip link to binary settings
return self
class CustomWorkbookView(Serialisable):
tagname = "customWorkbookView"
name = String()
guid = Guid()
autoUpdate = Bool(allow_none=True)
mergeInterval = Integer(allow_none=True)
changesSavedWin = Bool(allow_none=True)
onlySync = Bool(allow_none=True)
personalView = Bool(allow_none=True)
includePrintSettings = Bool(allow_none=True)
includeHiddenRowCol = Bool(allow_none=True)
maximized = Bool(allow_none=True)
minimized = Bool(allow_none=True)
showHorizontalScroll = Bool(allow_none=True)
showVerticalScroll = Bool(allow_none=True)
showSheetTabs = Bool(allow_none=True)
xWindow = Integer(allow_none=True)
yWindow = Integer(allow_none=True)
windowWidth = Integer()
windowHeight = Integer()
tabRatio = Integer(allow_none=True)
activeSheetId = Integer()
showFormulaBar = Bool(allow_none=True)
showStatusbar = Bool(allow_none=True)
showComments = NoneSet(
values=(['commNone', 'commIndicator', 'commIndAndComment']))
showObjects = NoneSet(values=(['all', 'placeholders']))
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
name=None,
guid=None,
autoUpdate=None,
mergeInterval=None,
changesSavedWin=None,
onlySync=None,
personalView=None,
includePrintSettings=None,
includeHiddenRowCol=None,
maximized=None,
minimized=None,
showHorizontalScroll=None,
showVerticalScroll=None,
showSheetTabs=None,
xWindow=None,
yWindow=None,
windowWidth=None,
windowHeight=None,
tabRatio=None,
activeSheetId=None,
showFormulaBar=None,
showStatusbar=None,
showComments="commIndicator",
showObjects="all",
extLst=None,
):
self.name = name
self.guid = guid
self.autoUpdate = autoUpdate
self.mergeInterval = mergeInterval
self.changesSavedWin = changesSavedWin
self.onlySync = onlySync
self.personalView = personalView
self.includePrintSettings = includePrintSettings
self.includeHiddenRowCol = includeHiddenRowCol
self.maximized = maximized
self.minimized = minimized
self.showHorizontalScroll = showHorizontalScroll
self.showVerticalScroll = showVerticalScroll
self.showSheetTabs = showSheetTabs
self.xWindow = xWindow
self.yWindow = yWindow
self.windowWidth = windowWidth
self.windowHeight = windowHeight
self.tabRatio = tabRatio
self.activeSheetId = activeSheetId
self.showFormulaBar = showFormulaBar
self.showStatusbar = showStatusbar
self.showComments = showComments
self.showObjects = showObjects
class WorkbookProperties(Serialisable):
tagname = "workbookPr"
date1904 = Bool(allow_none=True)
dateCompatibility = Bool(allow_none=True)
showObjects = NoneSet(values=(['all', 'placeholders']))
showBorderUnselectedTables = Bool(allow_none=True)
filterPrivacy = Bool(allow_none=True)
promptedSolutions = Bool(allow_none=True)
showInkAnnotation = Bool(allow_none=True)
backupFile = Bool(allow_none=True)
saveExternalLinkValues = Bool(allow_none=True)
updateLinks = NoneSet(values=(['userSet', 'never', 'always']))
codeName = String(allow_none=True)
hidePivotFieldList = Bool(allow_none=True)
showPivotChartFilter = Bool(allow_none=True)
allowRefreshQuery = Bool(allow_none=True)
publishItems = Bool(allow_none=True)
checkCompatibility = Bool(allow_none=True)
autoCompressPictures = Bool(allow_none=True)
refreshAllConnections = Bool(allow_none=True)
defaultThemeVersion = Integer(allow_none=True)
def __init__(self,
date1904=None,
dateCompatibility=None,
showObjects=None,
showBorderUnselectedTables=None,
filterPrivacy=None,
promptedSolutions=None,
showInkAnnotation=None,
backupFile=None,
saveExternalLinkValues=None,
updateLinks=None,
codeName=None,
hidePivotFieldList=None,
showPivotChartFilter=None,
allowRefreshQuery=None,
publishItems=None,
checkCompatibility=None,
autoCompressPictures=None,
refreshAllConnections=None,
defaultThemeVersion=None,
):
self.date1904 = date1904
self.dateCompatibility = dateCompatibility
self.showObjects = showObjects
self.showBorderUnselectedTables = showBorderUnselectedTables
self.filterPrivacy = filterPrivacy
self.promptedSolutions = promptedSolutions
self.showInkAnnotation = showInkAnnotation
self.backupFile = backupFile
self.saveExternalLinkValues = saveExternalLinkValues
self.updateLinks = updateLinks
self.codeName = codeName
self.hidePivotFieldList = hidePivotFieldList
self.showPivotChartFilter = showPivotChartFilter
self.allowRefreshQuery = allowRefreshQuery
self.publishItems = publishItems
self.checkCompatibility = checkCompatibility
self.autoCompressPictures = autoCompressPictures
self.refreshAllConnections = refreshAllConnections
self.defaultThemeVersion = defaultThemeVersion
class LineProperties(Serialisable):
tagname = "ln"
namespace = DRAWING_NS
w = MinMax(min=0, max=20116800, allow_none=True) # EMU
width = Alias('w')
cap = NoneSet(values=(['rnd', 'sq', 'flat']))
cmpd = NoneSet(values=(['sng', 'dbl', 'thickThin', 'thinThick', 'tri']))
algn = NoneSet(values=(['ctr', 'in']))
noFill = EmptyTag()
solidFill = ColorChoiceDescriptor()
gradFill = Typed(expected_type=GradientFillProperties, allow_none=True)
pattFill = Typed(expected_type=PatternFillProperties, allow_none=True)
prstDash = NestedNoneSet(values=([
'solid', 'dot', 'dash', 'lgDash', 'dashDot', 'lgDashDot',
'lgDashDotDot', 'sysDash', 'sysDot', 'sysDashDot', 'sysDashDotDot'
]),
namespace=namespace)
dashStyle = Alias('prstDash')
custDash = Typed(expected_type=DashStop, allow_none=True)
round = EmptyTag()
bevel = EmptyTag()
miter = Typed(expected_type=LineJoinMiterProperties, allow_none=True)
headEnd = Typed(expected_type=LineEndProperties, allow_none=True)
tailEnd = Typed(expected_type=LineEndProperties, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
__elements__ = ('noFill', 'solidFill', 'gradFill', 'pattFill', 'prstDash',
'custDash', 'round', 'bevel', 'mitre', 'headEnd',
'tailEnd')
def __init__(
self,
w=None,
cap=None,
cmpd=None,
algn=None,
noFill=None,
solidFill=None,
gradFill=None,
pattFill=None,
prstDash=None,
custDash=None,
round=None,
bevel=None,
miter=None,
headEnd=None,
tailEnd=None,
extLst=None,
):
self.w = w
self.cap = cap
self.cmpd = cmpd
self.algn = algn
self.noFill = noFill
self.solidFill = solidFill
self.gradFill = gradFill
self.pattFill = pattFill
if prstDash is None:
prstDash = "solid"
self.prstDash = prstDash
self.custDash = custDash
self.round = round
self.bevel = bevel
self.mitre = bevel
self.headEnd = headEnd
self.tailEnd = tailEnd
class RichTextProperties(Serialisable):
tagname = "bodyPr"
namespace = DRAWING_NS
rot = Integer(allow_none=True)
spcFirstLastPara = Bool(allow_none=True)
vertOverflow = NoneSet(values=(['overflow', 'ellipsis', 'clip']))
horzOverflow = NoneSet(values=(['overflow', 'clip']))
vert = NoneSet(values=([
'horz', 'vert', 'vert270', 'wordArtVert', 'eaVert', 'mongolianVert',
'wordArtVertRtl'
]))
wrap = NoneSet(values=(['none', 'square']))
lIns = Integer(allow_none=True)
tIns = Integer(allow_none=True)
rIns = Integer(allow_none=True)
bIns = Integer(allow_none=True)
numCol = Integer(allow_none=True)
spcCol = Integer(allow_none=True)
rtlCol = Bool(allow_none=True)
fromWordArt = Bool(allow_none=True)
anchor = NoneSet(values=(['t', 'ctr', 'b', 'just', 'dist']))
anchorCtr = Bool(allow_none=True)
forceAA = Bool(allow_none=True)
upright = Bool(allow_none=True)
compatLnSpc = Bool(allow_none=True)
prstTxWarp = Typed(expected_type=PresetTextShape, allow_none=True)
scene3d = Typed(expected_type=Scene3D, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
noAutofit = EmptyTag()
normAutofit = EmptyTag()
spAutoFit = EmptyTag()
flatTx = NestedInteger(attribute="z", allow_none=True)
__elements__ = ('prstTxWarp', 'scene3d', 'noAutofit', 'normAutofit',
'spAutoFit')
def __init__(
self,
rot=None,
spcFirstLastPara=None,
vertOverflow=None,
horzOverflow=None,
vert=None,
wrap=None,
lIns=None,
tIns=None,
rIns=None,
bIns=None,
numCol=None,
spcCol=None,
rtlCol=None,
fromWordArt=None,
anchor=None,
anchorCtr=None,
forceAA=None,
upright=None,
compatLnSpc=None,
prstTxWarp=None,
scene3d=None,
extLst=None,
noAutofit=None,
normAutofit=None,
spAutoFit=None,
flatTx=None,
):
self.rot = rot
self.spcFirstLastPara = spcFirstLastPara
self.vertOverflow = vertOverflow
self.horzOverflow = horzOverflow
self.vert = vert
self.wrap = wrap
self.lIns = lIns
self.tIns = tIns
self.rIns = rIns
self.bIns = bIns
self.numCol = numCol
self.spcCol = spcCol
self.rtlCol = rtlCol
self.fromWordArt = fromWordArt
self.anchor = anchor
self.anchorCtr = anchorCtr
self.forceAA = forceAA
self.upright = upright
self.compatLnSpc = compatLnSpc
self.prstTxWarp = prstTxWarp
self.scene3d = scene3d
self.noAutofit = noAutofit
self.normAutofit = normAutofit
self.spAutoFit = spAutoFit
self.flatTx = flatTx