def generate_ods(data): """ Generate a ODS file. :param data: list-like of dict with the data. :return: """ doc = OpenDocumentSpreadsheet() table = Table() tr = TableRow() colautowidth = Style(name="co1", family="table-column") colautowidth.addElement(TableColumnProperties(useoptimalcolumnwidth=True)) doc.automaticstyles.addElement(colautowidth) for column in data[0].keys(): table.addElement(TableColumn(stylename=colautowidth)) tc = TableCell(valuetype="string", value=column) tc.addElement(P(text=column)) tr.addElement(tc) table.addElement(tr) for row in data: tr = TableRow() for column in row.keys(): tc = TableCell(valuetype="string", value=row[column]) tc.addElement(P(text=row[column])) tr.addElement(tc) table.addElement(tr) file = os.path.join( tempfile.gettempdir(), 'SIGE' + datetime.now().strftime('%Y%m%d%H%M%S%f') + '.ods') doc.spreadsheet.addElement(table) print(doc.automaticstyles.childNodes[0].attributes) doc.save(file) return file
def extract_highlight_odf(name): textdoc = OpenDocumentText() location = os.path.join("/tmp/pdf_highlight/", name) doc_mask = fitzopen(location) doc_text = fitzopen(location) nb_pages = doc_text.pageCount style_p = Style(name="P1", family="paragraph", parentstylename="Standard") p_prop = ParagraphProperties(textalign="justify", justifysingleword="false") style_p.addElement(p_prop) textdoc.automaticstyles.addElement(style_p) textdoc.text.addElement(P(stylename=style_p, text=f"{name}\n\n")) for i in range(nb_pages): rect, hierarchy = Page_Get_Rects(doc_mask, doc_text, name, i) if rect.shape[0] > 0: textdoc = Page_Rect_get_Text_odf(doc_text, name, i, rect, hierarchy, textdoc, style_p) text_name = name.replace(".pdf", ".odt") location_out = os.path.join("/tmp/pdf_highlight/", text_name) textdoc.save(location_out) #print('fin') return text_name, location_out
def count_size(wh_list, row): """Count height of image row. Args: wh_list - list with attributes, contains width and height: row - image row. """ height, width = -1, -1 for l in wh_list: if l[0] == 'width': width = float(l[1].replace('in', '')) if l[0] == 'height': height = float(l[1].replace('in', '')) if height == -1 or width == -1: width = ININTENCM height = ININTENCM if width > ININTENCM: new_width = ININTENCM new_height = height * new_width / width else: new_width = width new_height = height height_set = str(new_height) + 'in' new_name = 'image' + str(image_counter) height_suit = Style(name=new_name, family='table-row') height_suit.addElement(TableRowProperties(rowheight=height_set)) ods.automaticstyles.addElement(height_suit) row.setAttribute(attr='stylename', value=new_name) new_width = str(new_width) + 'in' new_height = height_set return new_width, new_height
def createFinalReportTargetFormat(self, finalReport: List[list]) -> bytes: textdoc = OpenDocumentSpreadsheet() tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement( ParagraphProperties(numberlines="false", linenumber="0")) tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) table = Table(name="Java Metrics") tr = self.newRow(table) for columnLabels in finalReport[0]: self.addElementToRow(columnLabels, "string", tr, tablecontents) for row in finalReport[1:]: tr = self.newRow(table) self.addElementToRow(row[0], "string", tr, tablecontents) self.addElementToRow(row[1], "string", tr, tablecontents) for element in row[2:]: self.addElementToRow(str(element), "float", tr, tablecontents) textdoc.spreadsheet.addElement(table) stringOutput = BytesIO() textdoc.write(stringOutput) return stringOutput.getvalue()
def sample(): textdoc = OpenDocumentText() # Styles s = textdoc.styles h1style = Style(name="Heading 1", family="paragraph") h1style.addElement( TextProperties(attributes={ 'fontsize': "24pt", 'fontweight': "bold" })) s.addElement(h1style) # An automatic style boldstyle = Style(name="Bold", family="text") boldprop = TextProperties(fontweight="bold") boldstyle.addElement(boldprop) textdoc.automaticstyles.addElement(boldstyle) # Text h = H(outlinelevel=1, stylename=h1style, text="My first texta") textdoc.text.addElement(h) p = P(text="Hello world. ") boldpart = Span(stylename=boldstyle, text="This part is bold. ") p.addElement(boldpart) p.addText("This is after bold.") quotStyle = Style(name="Quotations") marginaliaStyle = Style(name="Marginalia") # p2 = P(text="2nd par. ", stylename=textBodyStyle) p3 = P(text="3rd par. ", stylename=quotStyle) textdoc.text.addElement(p) textdoc.text.addElement(p2) textdoc.text.addElement(p3) a = textdoc.save("myfirstdocument.odt")
def test_percentage(self): """ Test that an automatic style can refer to a PercentageStyle as a datastylename """ doc = OpenDocumentSpreadsheet() nonze = PercentageStyle(name='N11') nonze.addElement(Number(decimalplaces='2', minintegerdigits='1')) nonze.addElement(Text(text='%')) doc.automaticstyles.addElement(nonze) pourcent = Style(name='pourcent', family='table-cell', datastylename='N11') pourcent.addElement(ParagraphProperties(textalign='center')) pourcent.addElement(TextProperties(attributes={'fontsize':"10pt",'fontweight':"bold", 'color':"#000000" })) doc.automaticstyles.addElement(pourcent) table = Table(name='sheet1') tr = TableRow() tc = TableCell(formula='=AVERAGE(C4:CB62)/2',stylename='pourcent', valuetype='percentage') tr.addElement(tc) table.addElement(tr) doc.spreadsheet.addElement(table) doc.save("TEST.odt") self.saved = True d = load("TEST.odt") result = d.contentxml() self.assertNotEqual(-1, result.find(u'''<number:percentage-style''')) self.assertNotEqual(-1, result.find(u'''style:data-style-name="N11"''')) self.assertNotEqual(-1, result.find(u'''style:name="pourcent"'''))
def export_ods (headers, data): doc = OpenDocumentSpreadsheet() style = Style(name="Large number", family="table-cell") style.addElement(TextProperties(fontfamily="Arial", fontsize="15pt")) doc.styles.addElement(style) widewidth = Style(name="co1", family="table-column") widewidth.addElement(TableColumnProperties(columnwidth="2.8cm", breakbefore="auto")) doc.automaticstyles.addElement(widewidth) table = Table() if len (headers) > 0: tr = TableRow () table.addElement (tr) for item in headers: tc = TableCell () tr.addElement (tc) p = P(stylename = style, text = txt(item)) tc.addElement (p) for line in data: tr = TableRow () table.addElement (tr) for item in line: tc = TableCell () tr.addElement (tc) p = P (stylename = style, text = txt(item)) tc.addElement (p) doc.spreadsheet.addElement(table) buffer = StringIO () doc.write(buffer) return buffer.getvalue ()
def colwidth(self, width): if width not in self._widthstyles: w = Style(name="W{}".format(width), family="table-column") w.addElement(TableColumnProperties(columnwidth=width)) self.doc.automaticstyles.addElement(w) self._widthstyles[width] = w return self._widthstyles[width]
def add_style(self, name, family, styles, **kwargs): style = Style(name=name, family=family, **kwargs) for v in styles: style.addElement(v) self._document.automaticstyles.addElement(style)
def colwidth(w): if not hasattr(colwidth,'num'): colwidth.num=0 colwidth.num+=1 width=Style(name="W{}".format(colwidth.num),family="table-column") width.addElement(TableColumnProperties(columnwidth=w)) doc.automaticstyles.addElement(width) return width
def __handleFrameStyleRotated(self, text_data): style_name = "box%s%s%s%s%sRotated" % ( text_data.face, text_data.size, text_data.line_space, text_data.letter_space, text_data.justification, ) if not style_name in self.font_styles: frame_style = Style(name=style_name, family="paragraph") frame_style.addElement( ParagraphProperties( linespacing="%spt" % text_data.line_space, textalign=self.convertTextAlign(text_data.justification) ) ) frame_style.addElement( TextProperties( letterspacing="%spt" % text_data.letter_space, fontstyle=self.convertFontStyle(text_data.style), fontweight=self.convertFontWeight(text_data.weight), fontsize="%spt" % text_data.size, fontfamily=str(text_data.face), ) ) self.document.automaticstyles.addElement(frame_style) self.font_styles.append(style_name) return style_name
def generate_ods(data): """ Generate a ODS file. :param data: list-like of dict with the data. :return: """ doc = OpenDocumentSpreadsheet() table = Table() tr = TableRow() colautowidth = Style(name="co1", family="table-column") colautowidth.addElement(TableColumnProperties(useoptimalcolumnwidth=True)) doc.automaticstyles.addElement(colautowidth) for column in data[0].keys(): table.addElement(TableColumn(stylename=colautowidth)) tc = TableCell(valuetype="string", value=column) tc.addElement(P(text=column)) tr.addElement(tc) table.addElement(tr) for row in data: tr = TableRow() for column in row.keys(): tc = TableCell(valuetype="string", value=row[column]) tc.addElement(P(text=row[column])) tr.addElement(tc) table.addElement(tr) file = os.path.join(tempfile.gettempdir(), 'SIGE' + datetime.now().strftime('%Y%m%d%H%M%S%f') + '.ods') doc.spreadsheet.addElement(table) print(doc.automaticstyles.childNodes[0].attributes) doc.save(file) return file
def test_percentage(self): """ Test that an automatic style can refer to a PercentageStyle as a datastylename """ doc = OpenDocumentSpreadsheet() nonze = PercentageStyle(name='N11') nonze.addElement(Number(decimalplaces='2', minintegerdigits='1')) nonze.addElement(Text(text='%')) doc.automaticstyles.addElement(nonze) pourcent = Style(name='pourcent', family='table-cell', datastylename='N11') pourcent.addElement(ParagraphProperties(textalign='center')) pourcent.addElement( TextProperties(attributes={ 'fontsize': "10pt", 'fontweight': "bold", 'color': "#000000" })) doc.automaticstyles.addElement(pourcent) table = Table(name='sheet1') tr = TableRow() tc = TableCell(formula='=AVERAGE(C4:CB62)/2', stylename='pourcent', valuetype='percentage') tr.addElement(tc) table.addElement(tr) doc.spreadsheet.addElement(table) doc.save(u"TEST.ods") self.saved = True d = load(u"TEST.ods") result = d.contentxml() # contentxml is supposed to yeld a bytes self.assertNotEqual(-1, result.find(b'''<number:percentage-style''')) self.assertNotEqual(-1, result.find(b'''style:data-style-name="N11"''')) self.assertNotEqual(-1, result.find(b'''style:name="pourcent"'''))
def createTargetFormat(self, metricValues: Dict[str, List[int]], metricLabels: List[str]) -> bytes: textdoc = OpenDocumentSpreadsheet() tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement( ParagraphProperties(numberlines="false", linenumber="0")) tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) table = Table(name="Java Metrics") tr = self.newRow(table) for metricLabel in metricLabels: self.addElementToRow(metricLabel, "string", tr, tablecontents) for methodName in metricValues.keys(): tr = self.newRow(table) self.addElementToRow(methodName, "string", tr, tablecontents) for metricValue in metricValues[methodName]: self.addElementToRow(str(metricValue), "float", tr, tablecontents) textdoc.spreadsheet.addElement(table) stringOutput = BytesIO() textdoc.write(stringOutput) return stringOutput.getvalue()
def addParagraphStyle(self, id, name, paragraph_properties={}, text_properties={}, graphic_properties={}): style = Style(name=name, family="paragraph") if len(paragraph_properties)>0: style.addElement(ParagraphProperties(**paragraph_properties)) if len(text_properties)>0: style.addElement(TextProperties(**text_properties)) setattr(self, id, style) self.document.styles.addElement(style)
def _add_headerstyle(self): header = Style(name="ColumnHeader", family="table-cell") header.addElement( ParagraphProperties(textalign="center")) header.addElement( TextProperties(fontweight="bold")) self.doc.styles.addElement(header) return header
def saltolinea(documento): withbreak = Style(name="WithBreak", parentstylename="Standard", family="paragraph") withbreak.addElement(ParagraphProperties(breakafter="page")) documento.automaticstyles.addElement(withbreak) p = P(stylename=withbreak) documento.text.addElement(p) return documento
def addParagraphStyle(self, id, name, paragraph_properties={}, text_properties={}): """ """ style = Style(name=name, family="paragraph") if len(paragraph_properties) > 0: style.addElement(ParagraphProperties(**paragraph_properties)) if len(text_properties) > 0: style.addElement(TextProperties(**text_properties)) setattr(self, id, style) self.document.styles.addElement(style)
def extract_highlight_odf(name, img_quality, two_col, output_folder=None): textdoc = OpenDocumentText() doc_mask = fitzopen(name) doc_text = fitzopen(name) nb_pages = doc_text.pageCount #create style for paragraph style_p = Style(name="P1", family="paragraph", parentstylename="Standard") p_prop = ParagraphProperties(textalign="justify", justifysingleword="false") style_p.addElement(p_prop) textdoc.automaticstyles.addElement(style_p) #create style for images style_i = Style(name="fr1", family="graphic", parentstylename="Graphics") i_prop = GraphicProperties(wrap="none", runthrough="foreground", horizontalpos="center", horizontalrel="paragraph") style_i.addElement(i_prop) textdoc.automaticstyles.addElement(style_i) #insert pdf file name textdoc.text.addElement(P(stylename=style_p, text=f"{name}\n\n")) #isolate highlights in _mask and text in _text doc_mask, doc_text = Page_Get_Highlights(doc_mask, doc_text) #iterate over pages to create rectangles to extract for i in range(nb_pages): if two_col == True: #colonnes for col in [1, 2]: rect, hierarchy, Xrects = Page_Get_Rects(doc_mask[i], col) if rect.shape[0] > 0: textdoc = Page_Rect_get_Text_odf(doc_text, i, rect, hierarchy, Xrects, textdoc, style_p, style_i, img_quality, col) else: col = 0 rect, hierarchy, Xrects = Page_Get_Rects(doc_mask[i], col) if rect.shape[0] > 0: textdoc = Page_Rect_get_Text_odf(doc_text, i, rect, hierarchy, Xrects, textdoc, style_p, style_i, img_quality, col) if output_folder is not None: basename = os.path.basename(name) outname = basename.replace(".pdf", ".odt") outname = os.path.join(output_folder, outname) textdoc.save(outname) else: textdoc.save(name.replace(".pdf", ".odt")) doc_mask.close() doc_text.close()
def writer(data, **kwargs): """ Liberally adapted from odfpy's csv2ods script. """ def handle_formula(f): return TableCell(valuetype="float", formula="{}".format(f)) textdoc = OpenDocumentSpreadsheet(**kwargs) # Create a style for the table content. One we can modify # later in the word processor. tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement( ParagraphProperties(numberlines="false", linenumber="0")) tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) # Start the table table = Table(name=u'Sheet 1') fltExp = re.compile('^\s*[-+]?\d+(\.\d+)?\s*$') for row in data: tr = TableRow() table.addElement(tr) for val in row: if isinstance(val, spreadsheet.Formula): tc = handle_formula(val) else: valuetype = 'string' if not isinstance(val, unicode): if isinstance(val, str): text_value = "{}".format(val, PWENC, 'replace') else: text_value = "{}".format(val) else: text_value = val if isinstance(val, (float, int, long)) or (isinstance( val, str) and fltExp.match(text_value)): valuetype = 'float' if valuetype == 'float': tc = TableCell(valuetype="float", value=text_value.strip()) else: tc = TableCell(valuetype=valuetype) if val is not None: p = P(stylename=tablecontents, text=text_value) tc.addElement(p) tr.addElement(tc) textdoc.spreadsheet.addElement(table) result = StringIO() textdoc.write(result) return result.getvalue()
def newPage(self, page_data): master_name = self.__handlePageMaster(page_data) page_style_name = "%sPage" % master_name if not page_style_name in self.page_styles: page_style = Style(name=page_style_name, family="paragraph", masterpagename=master_name) page_style.addElement(ParagraphProperties(breakbefore="page")) self.document.automaticstyles.addElement(page_style) new_page = P(stylename=page_style_name) self.document.text.addElement(new_page) return new_page
class ExcercisesDoc: def __init__(self, count, min, max, filename): self.count = count self.min = min self.max = max self.filename = filename def create_doc(self): doc = OpenDocumentText() # Page layout: A4 pagelayout = PageLayout(name="A4") doc.automaticstyles.addElement(pagelayout) pagelayout.addElement( PageLayoutProperties(margin="2cm", pageheight="297mm", pagewidth="210mm", printorientation="portrait")) # Use page layout on master page, to set it: masterpage = MasterPage(name="Standard", pagelayoutname="A4") doc.masterstyles.addElement(masterpage) # Styles s = doc.styles self.h1style = Style(name="Heading 1", family="paragraph") self.h1style.addElement( TextProperties(attributes={ 'fontsize': "24pt", 'fontweight': "bold" })) s.addElement(self.h1style) return doc def render(self): doc = self.create_doc() for block_id in range(0, self.count, 10): block_num = block_id / 10 + 1 self.render_block(doc, block_num) doc.save(self.filename) def render_block(self, doc, num): problems = generate_problems(10, self.min, self.max) self.render_subblock(doc, num, problems, 'Aufgaben', False) self.render_subblock(doc, num, problems, 'Lösungen', True) def render_subblock(self, doc, num, problems, text, show_solution): base = (num - 1) * 10 + 1 doc.text.addElement( H(outlinelevel=1, stylename=self.h1style, text="{} Teil {}".format(text, num))) for i, p in enumerate(problems): p = P(text="{}) {}".format(base + i, p.render(show_solution))) doc.text.addElement(p) doc.text.addElement(P())
def setup(self): odt = self.generator s = odt.styles h1s = Style(name="Heading 1", family="paragraph") h1s.addElement( TextProperties( attributes={'fontsize': "24pt", 'fontweight': "bold"} ) ) s.addElement(h1s) self.h1s = h1s
def newPage(self, page_data): master_name = self.__handlePageMaster(page_data) page_style_name = '%sPage' % master_name if not page_style_name in self.page_styles: page_style = Style(name=page_style_name, family='paragraph', masterpagename=master_name) page_style.addElement(ParagraphProperties(breakbefore='page')) self.document.automaticstyles.addElement(page_style) new_page = P(stylename=page_style_name) self.document.text.addElement(new_page) return new_page
def __setDefaultStyle(self): DefaultStyle = Style(name="Standard", family='paragraph') DefaultStyle.addElement(TextProperties( fontfamily='FreeSans', fontsize='10pt')) DefaultStyle.addElement(ParagraphProperties( margintop='0.423cm', marginbottom='0.212cm')) self.__doc.styles.addElement(DefaultStyle) ''' Text Body ''' txt = Style(name='text_20_body', family='paragraph', parentstylename='Standard') self.__doc.styles.addElement(txt)
def odt_write(object, filename, introduction=None, lmf2odt=lmf_to_odt, items=lambda lexical_entry: lexical_entry.get_lexeme(), sort_order=None, paradigms=False, reverse=False): """! @brief Write a document file. @param object The LMF instance to convert into document output format. @param filename The name of the document file to write with full path, for instance 'user/output.odt'. @param introduction The name of the text file with full path containing the introduction of the document, for instance 'user/config/introduction.txt'. Default value is None. @param lmf2odt A function giving the mapping from LMF representation information that must be written to ODT commands, in a defined order. Default value is 'lmf_to_odt' function defined in 'pylmflib/config/odt.py'. Please refer to it as an example. @param items Lambda function giving the item to sort. Default value is 'lambda lexical_entry: lexical_entry.get_lexeme()', which means that the items to sort are lexemes. @param sort_order Python list. Default value is 'None', which means that the document output is alphabetically ordered. @param paradigms A boolean value to introduce paradigms in document or not. @param reverse A boolean value to set if a reverse dictionary is wanted. """ import string if sort_order is None: # Lowercase and uppercase letters must have the same rank sort_order = dict([(c, ord(c)) for c in string.lowercase]) up = dict([(c, ord(c) + 32) for c in string.uppercase]) sort_order.update(up) sort_order.update({'':0, ' ':0}) textdoc = OpenDocumentText() # Styles s = textdoc.styles h1style = Style(name="Heading 1", family="paragraph") h1style.addElement(TextProperties(attributes={'fontsize':"24pt", 'fontweight':"bold" })) s.addElement(h1style) # An automatic style boldstyle = Style(name="Bold", family="text") boldprop = TextProperties(fontweight="bold", fontname="Arial", fontsize="8pt") boldstyle.addElement(boldprop) textdoc.automaticstyles.addElement(boldstyle) # Parse LMF values if object.__class__.__name__ == "LexicalResource": for lexicon in object.get_lexicons(): # Document title h = H(outlinelevel=1, stylename=h1style, text=lexicon.get_id()) textdoc.text.addElement(h) # Plain paragraph p = P(text=lexicon.get_label()) # Text boldpart = Span(stylename=boldstyle, text="Test. ") p.addElement(boldpart) # Introduction if introduction is not None: p.addText(file_read(introduction)) textdoc.text.addElement(p) # Page break # # Text body lmf2odt(lexicon, textdoc, items, sort_order, paradigms, reverse) else: raise OutputError(object, "Object to write must be a Lexical Resource.") textdoc.save(filename)
def write(self): super().write() self.doc = OpenDocumentSpreadsheet() self.cell_formats = {} for key, value in self.colours.items(): style = Style(name=key, family="table-cell") style.addElement(TableCellProperties(backgroundcolor="#" + value)) self.doc.automaticstyles.addElement(style) self.cell_formats[key] = style for sheet in self.sheets: self.write_table(sheet) self.doc.save(self.filename, True)
def _create_style(name, family=None, **kwargs): """Helper function for creating a new style.""" if family == 'paragraph' and 'marginbottom' not in kwargs: kwargs['marginbottom'] = '.5cm' style = Style(name=name, family=family) # Extract paragraph properties. kwargs_par = {} keys = sorted(kwargs.keys()) for k in keys: if 'margin' in k: kwargs_par[k] = kwargs.pop(k) style.addElement(TextProperties(**kwargs)) if kwargs_par: style.addElement(ParagraphProperties(**kwargs_par)) return style
def add_title_page(self, odt, title): # Requirements for <project name> # <project description> # # Author: <stakeholder name> # <date> # # <document description> # Title titlestyle = Style(name="TitleStyle",family="text") titlestyle.addElement(TextProperties(attributes={'fontweight':"bold", 'fontsize':'36pt'})) odt.automaticstyles.addElement(titlestyle) titlespan = Span(stylename=titlestyle, text=_('Requirements for "%s"') % title) p = P(text='') p.addElement(titlespan) odt.text.addElement(p)
def _create_styles( self ): #Creating new ruby style self.ruby_style_name = "RubyMy" my_ruby_style = Style( name=self.ruby_style_name, family="ruby" ) my_ruby_style.addElement( RubyProperties( rubyalign = "center", rubyposition = "above" ) ) self.doc.automaticstyles.addElement( my_ruby_style ) #Create dotted style self.dot_style_name = "DottedMy" my_dotted_style = Style( name = self.dot_style_name, family="text" ) my_dotted_style.addElement( TextProperties( textemphasize="dot above" ) ) self.doc.automaticstyles.addElement( my_dotted_style )
def defineStyles(self): # entête s = Style(name = "Header", family ="paragraph") prop = {"numberlines":"false", "linenumber":"0"} P = ParagraphProperties(**prop) Q = TabStops() Q.addElement(TabStop(position="8.5cm", type="center")) Q.addElement(TabStop(position="17cm", type="right")) P.addElement(Q) s.addElement(P) prop2 = {"fontfamily": "Verdana", "fontweight": "bold", "fontsize": "14pt"} s.addElement(TextProperties(**prop2)) self.document.styles.addElement(s) setattr(self, "Header", s) #autres self.addParagraphStyle("heading1", "Heading 1", paragraph_properties={"breakbefore": "page", "lineheight": "24pt"}, text_properties={"fontfamily": "Verdana", "fontweight": "bold", "fontsize": "14pt"} ) self.addParagraphStyle("heading2", "Heading 2", paragraph_properties={"breakbefore": "false", "lineheight": "24pt"}, text_properties={"fontfamily": "Verdana", "fontweight": "italic", "fontsize": "14pt"} ) self.addParagraphStyle("heading3", "Heading 3", paragraph_properties={"breakbefore": "false", "lineheight": "20pt"}, text_properties={"fontfamily": "Liberation Sans", "fontweight": "bold", "fontsize": "14pt"} ) self.addParagraphStyle("normal", "Normal", paragraph_properties={"breakbefore": "false", "lineheight": "20pt"}, text_properties={"fontfamily": "Liberation Serif", "fontsize": "12pt"} ) self.addParagraphStyle("gras", "Bgr", paragraph_properties={"breakbefore": "false", "lineheight": "20pt"}, text_properties={"fontfamily": "Liberation Serif", "fontweight": "bold", "fontsize": "12pt"} ) self.addParagraphStyle("tablecontents", "Table Contents", paragraph_properties={"numberlines": "false", "linenumber": "0"} ) self.addPageLayoutStyle("mpm1", "Mpm1", \ properties={"pagewidth":"21.001cm", "pageheight": "14.801cm",\ "numformat": "1", "printorientation": "landscape",\ "margintop":"1cm", "marginbottom": "1cm", "marginleft": "1cm",\ "marginright": "1cm", "writingmode":"lr-tb"})#, "footnotemaxheight":"0cm" self.addTableColumnStyle("column1", "Left Column", properties={"columnwidth": "4cm"}) self.addTableColumnStyle("column2", "Center Column", properties={"columnwidth": "4cm"}) self.addTableColumnStyle("column3", "Right Column", properties={"columnwidth": "2cm"})
def add_attribute_row(self, table, key, value): """ Add a two cell row to the table """ boldstyle = Style(name="Bold",family="text") boldstyle.addElement(TextProperties(attributes={'fontweight':"bold"})) title_span = Span(stylename=boldstyle, text=key) pt = P(text='') pt.addElement(title_span) tr = TableRow() tc = TableCell(valuetype='string') tc.addElement(pt) tr.addElement(tc) tc = TableCell(valuetype='string') tc.addElement(P(text=value)) tr.addElement(tc) table.addElement(tr)
def save_test(self): new_partition = OpenDocumentText() T5style = Style(name="T5", family="text") T5style.addElement(TextProperties(fontname="Arial")) new_partition.automaticstyles.addElement(T5style) for i in range(len(self.allText)): old_text = teletype.extractText(self.allText[i]) p = text.P(text="", stylename="T5") for j in range(len(old_text)): if (old_text[j] == " " and i in self.lignes): p.addElement(Span(text=' ', stylename='T5')) else: p.addText(old_text[j]) new_partition.text.addElement(p) new_partition.save("x_test.odt")
def __init__(self, name): self.name = name self.document = OpenDocumentText() self.current_page = None self.photo_style = Style(name="Photo", family="graphic") self.document.styles.addElement(self.photo_style) self.font_styles = [] self.page_layouts = [] self.page_masters = [] self.page_styles = [] self.temp_images = [] frame_style = Style(name="FrameStyle", family="graphic") frame_style.addElement(GraphicProperties(borderlinewidth="none")) self.document.styles.addElement(frame_style) frame_style_rotated = Style(name="FrameStyleRotated", family="graphic") frame_style_rotated.addElement( GraphicProperties(fill="none", stroke="none", verticalpos="from-top", verticalrel="paragraph") ) self.document.automaticstyles.addElement(frame_style_rotated)
def make_document(): # Create the document doc = OpenDocumentDrawing() # Create the drawing page dpstyle = Style(family="drawing-page", name="DP1") dpstyle.addElement(DrawingPageProperties(backgroundsize="border", fill="none")) doc.automaticstyles.addElement(dpstyle) # Create page layout specifying dimensions plstyle = PageLayout(name="PM1") plstyle.addElement(PageLayoutProperties(margin="1in", pageheight="8.5in", pagewidth="11in", printorientation="landscape")) doc.automaticstyles.addElement(plstyle) # Create a master page masterpage = MasterPage(stylename=dpstyle, name="Default", pagelayoutname=plstyle) doc.masterstyles.addElement(masterpage) # Create a page to contain the drawing drawpage = Page(masterpagename=masterpage, name="page1", stylename=dpstyle) doc.drawing.addElement(drawpage) # Create a style for the circles circlestyle = Style(family="graphic", name="solid") circlestyle.addElement( GraphicProperties(fill="none", stroke="#000000", strokewidth="0.01in")) doc.automaticstyles.addElement(circlestyle) group=G() drawpage.addElement(group) circlePlotter = CirclePlotter(circlestyle) #nestedTriangle = NestedTriangle(group, circlePlotter, 0.25, 0.5, 0.5) #nestedTriangle = NestedTriangle(group, circlePlotter, 0.125, 0.75, 0.5) nestedTriangle = NestedTriangle(group, circlePlotter, 0.19, 0.625, 0.39) nestedTriangle.draw(5.5, 4.25, 3.5, 6) # Save the work doc.save(DRAWING_FILE, True)
def _process_style(self, style: dict[str, Any]) -> str: """Convert a style dictionary to a OpenDocument style sheet Parameters ---------- style : Dict Style dictionary Returns ------- style_key : str Unique style key for later reference in sheet """ from odf.style import ( ParagraphProperties, Style, TableCellProperties, TextProperties, ) if style is None: return None style_key = json.dumps(style) if style_key in self._style_dict: return self._style_dict[style_key] name = f"pd{len(self._style_dict)+1}" self._style_dict[style_key] = name odf_style = Style(name=name, family="table-cell") if "font" in style: font = style["font"] if font.get("bold", False): odf_style.addElement(TextProperties(fontweight="bold")) if "borders" in style: borders = style["borders"] for side, thickness in borders.items(): thickness_translation = {"thin": "0.75pt solid #000000"} odf_style.addElement( TableCellProperties( attributes={ f"border{side}": thickness_translation[thickness] })) if "alignment" in style: alignment = style["alignment"] horizontal = alignment.get("horizontal") if horizontal: odf_style.addElement(ParagraphProperties(textalign=horizontal)) vertical = alignment.get("vertical") if vertical: odf_style.addElement( TableCellProperties(verticalalign=vertical)) self.book.styles.addElement(odf_style) return name
def __handleFrameStyleRotated(self, text_data): style_name = 'box%s%s%s%s%sRotated' % ( text_data.face, text_data.size, text_data.line_space, text_data.letter_space, text_data.justification) if not style_name in self.font_styles: frame_style = Style(name=style_name, family='paragraph') frame_style.addElement( ParagraphProperties(linespacing='%spt' % text_data.line_space, textalign=self.convertTextAlign( text_data.justification))) frame_style.addElement( TextProperties( letterspacing='%spt' % text_data.letter_space, fontstyle=self.convertFontStyle(text_data.style), fontweight=self.convertFontWeight(text_data.weight), fontsize='%spt' % text_data.size, fontfamily=str(text_data.face))) self.document.automaticstyles.addElement(frame_style) self.font_styles.append(style_name) return style_name
def generate(self, target_file): """ List each requirement and it's details """ repo_dir = get_repo_dir() project = ProjectConfig() project.load_config_from_file(os.path.join(repo_dir, 'project.conf')) rt = RequirementTree() rt.load_repository(repo_dir) template_file = 'requirement-list-template.odt' # If no template found, then create new file try: template_file_path = os.path.join('templates', template_file) template_file_path = os.path.join(repo_dir, template_file_path) odt = odf.opendocument.load(template_file_path) except Exception as e: odt = odf.opendocument.OpenDocumentText() if project.name: odt.meta.addElement(odf.dc.Title(text=project.name)) else: odt.meta.addElement(odf.dc.Title(text='[Set name in project.conf]')) if project.description: odt.meta.addElement(odf.dc.Description(text=project.description)) # Add styles rejected = Style(name="Rejected", family="text") rejected.addElement(TextProperties(color="#666666", textlinethroughstyle="solid")) odt.automaticstyles.addElement(rejected) notrejected = Style(name="Not rejected", family="text") odt.automaticstyles.addElement(notrejected) self.write_child_details(rt, 1, rt, odt) try: odt.save(target_file, True) except: report_error(1, 'Unable to write to "%s", is file open?' % target_file)
def export_to_odt(self, data): document = OpenDocumentText() # Styles s = document.styles h1style = Style(name="Heading 1", family="paragraph") h1style.addElement( TextProperties(attributes={ 'fontsize': "24pt", 'fontweight': "bold" })) s.addElement(h1style) h2style = Style(name="Heading 2", family="paragraph") h2style.addElement( TextProperties(attributes={ 'fontsize': "16pt", 'fontweight': "bold" })) s.addElement(h2style) h3style = Style(name="Heading 3", family="paragraph") h3style.addElement( TextProperties(attributes={ 'fontsize': "12pt", 'fontweight': "bold" })) s.addElement(h3style) h4style = Style(name="Heading 4", family="paragraph") h4style.addElement(TextProperties(attributes={'fontsize': "8pt"})) s.addElement(h4style) # Text h = H(outlinelevel=1, stylename=h1style, text="Data of AtmoStation") document.text.addElement(h) h = H(outlinelevel=1, stylename=h2style, text=str(datetime.datetime.now())) document.text.addElement(h) for k, v in data.items(): h = H(outlinelevel=1, stylename=h2style, text=k) document.text.addElement(h) for v1 in v: h = H(outlinelevel=2, stylename=h3style, text="Item") document.text.addElement(h) for v2 in v1: h = H(outlinelevel=3, stylename=h4style, text=str(v2) + ": " + str(v1[v2])) document.text.addElement(h) document.save('templates\\formated_data\\data.odt')
def __init__(self, name): self.name = name self.document = OpenDocumentText() self.current_page = None self.photo_style = Style(name="Photo", family="graphic") self.document.styles.addElement(self.photo_style) self.font_styles = [] self.page_layouts = [] self.page_masters = [] self.page_styles = [] self.temp_images = [] frame_style = Style(name='FrameStyle', family='graphic') frame_style.addElement(GraphicProperties(borderlinewidth='none')) self.document.styles.addElement(frame_style) frame_style_rotated = Style(name='FrameStyleRotated', family='graphic') frame_style_rotated.addElement( GraphicProperties(fill='none', stroke='none', verticalpos='from-top', verticalrel='paragraph')) self.document.automaticstyles.addElement(frame_style_rotated)
def image_spices(an_odt, a_spice, a_font): ## graphic image_stylename = a_spice + "frame_style" image_graphic_style = Style(name=image_stylename, family="graphic") href = an_odt.addPicture(a_spice + ".jpg") if a_spice == "chocolade": backgroundimage = BackgroundImage(href=href, position="top left", repeat="no") elif a_spice == "koraal": backgroundimage = BackgroundImage(href=href, position="bottom right", repeat="no") else: backgroundimage = BackgroundImage(href=href, position="top left", repeat="repeat") image_graphic_properties = GraphicProperties(border="0.5mm double #000000") image_graphic_properties.addElement(backgroundimage) image_graphic_style.addElement(image_graphic_properties) image_beehive = beehive(an_odt, image_graphic_style, "273mm", "194mm", "-12mm", "-12mm", "1") image_frame = image_beehive["frame"] image_textbox = image_beehive["textbox"] ## textgraph image_stylename = "emptygif" image_textgraph_style = Style(name=image_stylename, family="paragraph") image_text_props = TextProperties() image_textgraph_style.addElement(image_text_props) image_paragraph_props = ParagraphProperties() image_textgraph_style.addElement(image_paragraph_props) an_odt.styles.addElement(image_textgraph_style) text_unit(an_odt, image_textgraph_style, u"", image_textbox) an_odt.text.addElement(image_frame)
def border_spices(an_odt, a_spice, a_font): ## graphic border_stylename = a_spice + "border_style" border_graphic_style = Style(name=border_stylename, family="graphic") #href = an_odt.addPicture(a_spice + ".jpg") #if a_spice == "kristallen": # border_graphic_properties = GraphicProperties(border="0.5mm double #000000") #elif a_spice == "roze": # border_graphic_properties = GraphicProperties(border="0.5mm double #000000") #else: # border_graphic_properties = GraphicProperties(border="0.5mm double #000000") border_graphic_properties = GraphicProperties(border="0.5mm double #000000") border_graphic_style.addElement(border_graphic_properties) border_beehive = beehive(an_odt, border_graphic_style, "273mm", "194mm", "-12mm", "-12mm", "1") border_frame = border_beehive["frame"] border_textbox = border_beehive["textbox"] ## textgraph border_stylename = "emptygif" border_textgraph_style = Style(name=border_stylename, family="paragraph") border_text_props = TextProperties() border_textgraph_style.addElement(border_text_props) border_paragraph_props = ParagraphProperties() border_textgraph_style.addElement(border_paragraph_props) an_odt.styles.addElement(border_textgraph_style) text_unit(an_odt, border_textgraph_style, u"", border_textbox) an_odt.text.addElement(border_frame)
class OdtConverter(Converter): def __init__(self, output_file_name): self._document = OpenDocumentText() self._raw_document_content = [] self._output_file_path = "target/{}.odt".format(output_file_name) self._h1_style = None self._p_style = None def convert(self): self._generate_styles() sources = self._process_input_files() for source in sources: self._raw_document_content += source self._process_raw_document_content() self._document.save(self._output_file_path) def _generate_styles(self): self._h1_style = Style(name="Heading 1", family="paragraph") self._h1_style.addElement(ParagraphProperties(attributes={"margintop": "24pt", "marginbottom": "12pt", "keepwithnext": "always"})) self._h1_style.addElement(TextProperties(attributes={"fontsize": "16pt"})) self._document.styles.addElement(self._h1_style) self._p_style = Style(name="Body", family="paragraph") self._p_style.addElement(ParagraphProperties(attributes={"textindent": "1.25cm", "textalign": "justify", "orphans": 2, "widows": 2})) self._document.styles.addElement(self._p_style) def _process_raw_document_content(self): for line in self._raw_document_content: if line.startswith("# "): new_element = H(outlinelevel=1, stylename=self._h1_style, text=line.replace("# ", "")) else: new_element = P(text=line, stylename=self._p_style) self._document.text.addElement(new_element)
def imprimir(conexion, obra): textdoc = OpenDocumentText() # Styles s = textdoc.styles h1style = Style(name="Heading 1", family="paragraph") h1style.addElement(TextProperties(attributes={'fontsize':"24pt",'fontweight':"bold" })) s.addElement(h1style) # An automatic style boldstyle = Style(name="Bold", family="text") boldprop = TextProperties(fontweight="bold") boldstyle.addElement(boldprop) textdoc.automaticstyles.addElement(boldstyle) # Text h=H(outlinelevel=1, stylename=h1style, text="My first text") textdoc.text.addElement(h) p = P(text="Hello world. ") boldpart = Span(stylename=boldstyle, text="This part is bold. ") p.addElement(boldpart) p.addText("This is after bold.") textdoc.text.addElement(p) textdoc.save("/home/david/programacion/python/odfpy/myfirstdocument.odt") print ("TodoOK")
def count_height(row, cell): """Counting height that shows all text in cell. This functions uses width of text-column and font size. Args: row - current row. cell - current cell. """ style_name = cell.getAttribute('stylename') try: style = saved_styles[style_name] text_prop = style.getElementsByType(TextProperties) try: text_prop = text_prop[0] font_size = str(text_prop.getAttribute('fontsize')) font_size = font_size.replace('pt', '') font_size = int(font_size) except IndexError: font_size = 10 except KeyError: font_size = 10 symbols_in_string = PTINTENCM // font_size + 1 length = 0 for p in cell.getElementsByType(P): length += len(p.__str__()) height = font_size * (length // symbols_in_string + 1) + 4 height = str(height) + 'pt' new_name = 'heightsuit' + height height_suit = Style(name=new_name, family='table-row') height_suit.addElement(TableRowProperties(rowheight=height)) ods.automaticstyles.addElement(height_suit) row.setAttribute(attr='stylename', value=new_name)
def inittable(textdoc): # Create a style for the table content. One we can modify # later in the word processor. tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement(ParagraphProperties(numberlines="false", linenumber="0")) tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) widewidth = Style(name="co1", family="table-column") widewidth.addElement(TableColumnProperties(columnwidth="9", breakbefore="auto")) textdoc.automaticstyles.addElement(widewidth) textdoc.styles.addElement(widewidth) table = Table( name='test' ) table.addElement(TableColumn(stylename=widewidth, defaultcellstylename="ce1")) return table,tablecontents,textdoc
def inittable(textdoc): # Create a style for the table content. One we can modify # later in the word processor. tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement( ParagraphProperties(numberlines="false", linenumber="0")) tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) widewidth = Style(name="co1", family="table-column") widewidth.addElement( TableColumnProperties(columnwidth="9", breakbefore="auto")) textdoc.automaticstyles.addElement(widewidth) textdoc.styles.addElement(widewidth) table = Table(name='test') table.addElement( TableColumn(stylename=widewidth, defaultcellstylename="ce1")) return table, tablecontents, textdoc
def __setHeadingStyle(self): HdgStyle = Style(name="Heading", family='paragraph', parentstylename="Standard") HdgStyle.addElement(TextProperties( fontweight='bold', fontfamily='FreeSans', fontsize='120%')) self.__doc.styles.addElement(HdgStyle) ''' Heading 1 ''' HdgStyle = Style(name="Heading_20_1", family='paragraph', parentstylename="Heading") HdgStyle.addElement(TextProperties(fontsize='120%')) self.__doc.styles.addElement(HdgStyle) ''' Heading 2 ''' HdgStyle = Style(name='Heading_20_2', family='paragraph', parentstylename='Heading') HdgStyle.addElement(TextProperties(fontsize='110%', color='#808080')) self.__doc.styles.addElement(HdgStyle)
def label(an_odt, a_spice, a_font): label_stylename = a_spice + a_font label_graphic_style = Style(name=label_stylename, family="graphic") label_graphic_properties = GraphicProperties() label_graphic_style.addElement(label_graphic_properties) label_beehive = beehive(an_odt, label_graphic_style, "5mm", "50mm", "60mm", "263mm", "1") label_frame = label_beehive["frame"] label_textbox = label_beehive["textbox"] ## textgraph label_stylename = a_spice + a_font label_textgraph_style = Style(name=label_stylename, family="paragraph") label_text_props = TextProperties(fontsize="11.1pt", fontfamily="Nimbus Sans L", color="#ffffff") label_textgraph_style.addElement(label_text_props) label_paragraph_props = ParagraphProperties(backgroundcolor="#000000", textalign="center") label_textgraph_style.addElement(label_paragraph_props) an_odt.styles.addElement(label_textgraph_style) text_unit(an_odt, label_textgraph_style, a_spice + " " + a_font, label_textbox) an_odt.text.addElement(label_frame)
def dingbat_spices(an_odt, a_spice, a_font): ## graphic dingbat_stylename = a_spice + "_style_frame" dingbat_graphic_style = Style(name=dingbat_stylename, family="graphic") dingbat_graphic_properties = GraphicProperties() dingbat_graphic_style.addElement(dingbat_graphic_properties) dingbat_beehive = beehive(an_odt, dingbat_graphic_style, "240mm", "10mm", "0mm", "0mm", "100") dingbat_frame = dingbat_beehive["frame"] dingbat_textbox = dingbat_beehive["textbox"] ## textgraph dingbat_stylename = a_spice + "_style_paragraph" dingbat_textgraph_style = Style(name=dingbat_stylename, family="paragraph") dingbat_text_props = TextProperties(fontsize="14pt", fontfamily="FreeSerif") dingbat_textgraph_style.addElement(dingbat_text_props) dingbat_paragraph_props = ParagraphProperties() dingbat_textgraph_style.addElement(dingbat_paragraph_props) an_odt.styles.addElement(dingbat_textgraph_style) for i in dingbats[a_spice]: text_unit(an_odt, dingbat_textgraph_style, i, dingbat_textbox) an_odt.text.addElement(dingbat_frame)
# Contributor(s): # Søren Roug # This example shows how to do a conditional currency style. We want negative # numbers to show as red and as Australian dollars. from odf.opendocument import OpenDocumentSpreadsheet from odf.style import Style, TextProperties, TableColumnProperties, Map from odf.number import NumberStyle, CurrencyStyle, CurrencySymbol, Number, Text from odf.text import P from odf.table import Table, TableColumn, TableRow, TableCell textdoc = OpenDocumentSpreadsheet() # Create a style for the table content. One we can modify # later in the spreadsheet. tablecontents = Style(name="Large number", family="table-cell") tablecontents.addElement(TextProperties(fontfamily="Arial", fontsize="15pt")) textdoc.styles.addElement(tablecontents) # Create automatic styles for the column widths. widewidth = Style(name="co1", family="table-column") widewidth.addElement( TableColumnProperties(columnwidth="2.8cm", breakbefore="auto")) textdoc.automaticstyles.addElement(widewidth) # Create the styles for $AUD format currency values ns1 = CurrencyStyle(name="positive-AUD", volatile="true") ns1.addElement(CurrencySymbol(language="en", country="AU", text=u"$")) ns1.addElement(Number(decimalplaces="2", minintegerdigits="1", grouping="true")) textdoc.styles.addElement(ns1)
from odf.opendocument import OpenDocumentSpreadsheet from odf.style import Style, TextProperties, ParagraphProperties, TableColumnProperties from odf.text import P from odf.table import Table, TableColumn, TableRow, TableCell if len(sys.argv) != 3: print "Usage: sqlite-db table" sys.exit(2) sqldb = sys.argv[1] sqltable = sys.argv[2] textdoc = OpenDocumentSpreadsheet() # Create a style for the table content. One we can modify # later in the word processor. tablecontents = Style(name="Table Contents", family="paragraph") tablecontents.addElement(ParagraphProperties(numberlines="false", linenumber="0")) #tablecontents.addElement(TextProperties(fontweight="bold")) textdoc.styles.addElement(tablecontents) # Create automatic styles for the column widths. # We want two different widths, one in inches, the other one in metric. # ODF Standard section 15.9.1 widthshort = Style(name="Wshort", family="table-column") widthshort.addElement(TableColumnProperties(columnwidth="1.7cm")) textdoc.automaticstyles.addElement(widthshort) widthwide = Style(name="Wwide", family="table-column") widthwide.addElement(TableColumnProperties(columnwidth="1.5in")) textdoc.automaticstyles.addElement(widthwide) # Start the table, and describe the columns
from odf.opendocument import OpenDocumentText from odf.text import P from odf.style import Style, MasterPage, PageLayout, PageLayoutProperties, TextProperties, GraphicProperties, ParagraphProperties, DrawingPageProperties, BackgroundImage from odf.draw import Page, Frame, TextBox, Image doc = OpenDocumentText() graphicStyleA = Style(name="graphicstyleA", family="graphic") gpA = GraphicProperties(border="1cm double #000000", padding="1cm", backgroundcolor="#cccccc") graphicStyleA.addElement(gpA) textStyleA = Style(name="textstyleA", family="paragraph") tpA = TextProperties(fontsize="16pt", fontfamily="Limousine") textStyleA.addElement(tpA) ppA = ParagraphProperties(textalign="right") textStyleA.addElement(ppA) graphicStyleB = Style(name="graphicstyleB", family="graphic") gpB = GraphicProperties(border="1cm double #000000", padding="1cm", backgroundcolor="#ff0000") graphicStyleB.addElement(gpB) textStyleB = Style(name="textstyleB", family="paragraph") tpB = TextProperties(fontsize="16pt", fontfamily="diluvienne") textStyleB.addElement(tpB) frameA = Frame(stylename=graphicStyleA, height="15cm", width="10cm") frameB = Frame(stylename=graphicStyleB, height="10cm", width="15cm") doc.styles.addElement(graphicStyleA) doc.styles.addElement(textStyleA)
def do_job(job): warnings = get_warnings(job['sts'], job['ets'], job['wfo'], job['wtype']) os.makedirs("/tmp/%s" % (job['jobid'],)) os.chdir("/tmp/%s" % (job['jobid'],)) basefn = "%s-%s-%s-%s-%s" % (job['wfo'], job['wtype'].replace(",", "_"), job['radar'], job['sts'].strftime("%Y%m%d%H"), job['ets'].strftime("%Y%m%d%H")) outputfile = "%s.odp" % (basefn,) doc = OpenDocumentPresentation() # We must describe the dimensions of the page pagelayout = PageLayout(name="MyLayout") doc.automaticstyles.addElement(pagelayout) pagelayout.addElement(PageLayoutProperties(margin="0pt", pagewidth="800pt", pageheight="600pt", printorientation="landscape")) # Style for the title frame of the page # We set a centered 34pt font with yellowish background titlestyle = Style(name="MyMaster-title2", family="presentation") titlestyle.addElement(ParagraphProperties(textalign="center")) titlestyle.addElement(TextProperties(fontsize="34pt")) titlestyle.addElement(GraphicProperties(fillcolor="#ffff99")) doc.styles.addElement(titlestyle) # Style for the title frame of the page # We set a centered 34pt font with yellowish background indexstyle = Style(name="MyMaster-title", family="presentation") indexstyle.addElement(ParagraphProperties(textalign="center")) indexstyle.addElement(TextProperties(fontsize="28pt")) indexstyle.addElement(GraphicProperties(fillcolor="#ffffff", stroke="none")) doc.styles.addElement(indexstyle) # Style for the photo frame photostyle = Style(name="MyMaster-photo", family="presentation") doc.styles.addElement(photostyle) # Every drawing page must have a master page assigned to it. masterpage = MasterPage(name="MyMaster", pagelayoutname=pagelayout) doc.masterstyles.addElement(masterpage) dpstyle = Style(name="dp1", family="drawing-page") #dpstyle.addElement(DrawingPageProperties(transitiontype="automatic", # transitionstyle="move-from-top", duration="PT5S")) doc.automaticstyles.addElement(dpstyle) # Title slide page = Page(masterpagename=masterpage) doc.presentation.addElement(page) frame = Frame(stylename=indexstyle, width="720pt", height="500pt", x="40pt", y="10pt") page.addElement( frame ) textbox = TextBox() frame.addElement(textbox) textbox.addElement(P(text="IEM Raccoon Report")) frame = Frame(stylename=indexstyle, width="720pt", height="500pt", x="40pt", y="150pt") page.addElement( frame ) textbox = TextBox() frame.addElement(textbox) textbox.addElement(P(text="WFO: %s" % (job['wfo'],))) textbox.addElement(P(text="Radar: %s Product: %s" % (job['radar'], job['nexrad_product']))) textbox.addElement(P(text="Phenomenas: %s" % (job['wtype'], ))) textbox.addElement(P(text="Start Time: %s UTC" % (job['sts'].strftime("%d %b %Y %H"),))) textbox.addElement(P(text="End Time: %s UTC" % (job['ets'].strftime("%d %b %Y %H"),))) textbox.addElement(P(text="")) textbox.addElement(P(text="Raccoon Version: %s" % (__REV__,))) textbox.addElement(P(text="Generated on: %s" % ( datetime.datetime.utcnow().strftime("%d %b %Y %H:%M %Z")))) textbox.addElement(P(text="")) textbox.addElement(P(text="Bugs/Comments/Yelling?: daryl herzmann [email protected]")) i = 0 for warning in warnings: # Make Index page for the warning page = Page(masterpagename=masterpage) doc.presentation.addElement(page) titleframe = Frame(stylename=indexstyle, width="700pt", height="500pt", x="10pt", y="10pt") page.addElement(titleframe) textbox = TextBox() titleframe.addElement(textbox) textbox.addElement(P(text="%s.O.NEW.K%s.%s.W.%04i" % ( job['sts'].year, job['wfo'], warning['phenomena'],warning['eventid']))) textbox.addElement(P(text="Issue: %s UTC" % ( warning['issue'].strftime("%d %b %Y %H:%M"),))) textbox.addElement(P(text="Expire: %s UTC" % ( warning['expire'].strftime("%d %b %Y %H:%M"),))) textbox.addElement(P(text="Poly Area: %.1f sq km (%.1f sq mi) [%.1f%% vs County]" % ( warning['polyarea'], warning['polyarea'] * 0.386102, warning['polyarea'] / warning['countyarea'] * 100.0))) textbox.addElement(P(text="County Area: %.1f square km (%.1f square miles)" % ( warning['countyarea'], warning['countyarea'] * 0.386102))) url = "http://iem21.local/GIS/radmap.php?" url += "layers[]=places&layers[]=legend&layers[]=ci&layers[]=cbw&layers[]=sbw" url += "&layers[]=uscounties&layers[]=bufferedlsr&lsrbuffer=15" url += "&vtec=%s.O.NEW.K%s.%s.W.%04i" % ( job['sts'].year, job['wfo'], warning['phenomena'],warning['eventid']) cmd = "wget -q -O %i.png '%s'" % (i, url) os.system(cmd) photoframe = Frame(stylename=photostyle, width="480pt", height="360pt", x="160pt", y="200pt") page.addElement(photoframe) href = doc.addPicture("%i.png" % (i,)) photoframe.addElement(Image(href=href)) i += 1 times = [] now = warning['issue'] while now < warning['expire']: times.append( now ) now += datetime.timedelta(minutes=15) times.append( warning['expire'] - datetime.timedelta(minutes=1)) for now in times: page = Page(stylename=dpstyle, masterpagename=masterpage) doc.presentation.addElement(page) titleframe = Frame(stylename=titlestyle, width="720pt", height="56pt", x="40pt", y="10pt") page.addElement(titleframe) textbox = TextBox() titleframe.addElement(textbox) textbox.addElement(P(text="%s.W.%04i Time: %s UTC" % ( warning['phenomena'],warning['eventid'], now.strftime("%d %b %Y %H%M")))) if job['nexrad_product'] == 'N0U': if now < SUPER_RES: n0qn0r = 'N0V' else: n0qn0r = 'N0U' else: if now < SUPER_RES: n0qn0r = 'N0R' else: n0qn0r = 'N0Q' url = "http://iem21.local/GIS/radmap.php?" url += "layers[]=ridge&ridge_product=%s&ridge_radar=%s&" % (n0qn0r, job['radar']) url += "layers[]=sbw&layers[]=sbwh&layers[]=uscounties&" url += "layers[]=lsrs&ts2=%s&" % ( (now + datetime.timedelta(minutes=15)).strftime("%Y%m%d%H%M"),) url += "vtec=%s.O.NEW.K%s.%s.W.%04i&ts=%s" % ( job['sts'].year, job['wfo'], warning['phenomena'],warning['eventid'], now.strftime("%Y%m%d%H%M")) cmd = "wget -q -O %i.png '%s'" % (i, url) os.system(cmd) photoframe = Frame(stylename=photostyle, width="640pt", height="480pt", x="80pt", y="70pt") page.addElement(photoframe) href = doc.addPicture("%i.png" % (i,)) photoframe.addElement(Image(href=href)) i += 1 doc.save(outputfile) del doc cmd = "unoconv -f ppt %s" % (outputfile,) os.system( cmd ) print "%s.ppt" % (basefn,) if os.path.isfile("%s.ppt" % (basefn,)): print 'Here!' shutil.copyfile("%s.ppt" % (basefn,), "/mesonet/share/pickup/raccoon/%s.ppt" % (basefn,))
def export_presentation(photos, destination, openafter=False): if destination[-4:] != ".odp": destination += ".odp" doc = OpenDocumentPresentation() # We must describe the dimensions of the page pagelayout = PageLayout(name="Layout") doc.automaticstyles.addElement(pagelayout) pagelayout.addElement(PageLayoutProperties(margin="0pt", pagewidth="800pt", pageheight="600pt", printorientation="landscape")) # Style for the title frame of the page # We set a centered 34pt font with yellowish background titlestyle = Style(name="Master-title", family="presentation") titlestyle.addElement(ParagraphProperties(textalign="center")) titlestyle.addElement(TextProperties(fontsize="34pt")) titlestyle.addElement(GraphicProperties(fillcolor="#ffffff")) doc.styles.addElement(titlestyle) # Style for the photo frame photostyle = Style(name="Master-photo", family="presentation") doc.styles.addElement(photostyle) # Create automatic transition dpstyle = Style(name="dp1", family="drawing-page") # dpstyle.addElement(DrawingPageProperties(transitiontype="automatic", transitionstyle="move-from-top", duration="PT5S")) doc.automaticstyles.addElement(dpstyle) # Every drawing page must have a master page assigned to it. masterpage = MasterPage(name="Master", pagelayoutname=pagelayout) doc.masterstyles.addElement(masterpage) for p in photos: path = p.getData() image = QImage(path) if(image.isNull()): continue w = image.width() h = image.height() if w > 720: h = float(h) * 720.0 / float(w) w = 720.0 if h > 540.0: w = float(w) * 540.0 / float(h) h = 540.0 page = Page(stylename=dpstyle, masterpagename=masterpage) doc.presentation.addElement(page) titleframe = Frame(stylename=titlestyle, width="720pt", height="56pt", x="40pt", y="10pt") page.addElement(titleframe) textbox = TextBox() titleframe.addElement(textbox) textbox.addElement(P(text=p.name)) offsetx = 400.0 - w/2.0 photoframe = Frame(stylename=photostyle, width="%fpt" % w, height="%fpt" % h, x="%fpt" % offsetx, y="56pt") page.addElement(photoframe) href = doc.addPicture(path) photoframe.addElement(Image(href=href)) os.remove(destination) doc.save(destination) if sys.platform.startswith('darwin'): subprocess.call(('open', destination)) elif os.name == 'nt': os.startfile(destination) elif os.name == 'posix': subprocess.call(('xdg-open', destination))
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA # # Contributor(s): # # This example shows how to create a manual page break. from odf.opendocument import OpenDocumentText from odf.style import Style, TextProperties, ParagraphProperties from odf.text import P textdoc = OpenDocumentText() # Create a style for the paragraph with page-break withbreak = Style(name="WithBreak", parentstylename="Standard", family="paragraph") withbreak.addElement(ParagraphProperties(breakbefore="page")) textdoc.automaticstyles.addElement(withbreak) p = P(text=u'First paragraph') textdoc.text.addElement(p) p = P(stylename=withbreak,text=u'Second paragraph') textdoc.text.addElement(p) textdoc.save("pagebreak_odfpy.odt")