839 lines
24 KiB
Python
839 lines
24 KiB
Python
# ~ FILTER_PDF = '/org.openoffice.Office.Common/Filter/PDF/Export/'
|
|
|
|
# ~ If location="document" Then
|
|
# ~ sp = ThisComponent.getScriptProvider()
|
|
|
|
|
|
class LOWriter(LODocument):
|
|
|
|
def create_chart(self, tipo, cursor=None):
|
|
cursor = cursor or self.selection.cursor.getEnd()
|
|
chart = LOChart(None, tipo)
|
|
chart.cursor = cursor
|
|
chart.doc = self
|
|
return chart
|
|
|
|
# ~ f = doc.createInstance('com.sun.star.text.TextFrame')
|
|
# ~ f.setSize(Size(10000, 500))
|
|
|
|
|
|
class LOBase(object):
|
|
TYPES = {
|
|
str: 'setString',
|
|
int: 'setInt',
|
|
float: 'setFloat',
|
|
bool: 'setBoolean',
|
|
Date: 'setDate',
|
|
Time: 'setTime',
|
|
DateTime: 'setTimestamp',
|
|
}
|
|
# ~ setArray
|
|
# ~ setBinaryStream
|
|
# ~ setBlob
|
|
# ~ setByte
|
|
# ~ setBytes
|
|
# ~ setCharacterStream
|
|
# ~ setClob
|
|
# ~ setNull
|
|
# ~ setObject
|
|
# ~ setObjectNull
|
|
# ~ setObjectWithInfo
|
|
# ~ setPropertyValue
|
|
# ~ setRef
|
|
def __init__(self, name, path='', **kwargs):
|
|
self._name = name
|
|
self._path = path
|
|
self._dbc = create_instance('com.sun.star.sdb.DatabaseContext')
|
|
if path:
|
|
path_url = _path_url(path)
|
|
db = self._dbc.createInstance()
|
|
db.URL = 'sdbc:embedded:firebird'
|
|
db.DatabaseDocument.storeAsURL(path_url, ())
|
|
if not self.exists:
|
|
self._dbc.registerDatabaseLocation(name, path_url)
|
|
else:
|
|
if name.startswith('odbc:'):
|
|
self._con = self._odbc(name, kwargs)
|
|
else:
|
|
db = self._dbc.getByName(name)
|
|
self.path = _path_system(self._dbc.getDatabaseLocation(name))
|
|
self._con = db.getConnection('', '')
|
|
|
|
if self._con is None:
|
|
msg = 'Not connected to: {}'.format(name)
|
|
else:
|
|
msg = 'Connected to: {}'.format(name)
|
|
debug(msg)
|
|
|
|
def _odbc(self, name, kwargs):
|
|
dm = create_instance('com.sun.star.sdbc.DriverManager')
|
|
args = dict_to_property(kwargs)
|
|
try:
|
|
con = dm.getConnectionWithInfo('sdbc:{}'.format(name), args)
|
|
return con
|
|
except Exception as e:
|
|
error(str(e))
|
|
return None
|
|
|
|
@property
|
|
def obj(self):
|
|
return self._obj
|
|
|
|
@property
|
|
def name(self):
|
|
return self._name
|
|
|
|
@property
|
|
def connection(self):
|
|
return self._con
|
|
|
|
@property
|
|
def path(self):
|
|
return self._path
|
|
@path.setter
|
|
def path(self, value):
|
|
self._path = value
|
|
|
|
@property
|
|
def exists(self):
|
|
return self._dbc.hasRegisteredDatabase(self.name)
|
|
|
|
@classmethod
|
|
def register(self, path, name):
|
|
if not self._dbc.hasRegisteredDatabase(name):
|
|
self._dbc.registerDatabaseLocation(name, _path_url(path))
|
|
return
|
|
|
|
def revoke(self, name):
|
|
self._dbc.revokeDatabaseLocation(name)
|
|
return True
|
|
|
|
def save(self):
|
|
# ~ self._db.connection.commit()
|
|
# ~ self._db.connection.getTables().refresh()
|
|
# ~ oDisp.executeDispatch(oFrame,".uno:DBRefreshTables", "", 0, Array())
|
|
self._obj.DatabaseDocument.store()
|
|
self.refresh()
|
|
return
|
|
|
|
def close(self):
|
|
self._con.close()
|
|
return
|
|
|
|
def refresh(self):
|
|
self._con.getTables().refresh()
|
|
return
|
|
|
|
def get_tables(self):
|
|
tables = self._con.getTables()
|
|
tables = [tables.getByIndex(i) for i in range(tables.Count)]
|
|
return tables
|
|
|
|
def cursor(self, sql, params):
|
|
cursor = self._con.prepareStatement(sql)
|
|
for i, v in enumerate(params, 1):
|
|
if not type(v) in self.TYPES:
|
|
error('Type not support')
|
|
debug((i, type(v), v, self.TYPES[type(v)]))
|
|
getattr(cursor, self.TYPES[type(v)])(i, v)
|
|
return cursor
|
|
|
|
def execute(self, sql, params):
|
|
debug(sql)
|
|
if params:
|
|
cursor = self.cursor(sql, params)
|
|
cursor.execute()
|
|
else:
|
|
cursor = self._con.createStatement()
|
|
cursor.execute(sql)
|
|
# ~ resulset = cursor.executeQuery(sql)
|
|
# ~ rows = cursor.executeUpdate(sql)
|
|
self.save()
|
|
return cursor
|
|
|
|
class EventsModify(EventsListenerBase, XModifyListener):
|
|
|
|
def __init__(self, controller):
|
|
super().__init__(controller)
|
|
|
|
def modified(self, event):
|
|
event_name = '{}_modified'.format(event.Source.Name)
|
|
if hasattr(self._controller, event_name):
|
|
getattr(self._controller, event_name)(event)
|
|
return
|
|
|
|
|
|
class EventsKeyWindow(EventsListenerBase, XKeyListener):
|
|
"""
|
|
event.KeyChar
|
|
event.KeyCode
|
|
event.KeyFunc
|
|
event.Modifiers
|
|
"""
|
|
|
|
def __init__(self, cls):
|
|
super().__init__(cls.events, cls.name)
|
|
self._cls = cls
|
|
|
|
def keyPressed(self, event):
|
|
pass
|
|
|
|
def keyReleased(self, event):
|
|
event_name = '{}_key_released'.format(self._cls.name)
|
|
if hasattr(self._controller, event_name):
|
|
getattr(self._controller, event_name)(event)
|
|
else:
|
|
if event.KeyFunc == QUIT and hasattr(self._cls, 'close'):
|
|
self._cls.close()
|
|
return
|
|
|
|
|
|
class EventsWindow(EventsListenerBase, XTopWindowListener, XWindowListener):
|
|
|
|
def __init__(self, cls):
|
|
self._cls = cls
|
|
super().__init__(cls.events, cls.name, cls._window)
|
|
|
|
def windowOpened(self, event):
|
|
event_name = '{}_opened'.format(self._name)
|
|
if hasattr(self._controller, event_name):
|
|
getattr(self._controller, event_name)(event)
|
|
return
|
|
|
|
def windowActivated(self, event):
|
|
control_name = '{}_activated'.format(event.Source.Model.Name)
|
|
if hasattr(self._controller, control_name):
|
|
getattr(self._controller, control_name)(event)
|
|
return
|
|
|
|
def windowDeactivated(self, event):
|
|
control_name = '{}_deactivated'.format(event.Source.Model.Name)
|
|
if hasattr(self._controller, control_name):
|
|
getattr(self._controller, control_name)(event)
|
|
return
|
|
|
|
def windowMinimized(self, event):
|
|
pass
|
|
|
|
def windowNormalized(self, event):
|
|
pass
|
|
|
|
def windowClosing(self, event):
|
|
if self._window:
|
|
control_name = 'window_closing'
|
|
else:
|
|
control_name = '{}_closing'.format(event.Source.Model.Name)
|
|
|
|
if hasattr(self._controller, control_name):
|
|
getattr(self._controller, control_name)(event)
|
|
# ~ else:
|
|
# ~ if not self._modal and not self._block:
|
|
# ~ event.Source.Visible = False
|
|
return
|
|
|
|
def windowClosed(self, event):
|
|
control_name = '{}_closed'.format(event.Source.Model.Name)
|
|
if hasattr(self._controller, control_name):
|
|
getattr(self._controller, control_name)(event)
|
|
return
|
|
|
|
# ~ XWindowListener
|
|
def windowResized(self, event):
|
|
sb = self._cls._subcont
|
|
sb.setPosSize(0, 0, event.Width, event.Height, SIZE)
|
|
event_name = '{}_resized'.format(self._name)
|
|
if hasattr(self._controller, event_name):
|
|
getattr(self._controller, event_name)(event)
|
|
return
|
|
|
|
def windowMoved(self, event):
|
|
pass
|
|
|
|
def windowShown(self, event):
|
|
pass
|
|
|
|
def windowHidden(self, event):
|
|
pass
|
|
|
|
|
|
class WriterTableRange(ObjectBase):
|
|
|
|
def __init__(self, obj, index, table_name):
|
|
self._index = index
|
|
self._table_name = table_name
|
|
super().__init__(obj)
|
|
self._is_cell = hasattr(self.obj, 'CellName')
|
|
|
|
def __getitem__(self, key):
|
|
obj = super().__getitem__(key)
|
|
return WriterTableRange(obj, key, self._table_name)
|
|
|
|
@property
|
|
def value(self):
|
|
return self.obj.String
|
|
@value.setter
|
|
def value(self, value):
|
|
self.obj.String = value
|
|
|
|
@property
|
|
def data(self):
|
|
return self.obj.getDataArray()
|
|
@data.setter
|
|
def data(self, values):
|
|
if isinstance(values, list):
|
|
values = tuple(values)
|
|
self.obj.setDataArray(values)
|
|
|
|
@property
|
|
def rows(self):
|
|
return len(self.data)
|
|
|
|
@property
|
|
def columns(self):
|
|
return len(self.data[0])
|
|
|
|
@property
|
|
def name(self):
|
|
if self._is_cell:
|
|
name = '{}.{}'.format(self._table_name, self.obj.CellName)
|
|
elif isinstance(self._index, str):
|
|
name = '{}.{}'.format(self._table_name, self._index)
|
|
else:
|
|
c1 = self.obj[0,0].CellName
|
|
c2 = self.obj[self.rows-1,self.columns-1].CellName
|
|
name = '{}.{}:{}'.format(self._table_name, c1, c2)
|
|
return name
|
|
|
|
def get_cell(self, *index):
|
|
return self[index]
|
|
|
|
def get_column(self, index=0, start=1):
|
|
return self[start:self.rows,index:index+1]
|
|
|
|
def get_series(self):
|
|
class Serie():
|
|
pass
|
|
series = []
|
|
for i in range(self.columns):
|
|
serie = Serie()
|
|
serie.label = self.get_cell(0,i).name
|
|
serie.data = self.get_column(i).data
|
|
serie.values = self.get_column(i).name
|
|
series.append(serie)
|
|
return series
|
|
|
|
|
|
class ChartFormat(object):
|
|
|
|
def __call__(self, obj):
|
|
for k, v in self.__dict__.items():
|
|
if hasattr(obj, k):
|
|
setattr(obj, k, v)
|
|
|
|
|
|
class LOChart(object):
|
|
BASE = 'com.sun.star.chart.{}Diagram'
|
|
|
|
def __init__(self, obj, tipo=''):
|
|
self._obj = obj
|
|
self._type = tipo
|
|
self._name = ''
|
|
self._table = None
|
|
self._data = ()
|
|
self._data_series = ()
|
|
self._cell = None
|
|
self._cursor = None
|
|
self._doc = None
|
|
self._title = ChartFormat()
|
|
self._subtitle = ChartFormat()
|
|
self._legend = ChartFormat()
|
|
self._xaxistitle = ChartFormat()
|
|
self._yaxistitle = ChartFormat()
|
|
self._xaxis = ChartFormat()
|
|
self._yaxis = ChartFormat()
|
|
self._xmaingrid = ChartFormat()
|
|
self._ymaingrid = ChartFormat()
|
|
self._xhelpgrid = ChartFormat()
|
|
self._yhelpgrid = ChartFormat()
|
|
self._area = ChartFormat()
|
|
self._wall = ChartFormat()
|
|
self._dim3d = False
|
|
self._series = ()
|
|
self._labels = ()
|
|
return
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_value, traceback):
|
|
self.insert()
|
|
|
|
@property
|
|
def obj(self):
|
|
return self._obj
|
|
@obj.setter
|
|
def obj(self, value):
|
|
self._obj = value
|
|
|
|
@property
|
|
def name(self):
|
|
return self._name
|
|
@name.setter
|
|
def name(self, value):
|
|
self._name = value
|
|
|
|
@property
|
|
def type(self):
|
|
return self._type
|
|
@type.setter
|
|
def type(self, value):
|
|
self._type = value
|
|
|
|
@property
|
|
def table(self):
|
|
return self._table
|
|
@table.setter
|
|
def table(self, value):
|
|
self._table = value
|
|
|
|
@property
|
|
def data(self):
|
|
return self._data
|
|
@data.setter
|
|
def data(self, value):
|
|
self._data = value
|
|
|
|
@property
|
|
def cell(self):
|
|
return self._cell
|
|
@cell.setter
|
|
def cell(self, value):
|
|
self._cell = value
|
|
self.doc = value.doc
|
|
|
|
@property
|
|
def cursor(self):
|
|
return self._cursor
|
|
@cursor.setter
|
|
def cursor(self, value):
|
|
self._cursor = value
|
|
|
|
@property
|
|
def doc(self):
|
|
return self._doc
|
|
@doc.setter
|
|
def doc(self, value):
|
|
self._doc = value
|
|
|
|
@property
|
|
def width(self):
|
|
return self._width
|
|
@width.setter
|
|
def width(self, value):
|
|
self._width = value
|
|
|
|
@property
|
|
def height(self):
|
|
return self._height
|
|
@height.setter
|
|
def height(self, value):
|
|
self._height = value
|
|
|
|
@property
|
|
def title(self):
|
|
return self._title
|
|
|
|
@property
|
|
def subtitle(self):
|
|
return self._subtitle
|
|
|
|
@property
|
|
def legend(self):
|
|
return self._legend
|
|
|
|
@property
|
|
def xaxistitle(self):
|
|
return self._xaxistitle
|
|
|
|
@property
|
|
def yaxistitle(self):
|
|
return self._yaxistitle
|
|
|
|
@property
|
|
def xaxis(self):
|
|
return self._xaxis
|
|
|
|
@property
|
|
def yaxis(self):
|
|
return self._yaxis
|
|
|
|
@property
|
|
def xmaingrid(self):
|
|
return self._xmaingrid
|
|
|
|
@property
|
|
def ymaingrid(self):
|
|
return self._ymaingrid
|
|
|
|
@property
|
|
def xhelpgrid(self):
|
|
return self._xhelpgrid
|
|
|
|
@property
|
|
def yhelpgrid(self):
|
|
return self._yhelpgrid
|
|
|
|
@property
|
|
def area(self):
|
|
return self._area
|
|
|
|
@property
|
|
def wall(self):
|
|
return self._wall
|
|
|
|
@property
|
|
def dim3d(self):
|
|
return self._dim3d
|
|
@dim3d.setter
|
|
def dim3d(self, value):
|
|
self._dim3d = value
|
|
|
|
@property
|
|
def series(self):
|
|
return self._series
|
|
@series.setter
|
|
def series(self, value):
|
|
self._series = value
|
|
|
|
@property
|
|
def data_series(self):
|
|
return self._series
|
|
@data_series.setter
|
|
def data_series(self, value):
|
|
self._data_series = value
|
|
|
|
@property
|
|
def labels(self):
|
|
return self._labels
|
|
@labels.setter
|
|
def labels(self, value):
|
|
self._labels = value
|
|
|
|
def _add_series_writer(self, chart):
|
|
dp = self.doc.create_instance('com.sun.star.chart2.data.DataProvider')
|
|
chart.attachDataProvider(dp)
|
|
chart_type = chart.getFirstDiagram().getCoordinateSystems()[0].getChartTypes()[0]
|
|
self._data_series = self.table[self.data].get_series()
|
|
series = [self._create_serie(dp, s) for s in self._data_series[1:]]
|
|
chart_type.setDataSeries(tuple(series))
|
|
chart_data = chart.getData()
|
|
chart_data.ComplexRowDescriptions = self._data_series[0].data
|
|
return
|
|
|
|
def _get_series(self):
|
|
rango = self._data_series
|
|
class Serie():
|
|
pass
|
|
series = []
|
|
for i in range(0, rango.columns, 2):
|
|
serie = Serie()
|
|
serie.label = rango[0, i+1].name
|
|
serie.xvalues = rango.get_column(i).name
|
|
serie.values = rango.get_column(i+1).name
|
|
series.append(serie)
|
|
return series
|
|
|
|
def _add_series_calc(self, chart):
|
|
dp = self.doc.create_instance('com.sun.star.chart2.data.DataProvider')
|
|
chart.attachDataProvider(dp)
|
|
chart_type = chart.getFirstDiagram().getCoordinateSystems()[0].getChartTypes()[0]
|
|
series = self._get_series()
|
|
series = [self._create_serie(dp, s) for s in series]
|
|
chart_type.setDataSeries(tuple(series))
|
|
return
|
|
|
|
def _create_serie(self, dp, data):
|
|
serie = create_instance('com.sun.star.chart2.DataSeries')
|
|
rango = data.values
|
|
is_x = hasattr(data, 'xvalues')
|
|
if is_x:
|
|
xrango = data.xvalues
|
|
rango_label = data.label
|
|
|
|
lds = create_instance('com.sun.star.chart2.data.LabeledDataSequence')
|
|
values = self._create_data(dp, rango, 'values-y')
|
|
lds.setValues(values)
|
|
if data.label:
|
|
label = self._create_data(dp, rango_label, '')
|
|
lds.setLabel(label)
|
|
|
|
xlds = ()
|
|
if is_x:
|
|
xlds = create_instance('com.sun.star.chart2.data.LabeledDataSequence')
|
|
values = self._create_data(dp, xrango, 'values-x')
|
|
xlds.setValues(values)
|
|
|
|
if is_x:
|
|
serie.setData((lds, xlds))
|
|
else:
|
|
serie.setData((lds,))
|
|
|
|
return serie
|
|
|
|
def _create_data(self, dp, rango, role):
|
|
data = dp.createDataSequenceByRangeRepresentation(rango)
|
|
if not data is None:
|
|
data.Role = role
|
|
return data
|
|
|
|
def _from_calc(self):
|
|
ps = self.cell.ps
|
|
ps.Width = self.width
|
|
ps.Height = self.height
|
|
charts = self.cell.charts
|
|
data = ()
|
|
if self.data:
|
|
data = (self.data.address,)
|
|
charts.addNewByName(self.name, ps, data, True, True)
|
|
self.obj = charts.getByName(self.name)
|
|
chart = self.obj.getEmbeddedObject()
|
|
chart.setDiagram(chart.createInstance(self.BASE.format(self.type)))
|
|
if not self.data:
|
|
self._add_series_calc(chart)
|
|
return chart
|
|
|
|
def _from_writer(self):
|
|
obj = self.doc.create_instance('com.sun.star.text.TextEmbeddedObject')
|
|
obj.setPropertyValue('CLSID', '12DCAE26-281F-416F-a234-c3086127382e')
|
|
obj.Name = self.name
|
|
obj.setSize(Size(self.width, self.height))
|
|
self.doc.insert_content(self.cursor, obj)
|
|
self.obj = obj
|
|
chart = obj.getEmbeddedObject()
|
|
tipo = self.type
|
|
if self.type == 'Column':
|
|
tipo = 'Bar'
|
|
chart.Diagram.Vertical = True
|
|
chart.setDiagram(chart.createInstance(self.BASE.format(tipo)))
|
|
chart.DataSourceLabelsInFirstColumn = True
|
|
if isinstance(self.data, str):
|
|
self._add_series_writer(chart)
|
|
else:
|
|
chart_data = chart.getData()
|
|
labels = [r[0] for r in self.data]
|
|
data = [(r[1],) for r in self.data]
|
|
chart_data.setData(data)
|
|
chart_data.RowDescriptions = labels
|
|
|
|
# ~ Bug
|
|
if tipo == 'Pie':
|
|
chart.setDiagram(chart.createInstance(self.BASE.format('Bar')))
|
|
chart.setDiagram(chart.createInstance(self.BASE.format('Pie')))
|
|
|
|
return chart
|
|
|
|
def insert(self):
|
|
if not self.cell is None:
|
|
chart = self._from_calc()
|
|
elif not self.cursor is None:
|
|
chart = self._from_writer()
|
|
|
|
diagram = chart.Diagram
|
|
|
|
if self.type == 'Bar':
|
|
diagram.Vertical = True
|
|
|
|
if hasattr(self.title, 'String'):
|
|
chart.HasMainTitle = True
|
|
self.title(chart.Title)
|
|
|
|
if hasattr(self.subtitle, 'String'):
|
|
chart.HasSubTitle = True
|
|
self.subtitle(chart.SubTitle)
|
|
|
|
if self.legend.__dict__:
|
|
chart.HasLegend = True
|
|
self.legend(chart.Legend)
|
|
|
|
if self.xaxistitle.__dict__:
|
|
diagram.HasXAxisTitle = True
|
|
self.xaxistitle(diagram.XAxisTitle)
|
|
|
|
if self.yaxistitle.__dict__:
|
|
diagram.HasYAxisTitle = True
|
|
self.yaxistitle(diagram.YAxisTitle)
|
|
|
|
if self.dim3d:
|
|
diagram.Dim3D = True
|
|
|
|
if self.series:
|
|
data_series = chart.getFirstDiagram(
|
|
).getCoordinateSystems(
|
|
)[0].getChartTypes()[0].DataSeries
|
|
for i, serie in enumerate(data_series):
|
|
for k, v in self.series[i].items():
|
|
if hasattr(serie, k):
|
|
setattr(serie, k, v)
|
|
return self
|
|
|
|
|
|
class LODialog(object):
|
|
|
|
def _get_type_control(self, name):
|
|
types = {
|
|
'stardiv.Toolkit.UnoFixedTextControl': 'label',
|
|
'stardiv.Toolkit.UnoFixedHyperlinkControl': 'link',
|
|
'stardiv.Toolkit.UnoEditControl': 'text',
|
|
'stardiv.Toolkit.UnoButtonControl': 'button',
|
|
'stardiv.Toolkit.UnoListBoxControl': 'listbox',
|
|
'stardiv.Toolkit.UnoRoadmapControl': 'roadmap',
|
|
'stardiv.Toolkit.UnoMultiPageControl': 'pages',
|
|
}
|
|
return types[name]
|
|
|
|
def _init_controls(self):
|
|
for control in self.obj.getControls():
|
|
tipo = self._get_type_control(control.ImplementationName)
|
|
name = control.Model.Name
|
|
control = get_custom_class(tipo, control)
|
|
setattr(self, name, control)
|
|
return
|
|
|
|
|
|
class LOWindow(object):
|
|
EMPTY = b"""<?xml version="1.0" encoding="UTF-8"?>
|
|
<!DOCTYPE dlg:window PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "dialog.dtd">
|
|
<dlg:window xmlns:dlg="http://openoffice.org/2000/dialog" xmlns:script="http://openoffice.org/2000/script" dlg:id="empty" dlg:left="0" dlg:top="0" dlg:width="0" dlg:height="0" dlg:closeable="true" dlg:moveable="true" dlg:withtitlebar="false"/>"""
|
|
|
|
def __init__(self, **kwargs):
|
|
self._events = None
|
|
self._menu = None
|
|
self._container = None
|
|
self._id_extension = ''
|
|
self._obj = self._create(kwargs)
|
|
|
|
@property
|
|
def id_extension(self):
|
|
return self._id_extension
|
|
@id_extension.setter
|
|
def id_extension(self, value):
|
|
global ID_EXTENSION
|
|
ID_EXTENSION = value
|
|
self._id_extension = value
|
|
|
|
def _get_base_control(self, tipo):
|
|
services = {
|
|
'label': 'com.sun.star.awt.UnoControlFixedText',
|
|
'button': 'com.sun.star.awt.UnoControlButton',
|
|
'text': 'com.sun.star.awt.UnoControlEdit',
|
|
'listbox': 'com.sun.star.awt.UnoControlListBox',
|
|
'link': 'com.sun.star.awt.UnoControlFixedHyperlink',
|
|
'roadmap': 'com.sun.star.awt.UnoControlRoadmap',
|
|
'image': 'com.sun.star.awt.UnoControlImageControl',
|
|
'groupbox': 'com.sun.star.awt.UnoControlGroupBox',
|
|
'radio': 'com.sun.star.awt.UnoControlRadioButton',
|
|
'tree': 'com.sun.star.awt.tree.TreeControl',
|
|
'grid': 'com.sun.star.awt.grid.UnoControlGrid',
|
|
'tab': 'com.sun.star.awt.tab.UnoControlTabPage',
|
|
}
|
|
return services[tipo]
|
|
|
|
def _special_properties(self, tipo, properties):
|
|
columns = properties.pop('Columns', ())
|
|
if tipo == 'grid':
|
|
properties['ColumnModel'] = self._set_column_model(columns)
|
|
elif tipo == 'button' and 'ImageURL' in properties:
|
|
properties['ImageURL'] = _set_image_url(
|
|
properties['ImageURL'], self.id_extension)
|
|
elif tipo == 'roadmap':
|
|
if not 'Height' in properties:
|
|
properties['Height'] = self.height
|
|
if 'Title' in properties:
|
|
properties['Text'] = properties.pop('Title')
|
|
elif tipo == 'tab':
|
|
if not 'Width' in properties:
|
|
properties['Width'] = self.width - 20
|
|
if not 'Height' in properties:
|
|
properties['Height'] = self.height - 20
|
|
|
|
return properties
|
|
|
|
def add_control(self, properties):
|
|
tipo = properties.pop('Type').lower()
|
|
root = properties.pop('Root', '')
|
|
sheets = properties.pop('Sheets', ())
|
|
|
|
properties = self._special_properties(tipo, properties)
|
|
model = self._subcont.Model.createInstance(get_control_model(tipo))
|
|
set_properties(model, properties)
|
|
name = properties['Name']
|
|
self._subcont.Model.insertByName(name, model)
|
|
control = self._subcont.getControl(name)
|
|
add_listeners(self.events, control, name)
|
|
control = get_custom_class(tipo, control)
|
|
|
|
if tipo == 'tree' and root:
|
|
control.root = root
|
|
elif tipo == 'tab' and sheets:
|
|
control.sheets = sheets
|
|
control.events = self.events
|
|
|
|
setattr(self, name, control)
|
|
return
|
|
|
|
def _add_listeners(self, control=None):
|
|
if self.events is None:
|
|
return
|
|
controller = EventsWindow(self)
|
|
self._window.addTopWindowListener(controller)
|
|
self._window.addWindowListener(controller)
|
|
self._container.addKeyListener(EventsKeyWindow(self))
|
|
return
|
|
|
|
@property
|
|
def name(self):
|
|
return self._title.lower().replace(' ', '_')
|
|
|
|
@property
|
|
def width(self):
|
|
return self._container.Size.Width
|
|
|
|
@property
|
|
def height(self):
|
|
return self._container.Size.Height
|
|
|
|
|
|
# ~ Export ok
|
|
def merge_zip(target, zips):
|
|
try:
|
|
with zipfile.ZipFile(target, 'w', compression=zipfile.ZIP_DEFLATED) as t:
|
|
for path in zips:
|
|
with zipfile.ZipFile(path, compression=zipfile.ZIP_DEFLATED) as s:
|
|
for name in s.namelist():
|
|
t.writestr(name, s.open(name).read())
|
|
except Exception as e:
|
|
error(e)
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
# ~ Export ok
|
|
def format(template, data):
|
|
"""
|
|
https://pyformat.info/
|
|
"""
|
|
if isinstance(data, (str, int, float)):
|
|
return template.format(data)
|
|
|
|
if isinstance(data, (Time, Date, DateTime)):
|
|
return template.format(_to_date(data))
|
|
|
|
if isinstance(data, tuple) and isinstance(data[0], tuple):
|
|
data = {r[0]: _to_date(r[1]) for r in data}
|
|
return template.format(**data)
|
|
|
|
data = [_to_date(v) for v in data]
|
|
result = template.format(*data)
|
|
return result
|