Exemplo n.º 1
0
 def add_title(self, title, width):
     row = TableRow()
     cell = TableCell(stylename="title")
     cell.setAttrNS(TABLENS, "number-columns-spanned", width)
     cell.addElement(P(text=title))
     row.addElement(cell)
     self.sheet.addElement(row)
Exemplo n.º 2
0
 def insertColumn(self, sheetname, columnname, columnnumber):
     """Inserts a new empty column into the current doc.
     @param sheetname: The name of the sheet to be added to.
     @type sheetname: string
     @param columnname: The name of the new column to be added
     @type columnname: string
     @param columnnumber: Where to insert the new column (= how many come before it?)
     @type columnnumber: int
     """
     sheets = self._doc.spreadsheet.getElementsByType(Table)
     for sheet in sheets:
         if sheet.getAttribute('name') == sheetname:
             rownum = 0
             rows   = sheet.getElementsByType(TableRow)
             for row in rows:
                 colNum = 0
                 cells  = row.getElementsByType(TableCell)
                 for cell in cells:
                     if colNum == columnnumber:
                         newCell = TableCell()
                         if rownum == 0:
                             p = P()
                             p.addText(unicode(columnname))
                             newCell.addElement(p)
                         else:
                             p = P()
                             p.addText(unicode(''))
                             newCell.addElement(p)
                         row.insertBefore(newCell, cell)
                     colNum += 1
                 rownum += 1
Exemplo n.º 3
0
 def add_row( self, _tuple, stylename):
     tr = TableRow()
     self.table.addElement(tr)
     for _c in _tuple:
         tc = TableCell( stylename= stylename )
         tr.addElement(tc)
         p = P(text = _c )
         tc.addElement(p)
Exemplo n.º 4
0
def addcell(tr, val, lestyle):
    if val == 'True':
        val = "Oui"
    if val == 'False':
        val = "Non"
    tc = TableCell(stylename=lestyle)
    tr.addElement(tc)
    p = P(text=val)
    tc.addElement(p)
Exemplo n.º 5
0
    def generate_ods(self, path="/home/apkawa/work/test_desu", group=False):
        self.make_style( tablename = self.category.name )

        self.add_spanned_row( (u'OOO "Политехник"',), self.head )
        head = (
                ( u'phone:','+7 (812) 312-42-38'),
                ( u'','+7 (812) 970-42-93'),
                ( u'email:','*****@*****.**'),
                ( u'www:','http://polytechnik.ru'),
                ('',),
                )
        self.add_rows( head, self.head )
        self.add_row( ( u'Прайс от %s'%date,), self.root_style )
        self.add_spanned_row( (self.category.name, ), self.tablemanuf )
        
        self.add_row( ( u'Наименование',u'Описание',u'Цена',), self.tablehead )


        manuf = None
        type_product = 13
        for p in self.price:

            if manuf != p.manufacturer_id and p.manufacturer_id != 233:
                manuf = p.manufacturer.id
                self.add_spanned_row( (p.manufacturer.name,) , self.tablemanuf )

            if type_product != p.type_product_id and p.type_product_id != 13:
                type_product = p.type_product_id
                self.add_spanned_row( ( p.type_product.name,) , self.tablemanuf )

            p_desc = p.desc
            p_cell = ' %.0f %s'%(p.cell, p.valyuta.desc) if p.cell else ' -'

            if p_desc:
                self.add_row( ( p.name, p_desc, p_cell  ) , self.tablecontents )
            elif not p.desc and not p.cell:
                p_name = re.sub('(<h4>|</h4>)','',p.name)
                self.add_spanned_row( (p_name,), self.tablehead )
            else:
                tr = TableRow( stylename = self.tablecontents )
                self.table.addElement(tr)
                p_price = ( p.name, p_cell )

                #self.add_cell( pl, tr, self.tablecontents, )#numbercolumnsspanned=2, numberrowsspanned = 1 )
                tc = TableCell( stylename= self.tablecontents, numbercolumnsspanned=2, numberrowsspanned = 1 )
                tr.addElement(tc)
                p = P(text=p_price[0])
                tc.addElement(p)

                tr.addElement( CoveredTableCell() )


                self.add_cell( p_price[1], tr, self.tablecontents )

        self.doc.spreadsheet.addElement( self.table )
        self.doc.save( path , True)
Exemplo n.º 6
0
    def write_captions(self, sheet, table):
        """ Writes sheet's caption row to table.
        """

        row = TableRow()
        for caption in sheet.captions:
            cell = TableCell()
            cell.addElement(P(text=caption))
            row.addElement(cell)
        table.addElement(row)
Exemplo n.º 7
0
def cell(tr, val, style=None):
    print "[cell] type=%s" % str(type(val))
    print "[cell] type=%s" % str(val)
    if style is None:
        tc = TableCell(valuetype=valuetype(val), value=str(val))
    else:
        tc = TableCell(stylename=style, valuetype=valuetype(val), value=str(val))
    tr.addElement(tc)
    p = P(stylename=tablecontents, text=str(val))
    tc.addElement(p)
Exemplo n.º 8
0
 def add_spanned_row( self, _tuple, stylename, _count_col_spanned = 3):
     tr = TableRow()
     self.table.addElement(tr)
     for _c in _tuple:
         tc = TableCell( stylename= stylename )
         tc = TableCell( stylename= stylename, numbercolumnsspanned= _count_col_spanned, numberrowsspanned = 1 )
         tr.addElement(tc)
         p = P(text = _c )
         tc.addElement(p)
         tr.addElement( CoveredTableCell() )
Exemplo n.º 9
0
 def sumtable():
     ad = {u"Напряжение" : u' (В)', u"Ток" : u' (А)', u"Мощность" : u' (Вт/c)'}
     table = Table()
     table.addElement(TableColumn(numbercolumnsrepeated = len(ampl)+1, stylename = tablestyle))
     tr = TableRow()
     tc = TableCell()
     tr.addElement(tc)
     for a in ampl:
         tr.addElement(ttb(tabletextbold, a))
     table.addElement(tr)
     for antenna in sorted(dictwire[wire].keys()):
         tr = TableRow()
         tr.addElement(ttb(tabletextbold, antenna))
         table.addElement(tr)
         for port in sorted(dictwire[wire][antenna].keys()):
             for m in [u"Напряжение", u"Ток", u"Мощность"]:
                 tr = TableRow()
                 tr.addElement(ttb(tabletextbold, m+ad[m]))
                 if port is not None:
                     tr.addElement(ttb(tabletextbold, port))
                 table.addElement(tr)
                 for rg in sorted(dictwire[wire][antenna][port].keys()):
                     for k in dictwire[wire][antenna][port][rg].keys():
                         if k != None:
                             b = sorted(dictwire[wire][antenna][port][rg].keys(), key = len)
                         else:
                             b = dictwire[wire][antenna][port][rg].keys()
                     for distance in b:
                         tr = TableRow()
                         tc = TableCell()
                         try:
                             p = P(text = distance + ', ' + rg)
                         except:
                             p = P(text = rg)
                         tc.addElement(p)
                         tr.addElement(tc)
                         for amplitude in ampl:
                             try:
                                 if m == u"Мощность":
                                     a = data[dictwire[wire][antenna][port][rg][distance][amplitude][u"Напряжение"]]
                                     amu = a.energy((0,len(a.xvalue)), bytime = True)
                                     amu = '{0:.03e}'.format(amu)
                                     wiretype = a.params['wiretype']
                                 else:
                                     a = data[dictwire[wire][antenna][port][rg][distance][amplitude][m]]
                                     amu = a.max()
                                     amu = '{0:.03f}'.format(amu)
                                     wiretype = a.params['wiretype']
                             except KeyError:
                                 amu = u'--'
                             tr.addElement(ttb(tabletext, amu))
                         table.addElement(tr)
     return [table, wiretype]
Exemplo n.º 10
0
	def make_row(self, row):
		""" For each item in array add a cell to a row """
		tr = TableRow()
		for cell_text in row:
			try:
				#i = int(cell_text)
				tc = TableCell(formula=cell_text)
			except:
				tc = TableCell()
				txt = P(text=cell_text)
				tc.addElement(txt)

			tr.addElement(tc)

		return tr
Exemplo n.º 11
0
 def skills(self) :
     t = self.doc.text
     t.addElement(P(text='RELEVANT SKILLS', stylename="Heading"))
     table = Table(name="skills-table")
     col = 0
     skills_cols = int(self.config.fetch('skills_cols'))
     table.addElement(TableColumn(numbercolumnsrepeated=skills_cols))
     for skill in Resume.skills(self) :
         if col % skills_cols == 0 :
             tr = TableRow()
             table.addElement(tr)
         tc = TableCell(valuetype="string")
         tc.addElement(P(text=skill,stylename="List"))
         tr.addElement(tc)             
         col += 1
     t.addElement(table)
Exemplo n.º 12
0
 def AddCell(self, attributes=None, rowspan=1, colspan=1):
     tc = TableCell(attributes=attributes)
     tc.number = self.nextcell
     self.nextcell += colspan
     tc.setAttribute('numberrowsspanned', str(rowspan))
     tc.setAttribute('numbercolumnsrepeated', str(colspan))
     tc.setAttribute('numbercolumnsspanned', str(colspan))
     self.row.addElement(tc)
     return tc
Exemplo n.º 13
0
 def openSpreadsheet(self):
     """(Re)Loads the spreadsheet."""
     self._doc = load(self._filepath)
     
     rows      = self._doc.spreadsheet.getElementsByType(TableRow)
     dataWidth = 1
     
     # Determine data-width (as opposed to trailing blank cells)
     cells = rows[0].getElementsByType(TableCell)
     for cell in cells[1:]:
         pl = cell.getElementsByType(P)
         if len(pl) > 0 and (pl[0].firstChild) and len(unicode(pl[0].firstChild)) > 0:
             dataWidth += 1
         else:
             break
     
     # Expand out / decompress repeated cells (e.g. number-columns-repeated="2")
     for row in rows:
         cells  = row.getElementsByType(TableCell)
         colNum = 0
         for cell in cells:
             if colNum < dataWidth:
                 repeated = int(cell.getAttribute('numbercolumnsrepeated') or 0)
                 pl = cell.getElementsByType(P)
                 if repeated > 1:
                     if len(pl) > 0 and (pl[0].firstChild) and len(unicode(pl[0].firstChild)) > 0:
                         for i in range(repeated):
                             c = TableCell()
                             p = P()
                             p.addText(unicode(pl[0].firstChild))
                             c.addElement(p)
                             row.insertBefore(c, cell)
                         row.removeChild(cell)
                     else:
                         for i in range(min(repeated, dataWidth-colNum)):
                             c = TableCell()
                             p = P()
                             p.addText(unicode(''))
                             c.addElement(p)
                             row.insertBefore(c, cell)
                         row.removeChild(cell)
             else:
                 row.removeChild(cell)
             colNum += 1
             
         # Add a constant 3 trailing columns
         for i in range(3):
             c = TableCell()
             p = P()
             p.addText(unicode(''))
             c.addElement(p)
             row.addElement(c)
Exemplo n.º 14
0
    def add_rows(self, _tuple, stylename):
        '''
        _tuple example

        (
        ('','',), # 1 row
        ('','','',), # 2 row
        )
        '''
        for _r in _tuple:
            tr = TableRow()
            self.table.addElement(tr)
            for _c in _r:
                tc = TableCell( stylename= stylename )
                tr.addElement(tc)
                p = P(text = _c )
                tc.addElement(p)
Exemplo n.º 15
0
 def addTable(self, content, cell_style, column_styles=[]):
     """  """
     cell_style = getattr(self, cell_style, None)
     table = Table()
     for style in column_styles:
         if "stylename" in style.keys():
             style["stylename"] = getattr(self, style["stylename"], None)
             table.addElement(TableColumn(**style))
     for row in content:
         tr = TableRow()
         table.addElement(tr)
         for cell in row:
             tc = TableCell()
             tr.addElement(tc)
             p = P(stylename=cell_style,text=cell)
             tc.addElement(p)
     self.document.text.addElement(table)
Exemplo n.º 16
0
    def write_row(self, sheet_row, table):
        """ Appends ``sheet_row`` data into table.
        """

        row = TableRow()
        for field in sheet_row:
            if isinstance(field, datetime.datetime):
                field = unicode(field.strftime('%Y-%m-%d %H:%M:%S'))
            elif isinstance(field, datetime.date):
                field = unicode(field.strftime('%Y-%m-%d'))
            elif not isinstance(field, unicode):
                field = unicode(field)
            cell = TableCell()
            cell.addElement(P(text=field))
            row.addElement(cell)

        table.addElement(row)
Exemplo n.º 17
0
def create_odf_table_row(data, first=""):
    """
    returns a odt table row that contains the passed data in odf table cells

    input:
        first   style scheme of the first row's cells

    output:
        row     the created table row containing cells with corresponding data

    """
    row = TableRow()

    for i, item in enumerate(data):

        # we need to distinguish between first column, middle columns and last
        # columns. The first and the last have outer borders, while the middle
        # have not. If we draw the first row, skip this and use the passed
        # style.
        if not first:

            # first
            if i == 0:
                style = "col_left"

            # last
            elif i == (len(data)-1):
                style = "col_right"

            # middle
            else:
                style = "col_middle"

        else:
            style = first

        logger.debug("cell content (i=%d):%s, style=%s", i, item, style)

        cell = TableCell(valuetype= 'string', stylename=style)
        cell.addElement(P(text=item, stylename="default"))
        row.addElement(cell)

    return row
Exemplo n.º 18
0
 def write_cell(self, row, cell):
     tc = TableCell()
     cell_type = type(cell)
     cell_odf_type = ODS_WRITE_FORMAT_COVERSION.get(cell_type, "string")
     tc.setAttrNS(OFFICENS, "value-type", cell_odf_type)
     cell_odf_value_token = VALUE_TOKEN.get(cell_odf_type, "value")
     converter = ODS_VALUE_CONVERTERS.get(cell_odf_type, None)
     if converter:
         cell = converter(cell)
     if cell_odf_type != 'string':
         tc.setAttrNS(OFFICENS, cell_odf_value_token, cell)
         tc.addElement(P(text=cell))
     else:
         lines = cell.split('\n')
         for line in lines:
             tc.addElement(P(text=line))
     row.addElement(tc)
Exemplo n.º 19
0
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 ()
Exemplo n.º 20
0
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
Exemplo n.º 21
0
 def write_cell(self, row, x):
     tc = TableCell()
     x_type = type(x)
     x_odf_type = ODS_WRITE_FORMAT_COVERSION.get(x_type, "string")
     tc.setAttrNS(OFFICENS, "value-type", x_odf_type)
     x_odf_value_token = VALUE_TOKEN.get(x_odf_type, "value")
     converter = ODS_VALUE_CONVERTERS.get(x_odf_type, None)
     if converter:
         x = converter(x)
     if x_odf_type != 'string':
         tc.setAttrNS(OFFICENS, x_odf_value_token, x)
     tc.addElement(P(text=x))
     row.addElement(tc)
Exemplo n.º 22
0
    def _get_cell(self, label, stylename=None):
        """
        Build a TableCell and adapt the format to the provided label format

        :param label: The data to write (int/float/bool/date/str/unicode)
        :param str stylename: One of the stylenames added in the __init__
        :returns: A TableCell instance
        """
        if stylename is not None:
            cell_to_be_written = TableCell(stylename=stylename)
        else:
            cell_to_be_written = TableCell()
        cell_type = type(label)
        cell_odf_type = converter.ODS_WRITE_FORMAT_COVERSION.get(
            cell_type,
            "string"
        )
        cell_to_be_written.setAttrNS(OFFICENS, "value-type", cell_odf_type)
        cell_odf_value_token = converter.VALUE_TOKEN.get(
            cell_odf_type,
            "value",
        )
        converter_func = converter.ODS_VALUE_CONVERTERS.get(
            cell_odf_type,
            None
        )
        if converter_func:
            label = converter_func(label)
        if cell_odf_type != 'string':
            cell_to_be_written.setAttrNS(OFFICENS, cell_odf_value_token, label)
            cell_to_be_written.addElement(P(text=label))
        else:
            lines = label.split('\n')
            for line in lines:
                cell_to_be_written.addElement(P(text=line))
        return cell_to_be_written
Exemplo n.º 23
0
 def write_cell(self, row, cell):
     """write a native cell"""
     cell_to_be_written = TableCell()
     cell_type = type(cell)
     cell_odf_type = converter.ODS_WRITE_FORMAT_COVERSION.get(
         cell_type, "string")
     cell_to_be_written.setAttrNS(OFFICENS, "value-type", cell_odf_type)
     cell_odf_value_token = converter.VALUE_TOKEN.get(
         cell_odf_type, "value")
     converter_func = converter.ODS_VALUE_CONVERTERS.get(
         cell_odf_type, None)
     if converter_func:
         cell = converter_func(cell)
     if cell_odf_type != 'string':
         cell_to_be_written.setAttrNS(OFFICENS, cell_odf_value_token, cell)
         cell_to_be_written.addElement(P(text=cell))
     else:
         lines = cell.split('\n')
         for line in lines:
             cell_to_be_written.addElement(P(text=line))
     row.addElement(cell_to_be_written)
Exemplo n.º 24
0
 def NameDatePair(self, a, b) :
     table = Table(name="t")
     table.addElement(TableColumn(numbercolumnsrepeated="1",
                                  stylename="widecolumn"))
     table.addElement(TableColumn(numbercolumnsrepeated="1",
                                  stylename="narrowcolumn"))
     tr = TableRow()
     tc = TableCell(valuetype="string")
     tc.addElement(P(text=a,stylename="Name"))
     tr.addElement(tc)             
     tc = TableCell(valuetype="string")
     tc.addElement(P(text=b,stylename="RightItalic"))
     tr.addElement(tc)             
     table.addElement(tr)
     return table
Exemplo n.º 25
0
	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)
Exemplo n.º 26
0
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
textdoc.automaticstyles.addElement(widthwide)

# Start the table, and describe the columns
table = Table(name=sqltable)
#table.addElement(TableColumn(numbercolumnsrepeated=4,stylename=widthshort))
#table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))

cx = sqlite.connect(sqldb)
cu = cx.cursor()
cu.execute("select * from %s" % sqltable)
for row in cu.fetchall():
    tr = TableRow()
    table.addElement(tr)
    for val in row:
        tc = TableCell()
        tr.addElement(tc)
        if type(val) == type(''):
	    textval = unicode(val,'utf-8')
        else:
            textval = str(val)
        p = P(stylename=tablecontents,text=textval)
        tc.addElement(p)

cx.close()

textdoc.spreadsheet.addElement(table)
textdoc.save(sqltable, True)

Exemplo n.º 27
0
    def insert_table_(self,ar,column_names=None,table_width=180):
        ar.setup_from(self.ar)
        columns, headers, widths = ar.get_field_info(column_names)
        widths = map(int,widths)
        tw = sum(widths)
        """
        specifying relative widths doesn't seem to work
        (and that's a pity because absolute widths requires us 
        to know the table_width). 
        """
        use_relative_widths = False
        if use_relative_widths:
            width_specs = ["%d*" % (w*100/tw) for w in widths]
            #~ width_specs = [(w*100/tw) for w in widths]
        else:
            #~ total_width = 180 # suppose table width = 18cm = 180mm
            width_specs = ["%dmm" % (table_width*w/tw) for w in widths]
        #~ else:
            #~ width_specs = []
            #~ for w in widths:
				#~ if w.endswith('%'):
					#~ mm = float(w[:-1]) * table_width / 100
					#~ width_specs.append("%dmm" % mm)
				#~ else:
        #~ print 20120419, width_specs 
        
        doc = OpenDocumentText()
        
        def add_style(**kw):
            st = Style(**kw)
            doc.styles.addElement(st)
            self.my_styles.append(st)
            return st
            

        table_style_name = str(ar.actor)
        st = add_style(name=table_style_name, family="table",parentstylename="Default")
        st.addElement(TableProperties(align="margins", maybreakbetweenrows="0"))
        
        # create some *visible* styles
        
        st = add_style(name="Table Contents", family="paragraph",parentstylename="Default")
        st.addElement(ParagraphProperties(numberlines="false", 
            linenumber="0"))
            
        st = add_style(name="Number Cell", family="paragraph",parentstylename="Table Contents")
        st.addElement(ParagraphProperties(numberlines="false", 
            textalign="end", justifysingleword="true",
            linenumber="0"))
        
        dn = "Table Column Header"
        st = self.stylesManager.styles.getStyle(dn)
        if st is None:
            st = add_style(name=dn, family="paragraph",parentstylename="Table Contents")
            st.addElement(ParagraphProperties(numberlines="false", linenumber="0"))
            st.addElement(TextProperties(fontweight="bold"))
        
        dn = "Bold Text"
        st = self.stylesManager.styles.getStyle(dn)
        if st is None:
            st = add_style(name=dn, family="text",parentstylename="Default")
            #~ st = add_style(name=dn, family="text")
            st.addElement(TextProperties(fontweight="bold"))

        if False:
            dn = "L1"
            st = self.stylesManager.styles.getStyle(dn)
            if st is None:
                st = ListStyle(name=dn)
                doc.styles.addElement(st)
                p = ListLevelProperties(listlevelpositionandspacemode="label-alignment")
                st.addElement(p)
                #~ label-followed-by="listtab" text:list-tab-stop-position="1.27cm" fo:text-indent="-0.635cm" fo:margin-left="1.27cm"/>
                p.addElement(ListLevelLabelAlignment(labelfollowedby="listtab",
                    listtabstopposition="1.27cm",
                    textindent="-0.635cm",
                    marginleft="1.27cm"
                  ))
                self.my_styles.append(st)
                
                #~ list_style = add_style(name=dn, family="list")
                bullet = text.ListLevelStyleBullet(level=1,stylename="Bullet_20_Symbols",bulletchar=u"•")
                #~ bullet = text.ListLevelStyleBullet(level=1,stylename="Bullet_20_Symbols",bulletchar=u"*")
                #~ <text:list-level-style-bullet text:level="1" text:style-name="Bullet_20_Symbols" text:bullet-char="•">
                st.addElement(bullet)
        
        # create some automatic styles
        
        def add_style(**kw):
            st = Style(**kw)
            doc.automaticstyles.addElement(st)
            self.my_automaticstyles.append(st)
            return st
            
        cell_style = add_style(name="Lino Cell Style",family="table-cell")
        cell_style.addElement(TableCellProperties(
            paddingleft="1mm",paddingright="1mm",
            paddingtop="1mm",paddingbottom="0.5mm",
            border="0.002cm solid #000000"))
            
        header_row_style = add_style(name="Lino Header Row",family="table-row",parentstylename=cell_style)
        header_row_style.addElement(TableRowProperties(backgroundcolor="#eeeeee"))
        
        total_row_style = add_style(name="Lino Total Row",family="table-row",parentstylename=cell_style)
        total_row_style.addElement(TableRowProperties(backgroundcolor="#ffffff"))
        
        table = Table(name=table_style_name,stylename=table_style_name)
        table_columns = TableColumns()
        table.addElement(table_columns)
        table_header_rows = TableHeaderRows()
        table.addElement(table_header_rows)
        table_rows = TableRows()
        table.addElement(table_rows)
        
        # create table columns and automatic table-column styles 
        for i,fld in enumerate(columns):
            #~ print 20120415, repr(fld.name)
            name = str(ar.actor)+"."+fld.name
            cs = add_style(name=name, family="table-column")
            if use_relative_widths:
                cs.addElement(TableColumnProperties(relcolumnwidth=width_specs[i]))
            else:
                cs.addElement(TableColumnProperties(columnwidth=width_specs[i]))
            #~ cs.addElement(TableColumnProperties(useoptimalcolumnwidth='true'))
            #~ k = cs.getAttribute('name')
            #~ renderer.stylesManager.styles[k] = toxml(e)
            #~ doc.automaticstyles.addElement(cs)
            #~ self.my_automaticstyles.append(cs)
            table_columns.addElement(TableColumn(stylename=name))
            
        from lino.ui import elems
        def fldstyle(fld):
            #~ if isinstance(fld,ext_store.VirtStoreField):
                #~ fld = fld.delegate
            if isinstance(fld,elems.NumberFieldElement):
                return "Number Cell"
            return "Table Contents"
        
        def value2cell(ar,i,fld,val,style_name,tc):
            #~ text = html2odt.html2odt(fld.value2html(ar,val))
            params = dict()
            #~ if isinstance(fld,ext_store.BooleanStoreField):
                #~ params.update(text=fld.value2html(ar,val))
            #~ else:
                #~ params.update(text=fld.format_value(ar,val))
            #~ params.update(text=fld.format_value(ar,val))
            txt = fld.value2html(ar,val)
            
            p = text.P(stylename=style_name)
            html2odf(txt,p)
            
            try:
                tc.addElement(p)
            except Exception as e:
                logger.warning("20120614 addElement %s %s %r : %s", i, fld, val, e)
                #~ print 20120614, i, fld, val, e
                
            #~ yield P(stylename=tablecontents,text=text)
            
        # create header row
        #~ hr = TableRow(stylename=HEADER_ROW_STYLE_NAME)
        hr = TableRow(stylename=header_row_style)
        table_header_rows.addElement(hr)
        for h in headers:
        #~ for fld in fields:
            #~ tc = TableCell(stylename=CELL_STYLE_NAME)
            tc = TableCell(stylename=cell_style)
            tc.addElement(text.P(
                stylename="Table Column Header",
                #~ text=force_unicode(fld.field.verbose_name or fld.name)))
                text=force_unicode(h)))
            hr.addElement(tc)
            
        sums  = [fld.zero for fld in columns]
          
        for row in ar.data_iterator:
            #~ for grp in ar.group_headers(row):
                #~ raise NotImplementedError()
            tr = TableRow()
            
            has_numeric_value = False
            
            for i,fld in enumerate(columns):
                #~ tc = TableCell(stylename=CELL_STYLE_NAME)
                tc = TableCell(stylename=cell_style)
                #~ if fld.field is not None:
                v = fld.field._lino_atomizer.full_value_from_object(row,ar)
                stylename = fldstyle(fld)
                if v is None:
                    tc.addElement(text.P(stylename=stylename,text=''))
                else:
                    value2cell(ar,i,fld,v,stylename,tc)
                    
                    
                    nv = fld.value2num(v)
                    if nv != 0:
                        sums[i] += nv
                        has_numeric_value = True
                    #~ sums[i] += fld.value2num(v)
                tr.addElement(tc)
            
            if has_numeric_value or not ar.actor.hide_zero_rows:
                table_rows.addElement(tr)
                
        if not ar.actor.hide_sums:
            if sums != [fld.zero for fld in columns]:
                tr = TableRow(stylename=total_row_style)
                table_rows.addElement(tr)
                for i,fld in enumerate(columns):
                    tc = TableCell(stylename=cell_style)
                    stylename = fldstyle(fld)
                    p = text.P(stylename=stylename)
                    e = fld.format_sum(ar,sums,i)
                    html2odf(e,p)
                    tc.addElement(p)
                    #~ if len(txt) != 0: 
                        #~ msg = "html2odf() returned "
                        #~ logger.warning(msg)
                    #~ txt = tuple(html2odf(fld.format_sum(ar,sums,i),p))
                    #~ assert len(txt) == 1
                    #~ tc.addElement(text.P(stylename=stylename,text=txt[0]))
                    tr.addElement(tc)
            

        doc.text.addElement(table)
        return toxml(table)
Exemplo n.º 28
0
Arquivo: views.py Projeto: zxdvd/snoek
def _toODSTable(v_table):
    # generate an ods file to download
    # input: Object VoteTable
    # output: Object ods.table

    table= Table(name=v_table.title)

    row_head = v_table.row_head
    col_head = v_table.col_head
    table_body = v_table.table_body

    # Render column head if it is a 2D table
    if v_table.is2D():
        table.name = '2D'
        tr= TableRow()
        table.addElement(tr)
        td= TableCell()
        td.addElement(P(text='Head'))
        tr.addElement(td)
        for headcell in v_table.col_head:
            td= TableCell()
            td.addElement(P(text=headcell.content))
            tr.addElement(td)

    for cursorRow in v_table.table_with_row:
        tr= TableRow()
        table.addElement(tr)
        td= TableCell()
        td.addElement(P(text=cursorRow['row_head'].content))
        tr.addElement(td)

        for val in cursorRow['row_body']:
            td= TableCell()
            td.addElement(P(text=val))
            tr.addElement(td)

    #myFile= tempfile.TemporaryFile('/tmp/')
    #doc.save('/tmp/test', True)
    return table
Exemplo n.º 29
0
    def to_ods(self, *selection):
        if not ODFLIB_INSTALLED:
            raise ODFLIBNotInstalled(_("odfpy not installed."))
        if self.fcn_list:
            stat_list = self.fcn_list[:]
            order_text = "   Ordered by: " + self.sort_type + "\n"
        else:
            stat_list = self.stats.keys()
            order_text = "   Random listing order was used\n"
        for s in selection:
            stat_list, __ = self.eval_print_amount(s, stat_list, "")
        spreadsheet = OpenDocumentSpreadsheet()
        table = Table(name="Profile")
        for fn in self.files:
            tcf = TableCell()
            tcf.addElement(P(text=fn))
            trf = TableRow()
            trf.addElement(tcf)
            table.addElement(trf)

        tc_summary = TableCell()
        summary_text = (
            "%d function calls (%d primitive calls) in %.6f \
                        seconds"
            % (self.total_calls, self.prim_calls, self.total_tt)
        )
        tc_summary.addElement(P(text=summary_text))
        tr_summary = TableRow()
        tr_summary.addElement(tc_summary)
        table.addElement(tr_summary)

        tc_order = TableCell()
        tc_order.addElement(P(text=order_text))
        tr_order = TableRow()
        tr_order.addElement(tc_order)
        table.addElement(tr_order)

        tr_header = TableRow()
        tc_cc = TableCell()
        tc_cc.addElement(P(text="Total Call Count"))
        tr_header.addElement(tc_cc)

        tc_pc = TableCell()
        tc_pc.addElement(P(text="Primitive Call Count"))
        tr_header.addElement(tc_pc)

        tc_tt = TableCell()
        tc_tt.addElement(P(text="Total Time(seconds)"))
        tr_header.addElement(tc_tt)

        tc_pc = TableCell()
        tc_pc.addElement(P(text="Time Per call(seconds)"))
        tr_header.addElement(tc_pc)

        tc_ct = TableCell()
        tc_ct.addElement(P(text="Cumulative Time(seconds)"))
        tr_header.addElement(tc_ct)

        tc_pt = TableCell()
        tc_pt.addElement(P(text="Cumulative Time per call(seconds)"))
        tr_header.addElement(tc_pt)

        tc_nfl = TableCell()
        tc_nfl.addElement(P(text="filename:lineno(function)"))
        tr_header.addElement(tc_nfl)

        table.addElement(tr_header)

        for func in stat_list:
            cc, nc, tt, ct, __ = self.stats[func]
            tr_header = TableRow()
            tc_nc = TableCell()
            tc_nc.addElement(P(text=nc))
            tr_header.addElement(tc_nc)

            tc_pc = TableCell()
            tc_pc.addElement(P(text=cc))
            tr_header.addElement(tc_pc)

            tc_tt = TableCell()
            tc_tt.addElement(P(text=tt))
            tr_header.addElement(tc_tt)

            tc_tpc = TableCell()
            tc_tpc.addElement(P(text=(None if nc == 0 else float(tt) / nc)))
            tr_header.addElement(tc_tpc)

            tc_ct = TableCell()
            tc_ct.addElement(P(text=ct))
            tr_header.addElement(tc_ct)

            tc_tpt = TableCell()
            tc_tpt.addElement(P(text=(None if cc == 0 else float(ct) / cc)))
            tr_header.addElement(tc_tpt)

            tc_nfl = TableCell()
            tc_nfl.addElement(P(text=func))
            tr_header.addElement(tc_nfl)
            table.addElement(tr_header)

        spreadsheet.spreadsheet.addElement(table)
        tmp_ods = tempfile.TemporaryFile()
        spreadsheet.write(tmp_ods)
        tmp_ods.seek(0)
        data = tmp_ods.read()
        os.close(tmp_ods)
        return data
Exemplo n.º 30
0
def doit(args) :
    logfile = args.logger
    if args.report: logfile.loglevel = args.report

    try:
        root = ET.parse(args.input).getroot()
    except:
        logfile.log("Error parsing FTML input", "S")

    if args.font:                   # font(s) specified on command line
        fontlist = getfonts( args.font, logfile )
    else:                           # get font spec from FTML fontsrc element
        fontlist = getfonts( [root.find("./head/fontsrc").text], logfile, False )
        #fontlist = getfonts( [fs.text for fs in root.findall("./head/fontsrc")], False ) ### would allow multiple fontsrc elements
    numfonts = len(fontlist)
    if numfonts == 0:
        logfile.log("No font(s) specified", "S")
    if numfonts > 1:
        formattedfontnum = ["{0:02d}".format(n) for n in range(numfonts)]
    else:
        formattedfontnum = [""]
    logfile.log("Font(s) specified:", "V")
    for n, (fontname, bold, italic, embeddedfont) in enumerate(fontlist):
        logfile.log(" " + formattedfontnum[n] + " " + fontname + BoldItalic(bold, italic) + " " + str(embeddedfont), "V")

    # get optional fontscale; compute pointsize as int(12*fontscale/100). If result xx is not 12, then add "fo:font-size=xxpt" in Px styles
    pointsize = 12
    fontscaleel = root.find("./head/fontscale")
    if fontscaleel != None:
        fontscale = fontscaleel.text
        try:
            pointsize = int(int(fontscale)*12/100)
        except ValueError:
            # any problem leaves pointsize 12
            logfile.log("Problem with fontscale value; defaulting to 12 point", "W")

    # Get FTML styles and generate LO writer styles
    # P2 is paragraph style for string element when no features specified
    # each Px (for P3...) corresponds to an FTML style, which specifies lang or feats or both
    # if numfonts > 1, two-digit font number is appended to make an LO writer style for each FTML style + font combo
    # When LO writer style is used with attribute rtl="True", "R" appended to style name
    LOstyles = {}
    ftmlstyles = {}
    Pstylenum = 2
    LOstyles["P2"] = ("", None, None)
    ftmlstyles[0] = "P2"
    for s in root.findall("./head/styles/style"):
        Pstylenum += 1
        Pnum = "P" + str(Pstylenum)
        featstring = ""
        if s.get('feats'):
            featstring = parsefeats(s.get('feats'))
        langname = None
        countryname = None
        lang = s.get('lang')
        if lang != None:
            x = re.match(langcode, lang)
            langname = x.group('langname')
            countryname = x.group('countryname')
        # FTML <test> element @stylename attribute references this <style> element @name attribute
        ftmlstyles[s.get('name')] = Pnum
        LOstyles[Pnum] = (featstring, langname, countryname)

    # create LOwriter file and construct styles for tables, column widths, etc.
    LOdoc = OpenDocumentText()
    init(LOdoc, numfonts)
    # Initialize sequence counters
    sds = SequenceDecls()
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Illustration'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Table'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Text'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Drawing'))
    LOdoc.text.addElement(sds)

    # Create Px style for each (featstring, langname, countryname) tuple in LOstyles
    # and for each font (if >1 font, append to Px style name a two-digit number corresponding to the font in fontlist)
    # and (if at least one rtl attribute) suffix of nothing or "R"
    # At the same time, collect info for creating FontFace elements (and any embedded fonts)
    suffixlist = ["", "R"] if root.find(".//test/[@rtl='True']") != None else [""]
    fontfaces = {}
    for p in sorted(LOstyles, key = lambda x : int(x[1:])):  # key = lambda x : int(x[1:]) corrects sort order
        featstring, langname, countryname = LOstyles[p]
        for n, (fontname, bold, italic, embeddedfont) in enumerate(fontlist): # embeddedfont = None if no embedding needed
            fontnum = formattedfontnum[n]
            # Collect fontface info: need one for each font family + feature combination
            # Put embedded font in list only under fontname with empty featstring
            if (fontname, featstring) not in fontfaces:
                fontfaces[ (fontname, featstring) ] = []
            if embeddedfont:
                if (fontname, "") not in fontfaces:
                    fontfaces[ (fontname, "") ] = []
                if embeddedfont not in fontfaces[ (fontname, "") ]:
                    fontfaces[ (fontname, "") ].append(embeddedfont)
            # Generate paragraph styles
            for s in suffixlist:
                pstyle = Style(name=p+fontnum+s, family="paragraph")
                if s == "R":
                    pstyle.addElement(ParagraphProperties(textalign="end", justifysingleword="false", writingmode="rl-tb"))
                pstyledic = {}
                pstyledic['fontnamecomplex'] = \
                pstyledic['fontnameasian'] =\
                pstyledic['fontname'] = fontname + featstring
                pstyledic['fontsizecomplex'] = \
                pstyledic['fontsizeasian'] = \
                pstyledic['fontsize'] = str(pointsize) + "pt"
                if bold:
                    pstyledic['fontweightcomplex'] = \
                    pstyledic['fontweightasian'] = \
                    pstyledic['fontweight'] = 'bold'
                if italic:
                    pstyledic['fontstylecomplex'] = \
                    pstyledic['fontstyleasian'] = \
                    pstyledic['fontstyle'] = 'italic'
                if langname != None:
                    pstyledic['languagecomplex'] = \
                    pstyledic['languageasian'] = \
                    pstyledic['language'] = langname
                if countryname != None:
                    pstyledic['countrycomplex'] = \
                    pstyledic['countryasian'] = \
                    pstyledic['country'] = countryname
                pstyle.addElement(TextProperties(attributes=pstyledic))
#                LOdoc.styles.addElement(pstyle)    ### tried this, but when saving the generated odt, LO changed them to automatic styles
                LOdoc.automaticstyles.addElement(pstyle)

    fontstoembed = []
    for fontname, featstring in sorted(fontfaces):  ### Or find a way to keep order of <style> elements from original FTML?
        ff = FontFace(name=fontname + featstring, fontfamily=fontname + featstring, fontpitch="variable")
        LOdoc.fontfacedecls.addElement(ff)
        if fontfaces[ (fontname, featstring) ]:     # embedding needed for this combination
            for fontfile in fontfaces[ (fontname, featstring) ]:
                fontstoembed.append(fontfile)       # make list for embedding
                ffsrc = FontFaceSrc()
                ffuri = FontFaceUri( **{'href': "Fonts/" + os.path.basename(fontfile), 'type': "simple"} )
                ffformat = FontFaceFormat( **{'string': 'truetype'} )
                ff.addElement(ffsrc)
                ffsrc.addElement(ffuri)
                ffuri.addElement(ffformat)

    basename = "Table1.B"
    colorcount = 0
    colordic = {} # record color #rrggbb as key and "Table1.Bx" as stylename (where x is current color count)
    tablenum = 0

    # get title and comment and use as title and subtitle
    titleel = root.find("./head/title")
    if titleel != None:
        LOdoc.text.addElement(H(outlinelevel=1, stylename="Title", text=titleel.text))
    commentel = root.find("./head/comment")
    if commentel != None:
        LOdoc.text.addElement(P(stylename="Subtitle", text=commentel.text))

    # Each testgroup element begins a new table
    for tg in root.findall("./testgroup"):
        # insert label attribute of testgroup element as subtitle
        tglabel = tg.get('label')
        if tglabel != None:
            LOdoc.text.addElement(H(outlinelevel=1, stylename="Subtitle", text=tglabel))

        # insert text from comment subelement of testgroup element
        tgcommentel = tg.find("./comment")
        if tgcommentel != None:
            #print("commentel found")
            LOdoc.text.addElement(P(text=tgcommentel.text))

        tgbg = tg.get('background') # background attribute of testgroup element
        tablenum += 1
        table = Table(name="Table" + str(tablenum), stylename="Table1")
        table.addElement(TableColumn(stylename="Table1.A"))
        for n in range(numfonts):
            table.addElement(TableColumn(stylename="Table1.B"))
        table.addElement(TableColumn(stylename="Table1.A"))
        table.addElement(TableColumn(stylename="Table1.D"))
        for t in tg.findall("./test"):                # Each test element begins a new row
            # stuff to start the row
            labeltext = t.get('label')
            stylename = t.get('stylename')
            stringel = t.find('./string')
            commentel = t.find('./comment')
            rtlsuffix = "R" if t.get('rtl') == 'True' else ""
            comment = commentel.text if commentel != None else None
            colBstyle = "Table1.A1"
            tbg = t.get('background')   # get background attribute of test group (if one exists)
            if tbg == None: tbg = tgbg
            if tbg != None:             # if background attribute for test element (or background attribute for testgroup element)
                if tbg not in colordic: # if color not found in color dic, create new style
                    colorcount += 1
                    newname = basename + str(colorcount)
                    colordic[tbg] = newname
                    tb1style = Style(name=newname, family="table-cell")
                    tb1style.addElement(TableCellProperties(attributes={'padding':"0.0382in", 'border':"0.05pt solid #000000", 'backgroundcolor':tbg}))
                    LOdoc.automaticstyles.addElement(tb1style)
                colBstyle = colordic[tbg]

            row = TableRow()
            table.addElement(row)
            # fill cells
            # column A (label)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if labeltext:
                cell.addElement(P(stylename="Table_20_Contents", text = labeltext))
            row.addElement(cell)

            # column B (string)
            for n in range(numfonts):
                Pnum = ftmlstyles[stylename] if stylename != None else "P2"
                Pnum = Pnum + formattedfontnum[n] + rtlsuffix
                ### not clear if any of the following can be moved outside loop and reused
                cell = TableCell(stylename=colBstyle, valuetype="string")
                par = P(stylename=Pnum)
                if len(stringel) == 0: # no <em> subelements
                    par.addText(re.sub(backu, hextounichr, stringel.text))
                else:   # handle <em> subelement(s)
                    if stringel.text != None:
                        par.addElement(Span(stylename="T1", text = re.sub(backu, hextounichr, stringel.text)))
                    for e in stringel.findall("em"):
                        if e.text != None:
                            par.addText(re.sub(backu, hextounichr, e.text))
                        if e.tail != None:
                            par.addElement(Span(stylename="T1", text = re.sub(backu, hextounichr, e.tail)))
                cell.addElement(par)
                row.addElement(cell)

            # column C (comment)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if comment:
                cell.addElement(P(stylename="Table_20_Contents", text = comment))
            row.addElement(cell)

            # column D (stylename)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if comment:
                cell.addElement(P(stylename="Table_20_Contents", text = stylename))
            row.addElement(cell)
        LOdoc.text.addElement(table)

    LOdoc.text.addElement(P(stylename="Subtitle", text="")) # Empty paragraph to end ### necessary?

    try:
        if fontstoembed: logfile.log("Embedding fonts in document", "V")
        for f in fontstoembed:
            LOdoc._extra.append(
                OpaqueObject(filename = "Fonts/" + os.path.basename(f),
                    mediatype = "application/x-font-ttf",      ### should be "application/font-woff" or "/font-woff2" for WOFF fonts, "/font-opentype" for ttf
                    content = io.open(f, "rb").read() ))
        ci = ConfigItem(**{'name':'EmbedFonts', 'type': 'boolean'}) ### (name = 'EmbedFonts', type = 'boolean')
        ci.addText('true')
        cis=ConfigItemSet(**{'name':'ooo:configuration-settings'})  ### (name = 'ooo:configuration-settings')
        cis.addElement(ci)
        LOdoc.settings.addElement(cis)
    except:
        logfile.log("Error embedding fonts in document", "E")
    logfile.log("Writing output file: " + args.output, "P")
    LOdoc.save(unicode(args.output))
    return