def parse(self, node):
xfield = None
yfields = []
for node in node.childNodes:
if node.nodeType != node.ELEMENT_NODE:
continue
if node.tagName == 'x':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
xfield = node_attributes(child)
field = self.screen.group.fields[xfield['name']]
if not xfield.get('string'):
xfield['string'] = field.attrs['string']
elif node.tagName == 'y':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
yattrs = node_attributes(child)
if not yattrs.get('string') and yattrs['name'] != '#':
field = self.screen.group.fields[yattrs['name']]
yattrs['string'] = field.attrs['string']
yfields.append(yattrs)
Widget = self.get_widget(self.attributes.get('type', 'vbar'))
widget = Widget(self, xfield, yfields)
self.widgets['root'] = widget
event = gtk.EventBox()
event.add(widget)
event.connect('button-press-event', self.button_press)
return event
def parse(self, node, container=None):
if not container:
node_attrs = node_attributes(node)
container = Container(int(node_attrs.get('col', 4)))
mnemonics = {}
for node in node.childNodes:
if node.nodeType != node.ELEMENT_NODE:
continue
node_attrs = node_attributes(node)
for b_field in ('readonly', 'homogeneous'):
if b_field in node_attrs:
node_attrs[b_field] = bool(int(node_attrs[b_field]))
for i_field in ('yexpand', 'yfill', 'xexpand', 'xfill', 'colspan',
'position'):
if i_field in node_attrs:
node_attrs[i_field] = int(node_attrs[i_field])
parser = getattr(self, '_parse_%s' % node.tagName)
widget = parser(node, container, node_attrs)
if not widget:
continue
name = node_attrs.get('name')
if node.tagName == 'label' and name:
mnemonics[name] = widget
if node.tagName == 'field':
if name in mnemonics and widget.mnemonic_widget:
mnemonics.pop(name).set_mnemonic_widget(
widget.mnemonic_widget)
return container
def parse(self, node):
vbox = gtk.VBox()
if not Calendar_:
return vbox
fields = []
for node in node.childNodes:
if node.nodeType != node.ELEMENT_NODE:
continue
if node.tagName == "field":
fields.append(node_attributes(node))
goocalendar = Calendar_(attrs=self.attributes, screen=self.screen, fields=fields)
toolbar = Toolbar(goocalendar)
self.widgets["toolbar"] = toolbar
goocalendar.connect("view-changed", self.on_view_changed, toolbar)
goocalendar.connect("page-changed", self.on_page_changed, toolbar)
goocalendar.connect("event-pressed", self.on_event_pressed)
goocalendar.connect("event-activated", self.on_event_activated)
goocalendar.connect("event-released", self.on_event_released)
goocalendar.connect("day-pressed", self.on_day_pressed)
goocalendar.connect("day-activated", self.on_day_activated)
self.widgets["goocalendar"] = goocalendar
scrolledWindow = gtk.ScrolledWindow()
scrolledWindow.add_with_viewport(goocalendar)
vbox.pack_start(toolbar, False, False)
vbox.pack_start(scrolledWindow, True, True)
return vbox
def parse(self, node, container=None):
if not container:
node_attrs = node_attributes(node)
container = Container(int(node_attrs.get('col', 4)))
for node in node.childNodes:
if node.nodeType != node.ELEMENT_NODE:
continue
node_attrs = node_attributes(node)
for i_field in ('yexpand', 'yfill', 'xexpand', 'xfill', 'colspan',
'position'):
if i_field in node_attrs:
node_attrs[i_field] = int(node_attrs[i_field])
parser = getattr(self, '_parse_%s' % node.tagName)
parser(node, container, node_attrs)
return container
def _parse_form(self, node, attributes):
container_attributes = node_attributes(node)
container = Container.constructor(
int(container_attributes.get('col', 4)),
container_attributes.get('homogeneous', False))
self.view.viewport.add(container.container)
self.parse_child(node, container)
assert not self._containers
def search_active(self, active=True):
if active and not self.parent:
if not self.fields_view_tree:
try:
self.fields_view_tree = RPCExecute('model',
self.model_name,
'fields_view_get',
False,
'tree',
context=self.context)
except RPCException:
return
if not self.domain_parser:
fields = copy.deepcopy(self.fields_view_tree['fields'])
for name, props in fields.iteritems():
if props['type'] not in ('selection', 'reference'):
continue
if isinstance(props['selection'], (tuple, list)):
continue
props['selection'] = self.get_selection(props)
# Filter only fields in XML view
xml_dom = xml.dom.minidom.parseString(
self.fields_view_tree['arch'])
root_node, = xml_dom.childNodes
xml_fields = [
node_attributes(node).get('name')
for node in root_node.childNodes
if node.nodeName == 'field'
]
if hasattr(collections, 'OrderedDict'):
odict = collections.OrderedDict
else:
odict = dict
fields = odict((name, fields[name]) for name in xml_fields)
for name, string, type_ in (
('id', _('ID'), 'integer'),
('create_uid', _('Creation User'), 'many2one'),
('create_date', _('Creation Date'), 'datetime'),
('write_uid', _('Modification User'), 'many2one'),
('write_date', _('Modification Date'), 'datetime'),
):
if name not in fields:
fields[name] = {
'string': string.decode('utf-8'),
'name': name,
'type': type_,
}
if type_ == 'datetime':
fields[name]['format'] = '"%H:%M:%S"'
self.domain_parser = DomainParser(fields)
self.screen_container.set_screen(self)
self.screen_container.show_filter()
else:
self.screen_container.hide_filter()
def domain_parser(self):
view_id = self.current_view.view_id if self.current_view else None
if view_id in self._domain_parser:
return self._domain_parser[view_id]
if view_id not in self.fields_view_tree:
try:
self.fields_view_tree[view_id] = view_tree = RPCExecute(
'model', self.model_name, 'fields_view_get', False, 'tree',
context=self.context)
except RPCException:
view_tree = {
'fields': {},
}
else:
view_tree = self.fields_view_tree[view_id]
fields = copy.deepcopy(view_tree['fields'])
for name, props in fields.iteritems():
if props['type'] not in ('selection', 'reference'):
continue
if isinstance(props['selection'], (tuple, list)):
continue
props['selection'] = self.get_selection(props)
if 'arch' in view_tree:
# Filter only fields in XML view
xml_dom = xml.dom.minidom.parseString(view_tree['arch'])
root_node, = xml_dom.childNodes
xml_fields = [node_attributes(node).get('name')
for node in root_node.childNodes
if node.nodeName == 'field']
fields = collections.OrderedDict(
(name, fields[name]) for name in xml_fields)
# Add common fields
for name, string, type_ in (
('id', _('ID'), 'integer'),
('create_uid', _('Creation User'), 'many2one'),
('create_date', _('Creation Date'), 'datetime'),
('write_uid', _('Modification User'), 'many2one'),
('write_date', _('Modification Date'), 'datetime'),
):
if name not in fields:
fields[name] = {
'string': string.decode('utf-8'),
'name': name,
'type': type_,
}
if type_ == 'datetime':
fields[name]['format'] = '"%H:%M:%S"'
context = rpc.CONTEXT.copy()
context.update(self.context)
domain_parser = DomainParser(fields, context)
self._domain_parser[view_id] = domain_parser
return domain_parser
def __init__(self, view_id, screen, xml):
self.view_id = view_id
self.screen = screen
self.widgets = defaultdict(list_)
self.state_widgets = []
self.attributes = node_attributes(xml)
screen.set_on_write(self.attributes.get('on_write'))
if self.xml_parser:
self.xml_parser(
self, self.screen.exclude_field,
{k: f.attrs
for k, f in self.screen.group.fields.items()}).parse(xml)
def __init__(self, arch, context=None):
self.context = context
self.actions = []
xml_dom = xml.dom.minidom.parseString(arch)
for node in xml_dom.childNodes:
if node.nodeType == node.ELEMENT_NODE:
break
self.attributes = node_attributes(node)
self.widget = self.parse(node).container
self.widget.show_all()
self._active_changed(None)
def parse(self, model, root_node, fields):
attrs = common.node_attributes(root_node)
self.title = attrs.get('string', 'Unknown')
xfield = None
yfields = []
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
if node.localName == 'x':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
xfield = common.node_attributes(child)
if not xfield.get('string'):
xfield['string'] = fields[
xfield['name']].attrs['string']
break
elif node.localName == 'y':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
yattrs = common.node_attributes(child)
if not yattrs.get('string') and yattrs['name'] != '#':
yattrs['string'] = fields[
yattrs['name']].attrs['string']
yfields.append(yattrs)
widget = GRAPH_TYPE[attrs.get('type', 'vbar')](xfield, yfields, attrs,
model)
event = gtk.EventBox()
event.add(widget)
event.connect('button-press-event', button_press, widget)
return event, {'root': widget}, [], '', [], None
def __init__(self, arch, context=None):
self.context = context
self.widgets = []
self.actions = []
xml_dom = xml.dom.minidom.parseString(arch)
for node in xml_dom.childNodes:
if node.nodeType == node.ELEMENT_NODE:
break
self.attributes = node_attributes(node)
self.widget = self.parse(node).table
self.widget.show_all()
self._active_changed(None)
def parse(self, model, root_node, fields):
attrs = common.node_attributes(root_node)
self.title = attrs.get('string', 'Unknown')
xfield = None
yfields = []
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
if node.localName == 'x':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
xfield = common.node_attributes(child)
if not xfield.get('string'):
xfield['string'] = fields[xfield['name']
].attrs['string']
break
elif node.localName == 'y':
for child in node.childNodes:
if not child.nodeType == child.ELEMENT_NODE:
continue
yattrs = common.node_attributes(child)
if not yattrs.get('string') and yattrs['name'] != '#':
yattrs['string'] = fields[yattrs['name']
].attrs['string']
yfields.append(yattrs)
widget = GRAPH_TYPE[attrs.get('type', 'vbar')
](xfield, yfields, attrs, model)
event = gtk.EventBox()
event.add(widget)
event.connect('button-press-event', button_press, widget)
return event, {'root': widget}, [], '', [], None
def _parse_button(self, node):
node_attrs = node_attributes(node)
widget = Button(self, node_attrs)
self.state_widgets.append(widget)
column = gtk.TreeViewColumn(node_attrs.get('string', ''),
widget.renderer)
column._type = 'button'
column.name = None
column.set_cell_data_func(widget.renderer, widget.setter)
self.set_column_widget(column, None, node_attrs, arrow=False)
self.set_column_width(column, None, node_attrs)
column.set_visible(not node_attrs.get('tree_invisible', False))
self.treeview.append_column(column)
def search_active(self, active=True):
if active and not self.parent:
if not self.fields_view_tree:
try:
self.fields_view_tree = RPCExecute('model',
self.model_name, 'fields_view_get', False, 'tree',
context=self.context)
except RPCException:
return
if not self.domain_parser:
fields = copy.deepcopy(self.fields_view_tree['fields'])
for name, props in fields.iteritems():
if props['type'] not in ('selection', 'reference'):
continue
if isinstance(props['selection'], (tuple, list)):
continue
props['selection'] = self.get_selection(props)
# Filter only fields in XML view
xml_dom = xml.dom.minidom.parseString(
self.fields_view_tree['arch'])
root_node, = xml_dom.childNodes
xml_fields = [node_attributes(node).get('name')
for node in root_node.childNodes
if node.nodeName == 'field']
if hasattr(collections, 'OrderedDict'):
odict = collections.OrderedDict
else:
odict = dict
fields = odict((name, fields[name]) for name in xml_fields)
if 'id' not in fields:
fields['id'] = {
'string': _('ID'),
'name': 'id',
'type': 'integer',
}
self.domain_parser = DomainParser(fields)
self.screen_container.set_screen(self)
self.screen_container.show_filter()
else:
self.screen_container.hide_filter()
def current_domain(self):
first_datetime, last_datetime = \
self.current_domain_period.get_dates(True)
attrs = common.node_attributes(self.root_node)
dtstart = attrs.get('dtstart')
dtend = attrs.get('dtend') or dtstart
domain = [
'OR',
[
'AND', (dtstart, '>=', first_datetime),
(dtstart, '<', last_datetime)
],
[
'AND', (dtend, '>=', first_datetime),
(dtend, '<', last_datetime)
],
[
'AND', (dtstart, '<', first_datetime),
(dtend, '>', last_datetime)
]
]
return domain
def _node_attributes(self, node):
node_attrs = node_attributes(node)
if 'name' in node_attrs:
field = self.field_attrs.get(node_attrs['name'], {})
else:
field = {}
for name in ['readonly', 'homogeneous']:
if name in node_attrs:
node_attrs[name] = bool(int(node_attrs[name]))
for name in [
'yexpand', 'yfill', 'xexpand', 'xfill', 'colspan', 'position',
'height', 'width', 'expand'
]:
if name in node_attrs:
node_attrs[name] = int(node_attrs[name])
for name in ['xalign', 'yalign']:
if name in node_attrs:
node_attrs[name] = float(node_attrs[name])
if field:
node_attrs.setdefault('widget', field['type'])
if node.tagName == 'label' and 'string' not in node_attrs:
node_attrs['string'] = field['string'] + _(':')
if node.tagName == 'field' and 'help' not in node_attrs:
node_attrs['help'] = field['help']
for name in [
'relation', 'domain', 'selection', 'string', 'states',
'relation_field', 'views', 'invisible', 'add_remove',
'sort', 'context', 'size', 'filename', 'autocomplete',
'translate', 'create', 'delete', 'selection_change_with',
'schema_model', 'required', 'help_selection', 'help_field',
'order', 'symbol', 'monetary'
]:
if name in field:
node_attrs.setdefault(name, field[name])
return node_attrs
def parse(self, model_name, root_node, fields):
dict_widget = {}
state_widgets = []
attrs = node_attributes(root_node)
on_write = attrs.get('on_write', '')
editable = attrs.get('editable', False)
if editable:
treeview = EditableTreeView(editable)
else:
treeview = TreeView()
treeview.cells = {}
treeview.sequence = attrs.get('sequence', False)
treeview.colors = attrs.get('colors', '"black"')
treeview.keyword_open = attrs.get('keyword_open', False)
self.treeview = treeview
treeview.set_property('rules-hint', True)
if not self.title:
self.title = attrs.get('string', 'Unknown')
tooltips = common.Tooltips()
expandable = False
for node in root_node.childNodes:
node_attrs = node_attributes(node)
if node.localName == 'field':
fname = str(node_attrs['name'])
for boolean_fields in ('readonly', 'required', 'expand'):
if boolean_fields in node_attrs:
node_attrs[boolean_fields] = \
bool(int(node_attrs[boolean_fields]))
if fname not in fields:
continue
for attr_name in ('relation', 'domain', 'selection',
'relation_field', 'string', 'views', 'invisible',
'add_remove', 'sort', 'context', 'filename',
'selection_change_with'):
if attr_name in fields[fname].attrs and \
not attr_name in node_attrs:
node_attrs[attr_name] = fields[fname].attrs[attr_name]
cell_type = node_attrs.get('widget',
fields[fname].attrs['type'])
cell = CELLTYPES.get(cell_type)(fname, model_name,
treeview, node_attrs)
treeview.cells[fname] = cell
renderer = cell.renderer
readonly = not (editable and not node_attrs.get('readonly',
fields[fname].attrs.get('readonly', False)))
if isinstance(renderer, CellRendererToggle):
renderer.set_property('activatable', not readonly)
elif isinstance(renderer,
(gtk.CellRendererProgress, CellRendererButton)):
pass
else:
renderer.set_property('editable', not readonly)
if (not readonly
and not isinstance(renderer, CellRendererBinary)):
renderer.connect_after('editing-started', send_keys,
treeview)
col = gtk.TreeViewColumn(fields[fname].attrs['string'])
prefixes = []
suffixes = []
if cell_type in ('url', 'email', 'callto', 'sip'):
prefixes.append(Affix(fname, self.treeview, node_attrs,
protocol=cell_type))
if 'icon' in node_attrs:
prefixes.append(Affix(fname, self.treeview, node_attrs))
for affix in node.childNodes:
affix_attrs = node_attributes(affix)
if affix.localName == 'prefix':
list_ = prefixes
else:
list_ = suffixes
list_.append(Affix(fname, self.treeview, affix_attrs))
for prefix in prefixes:
col.pack_start(prefix.renderer, expand=False)
col.set_cell_data_func(prefix.renderer, prefix.setter)
col.pack_start(renderer, expand=True)
col.set_cell_data_func(renderer, cell.setter)
col.name = fname
for suffix in suffixes:
col.pack_start(suffix.renderer, expand=False)
col.set_cell_data_func(suffix.renderer, suffix.setter)
hbox = gtk.HBox(False, 2)
label = gtk.Label(fields[fname].attrs['string'])
label.show()
help = fields[fname].attrs['string']
if fields[fname].attrs.get('help'):
help += '\n' + fields[fname].attrs['help']
tooltips.set_tip(label, help)
tooltips.enable()
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
hbox.pack_start(label, True, True, 0)
hbox.pack_start(arrow, False, False, 0)
hbox.show()
col.set_widget(hbox)
col._type = fields[fname].attrs['type']
col.set_clickable(True)
twidth = {
'integer': 60,
'biginteger': 60,
'float': 80,
'numeric': 80,
'float_time': 100,
'date': 110,
'datetime': 160,
'selection': 90,
'char': 100,
'one2many': 50,
'many2many': 50,
'boolean': 20,
'binary': 200,
}
width = self.screen.tree_column_width[model_name].get(fname)
if not width:
if 'width' in node_attrs:
width = int(node_attrs['width'])
else:
width = twidth.get(fields[fname].attrs['type'], 100)
col.width = width
if width > 0:
col.set_fixed_width(width)
col.set_min_width(1)
expand = node_attrs.get('expand', False)
col.set_expand(expand)
expandable |= expand
if (not treeview.sequence
and not self.children_field
and fields[fname].attrs.get('sortable', True)):
col.connect('clicked', sort_model, treeview, self.screen)
col.set_resizable(True)
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
col.set_visible(not node_attrs.get('tree_invisible',
fields[fname].attrs.get('tree_invisible', False)))
if fname == self.screen.exclude_field:
col.set_visible(False)
i = treeview.append_column(col)
if 'sum' in node_attrs and fields[fname].attrs['type'] \
in ('integer', 'biginteger', 'float', 'numeric',
'float_time'):
label = gtk.Label(node_attrs['sum'] + _(': '))
label_sum = gtk.Label()
if isinstance(fields[fname].attrs.get('digits'),
basestring):
digits = 2
else:
digits = fields[fname].attrs.get('digits', (16, 2))[1]
dict_widget[i] = (fname, label, label_sum, digits)
elif node.localName == 'button':
#TODO add shortcut
cell = Button(treeview, self.screen, node_attrs)
state_widgets.append(cell)
renderer = cell.renderer
string = node_attrs.get('string', _('Unknown'))
col = gtk.TreeViewColumn(string, renderer)
col.name = None
label = gtk.Label(string)
label.show()
help = string
if node_attrs.get('help'):
help += '\n' + node_attrs['help']
tooltips.set_tip(label, help)
tooltips.enable()
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
col.set_widget(label)
col._type = 'button'
col.set_cell_data_func(renderer, cell.setter)
if 'width' in node_attrs:
width = int(node_attrs['width'])
else:
width = 80
col.width = width
if width > 0:
col.set_fixed_width(width)
col.set_resizable(True)
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
i = treeview.append_column(col)
if not expandable:
col = gtk.TreeViewColumn()
col.name = None
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
col._type = 'fill'
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
treeview.append_column(col)
treeview.set_fixed_height_mode(True)
return treeview, dict_widget, state_widgets, on_write, [], None
def _parse_field(self, node):
group = self.screen.group
node_attrs = node_attributes(node)
name = node_attrs['name']
field = group.fields[name]
for b_field in ('readonly', 'expand'):
if b_field in node_attrs:
node_attrs[b_field] = bool(int(node_attrs[b_field]))
for i_field in ('width', 'height'):
if i_field in node_attrs:
node_attrs[i_field] = int(node_attrs[i_field])
if 'widget' not in node_attrs:
node_attrs['widget'] = field.attrs['type']
for attr in ('relation', 'domain', 'selection',
'relation_field', 'string', 'views', 'invisible',
'add_remove', 'sort', 'context', 'size', 'filename',
'autocomplete', 'translate', 'create', 'delete',
'selection_change_with', 'schema_model'):
if (attr in field.attrs
and attr not in node_attrs):
node_attrs[attr] = field.attrs[attr]
Widget = self.get_widget(node_attrs['widget'])
widget = Widget(self, node_attrs)
self.widgets[name].append(widget)
column = gtk.TreeViewColumn(field.attrs['string'])
column._type = 'field'
column.name = name
prefixes = []
suffixes = []
if node_attrs['widget'] in ('url', 'email', 'callto', 'sip'):
prefixes.append(Affix(self, node_attrs,
protocol=node_attrs['widget']))
if 'icon' in node_attrs:
prefixes.append(Affix(self, node_attrs))
for affix in node.childNodes:
affix_attrs = node_attributes(affix)
if 'name' not in affix_attrs:
affix_attrs['name'] = name
if affix.tagName == 'prefix':
list_ = prefixes
else:
list_ = suffixes
list_.append(Affix(self, affix_attrs))
for prefix in prefixes:
column.pack_start(prefix.renderer, expand=False)
column.set_cell_data_func(prefix.renderer,
prefix.setter)
column.pack_start(widget.renderer, expand=True)
column.set_cell_data_func(widget.renderer, widget.setter)
for suffix in suffixes:
column.pack_start(suffix.renderer, expand=False)
column.set_cell_data_func(suffix.renderer,
suffix.setter)
self.set_column_widget(column, field, node_attrs)
self.set_column_width(column, field, node_attrs)
if (not self.attributes.get('sequence')
and not self.children_field
and field.attrs.get('sortable', True)):
column.connect('clicked', self.sort_model)
self.treeview.append_column(column)
self.add_sum(node_attrs)
def parse(self, model_name, root_node, fields, notebook=None, paned=None,
tooltips=None):
dict_widget = {}
button_list = []
notebook_list = []
attrs = common.node_attributes(root_node)
on_write = attrs.get('on_write', '')
if not tooltips:
tooltips = common.Tooltips()
container = _container(tooltips)
if CONFIG['client.modepda']:
container.new(col=1)
else:
container.new(col=int(attrs.get('col', 4)))
cursor_widget = attrs.get('cursor')
if not self.title:
self.title = attrs.get('string', 'Unknown')
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
attrs = common.node_attributes(node)
if not cursor_widget:
if attrs.get('name') and fields.get(attrs['name']) \
and attrs['name'] != self.screen.exclude_field:
cursor_widget = attrs.get('name')
yexpand = int(attrs.get('yexpand', 0))
yfill = int(attrs.get('yfill', 0))
xexpand = int(attrs.get('xexpand', 1))
xfill = int(attrs.get('xfill', 1))
colspan = int(attrs.get('colspan', 1))
if node.localName == 'image':
common.ICONFACTORY.register_icon(attrs['name'])
icon = Image(attrs)
button_list.append(icon)
icon.set_from_stock(attrs['name'], gtk.ICON_SIZE_DIALOG)
container.wid_add(icon,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'separator':
text = attrs.get('string', '')
if 'name' in attrs:
for attr_name in ('states', 'invisible'):
if attr_name not in attrs and attrs['name'] in fields:
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
if not text:
text = fields[attrs['name']].attrs['string']
vbox = VBox(attrs=attrs)
button_list.append(vbox)
if text:
label = gtk.Label(text)
label.set_use_markup(True)
label.set_alignment(float(attrs.get('xalign', 0.0)), 0.5)
vbox.pack_start(label)
vbox.pack_start(gtk.HSeparator())
container.wid_add(vbox,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'label':
text = attrs.get('string', '')
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('states', 'invisible'):
if attr_name not in attrs \
and attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
if not text:
if gtk.widget_get_default_direction() == \
gtk.TEXT_DIR_RTL:
text = _(':') + \
fields[attrs['name']].attrs['string']
else:
text = fields[attrs['name']].attrs['string'] + \
_(':')
if 'xalign' not in attrs:
attrs['xalign'] = 1.0
elif not text:
for node in node.childNodes:
if node.nodeType == node.TEXT_NODE:
text += node.data
else:
text += node.toxml()
if not text:
container.empty_add(int(attrs.get('colspan', 1)))
continue
label = Label(text, attrs)
button_list.append(label)
label.set_use_markup(True)
if CONFIG['client.modepda']:
attrs['xalign'] = 0.0
label.set_alignment(float(attrs.get('xalign', 1.0)),
float(attrs.get('yalign', 0.0)))
label.set_angle(int(attrs.get('angle', 0)))
xexpand = bool(attrs.get('xexpand', 0))
container.wid_add(label,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'newline':
container.newline()
elif node.localName == 'button':
button = Button(attrs)
button_list.append(button)
container.wid_add(button,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'notebook':
notebook = gtk.Notebook()
notebook.set_scrollable(True)
notebook_list.append(notebook)
if CONFIG['client.form_tab'] == 'top':
pos = gtk.POS_TOP
elif CONFIG['client.form_tab'] == 'left':
pos = gtk.POS_LEFT
elif CONFIG['client.form_tab'] == 'right':
pos = gtk.POS_RIGHT
elif CONFIG['client.form_tab'] == 'bottom':
pos = gtk.POS_BOTTOM
notebook.set_tab_pos(pos)
notebook.set_border_width(3)
colspan = int(attrs.get('colspan', 4))
yexpand = bool(attrs.get('yexpand', 1))
yfill = bool(attrs.get('yfill', 1))
container.wid_add(notebook,
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
widget, widgets, buttons, spam, notebook_list2, cursor_widget2\
= self.parse(model_name, node, fields, notebook,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
button_list += buttons
for widget_name, widgets in widgets.items():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
elif node.localName == 'page':
if CONFIG['client.form_tab'] == 'left':
angle = 90
tab_box = gtk.VBox(spacing=3)
image_pos, image_rotate = ('end',
gtk.gdk.PIXBUF_ROTATE_COUNTERCLOCKWISE)
elif CONFIG['client.form_tab'] == 'right':
angle = -90
tab_box = gtk.VBox(spacing=3)
image_pos, image_rotate = ('start',
gtk.gdk.PIXBUF_ROTATE_CLOCKWISE)
else:
angle = 0
tab_box = gtk.HBox(spacing=3)
image_pos, image_rotate = ('start',
gtk.gdk.PIXBUF_ROTATE_NONE)
text = attrs.get('string', '')
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
continue
for attr_name in ('states', 'invisible'):
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = \
fields[attrs['name']].attrs[attr_name]
if not text:
text = fields[attrs['name']].attrs['string']
if not text:
text = _('No String Attr.')
if '_' not in text:
text = '_' + text
tab_label = gtk.Label(text)
tab_label.set_angle(angle)
tab_label.set_use_underline(True)
tab_box.pack_start(tab_label)
if 'icon' in attrs:
common.ICONFACTORY.register_icon(attrs['icon'])
pixbuf = tab_box.render_icon(attrs['icon'],
gtk.ICON_SIZE_SMALL_TOOLBAR)
pixbuf = pixbuf.rotate_simple(image_rotate)
icon = gtk.Image()
icon.set_from_pixbuf(pixbuf)
if image_pos == 'end':
tab_box.pack_end(icon)
else:
tab_box.pack_start(icon)
tab_box.show_all()
widget, widgets, buttons, spam, notebook_list2, cursor_widget2\
= self.parse(model_name, node, fields, notebook,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
button_list += buttons
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(widget)
viewport.show()
scrolledwindow = ScrolledWindow(attrs=attrs)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scrolledwindow.add(viewport)
button_list.append(scrolledwindow)
notebook.append_page(scrolledwindow, tab_box)
elif node.localName == 'field':
name = str(attrs['name'])
if name == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
if name not in fields:
container.empty_add(int(attrs.get('colspan', 1)))
log = logging.getLogger('view')
log.error('Unknown field "%s"' % str(name))
continue
ftype = attrs.get('widget', fields[name].attrs['type'])
if not ftype in WIDGETS_TYPE:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('relation', 'domain', 'selection',
'relation_field', 'string', 'views', 'invisible',
'add_remove', 'sort', 'context', 'size', 'filename',
'autocomplete', 'translate'):
if attr_name in fields[name].attrs and \
not attr_name in attrs:
attrs[attr_name] = fields[name].attrs[attr_name]
widget_act = WIDGETS_TYPE[ftype][0](name, model_name, attrs)
self.widget_id += 1
widget_act.position = self.widget_id
dict_widget.setdefault(name, [])
dict_widget[name].append(widget_act)
yexpand = bool(attrs.get('yexpand', WIDGETS_TYPE[ftype][2]))
yfill = bool(attrs.get('yfill', WIDGETS_TYPE[ftype][3]))
hlp = fields[name].attrs.get('help', attrs.get('help', False))
if attrs.get('height', False) or attrs.get('width', False):
widget_act.widget.set_size_request(
int(attrs.get('width', -1)),
int(attrs.get('height', -1)))
container.wid_add(Alignment(widget_act.widget, attrs),
fields[name].attrs['string'], fname=name,
help_tip=hlp,
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'group':
widget, widgets, buttons, spam, notebook_list2, cursor_widget2\
= self.parse(model_name, node, fields, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
button_list += buttons
text = ''
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('states', 'invisible'):
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
text = fields[attrs['name']].attrs['string']
if attrs.get('string'):
text = attrs['string']
frame = Frame(text, attrs)
frame.add(widget)
button_list.append(frame)
container.wid_add(frame,
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=0,
xexpand=xexpand, xfill=xfill, xpadding=0)
elif node.localName == 'hpaned':
hpaned = gtk.HPaned()
container.wid_add(hpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
widget, widgets, buttons, spam, notebook_list2, cursor_widget2\
= self.parse(model_name, node, fields, paned=hpaned,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
button_list += buttons
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if 'position' in attrs:
hpaned.set_position(int(attrs['position']))
elif node.localName == 'vpaned':
vpaned = gtk.VPaned()
container.wid_add(vpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
widget, widgets, buttons, spam, notebook_list, cursor_widget2\
= self.parse(model_name, node, fields, paned=vpaned,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
button_list += buttons
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if 'position' in attrs:
vpaned.set_position(int(attrs['position']))
elif node.localName == 'child':
widget, widgets, buttons, spam, notebook_list2, cursor_widget2\
= self.parse(model_name, node, fields, paned=paned,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
button_list += buttons
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if not paned.get_child1():
paned.pack1(widget, resize=True, shrink=True)
elif not paned.get_child2():
paned.pack2(widget, resize=True, shrink=True)
return container.pop(), dict_widget, button_list, on_write, \
notebook_list, cursor_widget
def _parse_field(self, node, attributes):
name = attributes['name']
widget = self.WIDGETS[attributes['widget']](self.view, attributes)
self.view.widgets[name].append(widget)
column = Gtk.TreeViewColumn(attributes['string'])
column._type = 'field'
column.name = name
prefixes = []
suffixes = list(widget.suffixes)
if attributes['widget'] in ['url', 'email', 'callto', 'sip']:
prefixes.append(
Affix(self.view, attributes, protocol=attributes['widget']))
if 'icon' in attributes:
prefixes.append(Affix(self.view, attributes))
for affix in node.childNodes:
affix_attrs = node_attributes(affix)
if 'name' not in affix_attrs:
affix_attrs['name'] = attributes['name']
if affix.tagName == 'prefix':
list_ = prefixes
else:
list_ = suffixes
list_.append(Affix(self.view, affix_attrs))
prefixes.extend(widget.prefixes)
for prefix in prefixes:
column.pack_start(prefix.renderer, expand=prefix.expand)
column.set_cell_data_func(prefix.renderer, prefix.setter)
column.pack_start(widget.renderer, expand=True)
column.set_cell_data_func(widget.renderer, widget.setter)
for suffix in suffixes:
column.pack_start(suffix.renderer, expand=suffix.expand)
column.set_cell_data_func(suffix.renderer, suffix.setter)
self._set_column_widget(column, attributes, align=widget.align)
self._set_column_width(column, attributes)
if (not self.view.attributes.get('sequence')
and not self.view.children_field
and self.field_attrs[name].get('sortable', True)):
column.connect('clicked', self.view.sort_model)
self.view.treeview.append_column(column)
if 'sum' in attributes:
# Coog Specific : highlight_sum : cf #8374
highlight_sum_ = attributes.get('highlight_sum', '0')
text = attributes['sum'] + _(':')
label, sum_ = Gtk.Label(label=text), Gtk.Label()
hbox = Gtk.HBox()
hbox.pack_start(label, expand=True, fill=False, padding=2)
hbox.pack_start(sum_, expand=True, fill=False, padding=2)
hbox.show_all()
self.view.sum_box.pack_start(
hbox, expand=False, fill=False, padding=0)
self.view.sum_widgets.append(
(attributes['name'], sum_, highlight_sum_))
def __init__(self, screen, xml):
self.screen = screen
self.fields = {}
self.attributes = node_attributes(xml)
screen.set_on_write(self.attributes.get('on_write'))
def __init__(self, screen, xml):
self.screen = screen
self.fields = {}
self.attributes = node_attributes(xml)
screen.set_on_write(self.attributes.get('on_write'))
def parse(self, root_node, notebook=None, paned=None, tooltips=None):
widgets = []
attrs = common.node_attributes(root_node)
if not tooltips:
tooltips = common.Tooltips()
container = _container(tooltips)
container.new(col=int(attrs.get('col', 4)))
if not self.title:
self.title = attrs.get('string', 'Unknown')
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
attrs = common.node_attributes(node)
yexpand = int(attrs.get('yexpand', 0))
yfill = int(attrs.get('yfill', 0))
xexpand = int(attrs.get('xexpand', 1))
xfill = int(attrs.get('xfill', 1))
colspan = int(attrs.get('colspan', 1))
if node.localName == 'image':
common.ICONFACTORY.register_icon(attrs['name'])
icon = gtk.Image()
icon.set_from_stock(attrs['name'], gtk.ICON_SIZE_DIALOG)
container.wid_add(icon,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'separator':
text = attrs.get('string', '')
vbox = VBox(attrs=attrs)
if text:
label = gtk.Label(text)
label.set_use_markup(True)
label.set_alignment(float(attrs.get('align', 0.0)), 0.5)
vbox.pack_start(label)
vbox.pack_start(gtk.HSeparator())
container.wid_add(vbox,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'label':
text = attrs.get('string', '')
if not text:
container.empty_add(int(attrs.get('colspan', 1)))
continue
label = gtk.Label(text)
label.set_use_markup(True)
label.set_alignment(float(attrs.get('xalign', 1.0)),
float(attrs.get('yalign', 0.0)))
label.set_angle(int(attrs.get('angle', 0)))
xexpand = bool(attrs.get('xexpand', 0))
container.wid_add(label,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'newline':
container.newline()
elif node.localName == 'notebook':
notebook = gtk.Notebook()
if CONFIG['client.form_tab'] == 'top':
pos = gtk.POS_TOP
elif CONFIG['client.form_tab'] == 'left':
pos = gtk.POS_LEFT
elif CONFIG['client.form_tab'] == 'right':
pos = gtk.POS_RIGHT
elif CONFIG['client.form_tab'] == 'bottom':
pos = gtk.POS_BOTTOM
notebook.set_tab_pos(pos)
notebook.set_border_width(3)
container.wid_add(notebook,
colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
widget, new_widgets = self.parse(node, notebook,
tooltips=tooltips)
widgets += new_widgets
elif node.localName == 'page':
if CONFIG['client.form_tab'] == 'left':
angle = 90
elif CONFIG['client.form_tab'] == 'right':
angle = -90
else:
angle = 0
label = gtk.Label(attrs.get('string', _('No String Attr.')))
label.set_angle(angle)
widget, new_widgets = self.parse(node, notebook,
tooltips=tooltips)
widgets += new_widgets
notebook.append_page(widget, label)
elif node.localName == 'group':
widget, new_widgets = self.parse(node, tooltips=tooltips)
widgets += new_widgets
if attrs.get('string', None):
frame = gtk.Frame(attrs['string'])
frame.add(widget)
else:
frame = widget
container.wid_add(frame,
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=0,
xexpand=xexpand, xfill=xfill, xpadding=0)
elif node.localName == 'hpaned':
hpaned = gtk.HPaned()
container.wid_add(hpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
widget, new_widgets = self.parse(node, paned=hpaned,
tooltips=tooltips)
widgets += new_widgets
if 'position' in attrs:
hpaned.set_position(int(attrs['position']))
elif node.localName == 'vpaned':
vpaned = gtk.VPaned()
container.wid_add(vpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
widget, new_widgets = self.parse(node, paned=vpaned,
tooltips=tooltips)
widgets += new_widgets
if 'position' in attrs:
vpaned.set_position(int(attrs['position']))
elif node.localName == 'child':
widget, new_widgets = self.parse(node, paned=paned,
tooltips=tooltips)
widgets += new_widgets
if not paned.get_child1():
paned.pack1(widget, resize=True, shrink=True)
elif not paned.get_child2():
paned.pack2(widget, resize=True, shrink=True)
elif node.localName == 'action':
widget_act = Action(attrs, self.context)
widgets.append(widget_act)
yexpand = bool(attrs.get('yexpand', 1))
yfill = bool(attrs.get('yfill', 1))
container.wid_add(widget_act.widget,
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
return container.pop(), widgets
def parse(self, model_name, root_node, fields, notebook=None, paned=None,
tooltips=None):
dict_widget = {}
state_widgets = []
notebook_list = []
attrs = common.node_attributes(root_node)
on_write = attrs.get('on_write', '')
if not tooltips:
tooltips = common.Tooltips()
container = _container(tooltips)
if CONFIG['client.modepda']:
container.new(col=1)
else:
container.new(col=int(attrs.get('col', 4)))
cursor_widget = attrs.get('cursor')
if not self.title:
self.title = attrs.get('string', 'Unknown')
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
attrs = common.node_attributes(node)
if not cursor_widget:
if (attrs.get('name') and fields.get(attrs['name'])
and not int(attrs.get('invisible', 0))
and not int(attrs.get('readonly', 0))
and attrs['name'] != self.screen.exclude_field):
cursor_widget = attrs.get('name')
yexpand = int(attrs.get('yexpand', 0))
yfill = int(attrs.get('yfill', 0))
xexpand = int(attrs.get('xexpand', 1))
xfill = int(attrs.get('xfill', 1))
colspan = int(attrs.get('colspan', 1))
if node.localName == 'image':
common.ICONFACTORY.register_icon(attrs['name'])
icon = Image(attrs=attrs)
state_widgets.append(icon)
icon.set_from_stock(attrs['name'], gtk.ICON_SIZE_DIALOG)
container.wid_add(icon,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'separator':
text = attrs.get('string', '')
if 'name' in attrs:
for attr_name in ('states', 'invisible'):
if attr_name not in attrs and attrs['name'] in fields:
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
if not text:
text = fields[attrs['name']].attrs['string']
vbox = VBox(attrs=attrs)
state_widgets.append(vbox)
if text:
label = gtk.Label(text)
label.set_alignment(float(attrs.get('xalign', 0.0)), 0.5)
vbox.pack_start(label)
vbox.pack_start(gtk.HSeparator())
container.wid_add(vbox,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=10,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'label':
text = attrs.get('string', '')
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('states', 'invisible'):
if attr_name not in attrs \
and attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
if 'string' not in attrs:
if gtk.widget_get_default_direction() == \
gtk.TEXT_DIR_RTL:
text = _(':') + \
fields[attrs['name']].attrs['string']
else:
text = fields[attrs['name']].attrs['string'] + \
_(':')
if 'xalign' not in attrs:
attrs['xalign'] = 1.0
elif not text:
for node in node.childNodes:
if node.nodeType == node.TEXT_NODE:
text += node.data
else:
text += node.toxml()
label = Label(text, attrs=attrs)
state_widgets.append(label)
if CONFIG['client.modepda']:
attrs['xalign'] = 0.0
label.set_alignment(float(attrs.get('xalign', 1.0)),
float(attrs.get('yalign', 0.0)))
label.set_angle(int(attrs.get('angle', 0)))
xexpand = bool(attrs.get('xexpand', 0))
container.wid_add(label,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'newline':
container.newline()
elif node.localName == 'button':
button = Button(attrs)
state_widgets.append(button)
container.wid_add(button,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'notebook':
notebook = Notebook(attrs=attrs)
state_widgets.append(notebook)
notebook.set_scrollable(True)
notebook_list.append(notebook)
if CONFIG['client.form_tab'] == 'top':
pos = gtk.POS_TOP
elif CONFIG['client.form_tab'] == 'left':
pos = gtk.POS_LEFT
elif CONFIG['client.form_tab'] == 'right':
pos = gtk.POS_RIGHT
elif CONFIG['client.form_tab'] == 'bottom':
pos = gtk.POS_BOTTOM
notebook.set_tab_pos(pos)
notebook.set_border_width(3)
colspan = int(attrs.get('colspan', 4))
yexpand = bool(attrs.get('yexpand', 1))
yfill = bool(attrs.get('yfill', 1))
container.wid_add(notebook,
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
notebook, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
state_widgets += state_widgets2
for widget_name, widgets in widgets.items():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
elif node.localName == 'page':
if CONFIG['client.form_tab'] == 'left':
angle = 90
tab_box = gtk.VBox(spacing=3)
image_pos, image_rotate = ('end',
gtk.gdk.PIXBUF_ROTATE_COUNTERCLOCKWISE)
elif CONFIG['client.form_tab'] == 'right':
angle = -90
tab_box = gtk.VBox(spacing=3)
image_pos, image_rotate = ('start',
gtk.gdk.PIXBUF_ROTATE_CLOCKWISE)
else:
angle = 0
tab_box = gtk.HBox(spacing=3)
image_pos, image_rotate = ('start',
gtk.gdk.PIXBUF_ROTATE_NONE)
text = attrs.get('string', '')
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
continue
for attr_name in ('states', 'invisible'):
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = \
fields[attrs['name']].attrs[attr_name]
if not text:
text = fields[attrs['name']].attrs['string']
if not text:
text = _('No String Attr.')
if '_' not in text:
text = '_' + text
tab_label = gtk.Label(text)
tab_label.set_angle(angle)
tab_label.set_use_underline(True)
tab_box.pack_start(tab_label)
if 'icon' in attrs:
common.ICONFACTORY.register_icon(attrs['icon'])
pixbuf = tab_box.render_icon(attrs['icon'],
gtk.ICON_SIZE_SMALL_TOOLBAR)
pixbuf = pixbuf.rotate_simple(image_rotate)
icon = gtk.Image()
icon.set_from_pixbuf(pixbuf)
if image_pos == 'end':
tab_box.pack_end(icon)
else:
tab_box.pack_start(icon)
tab_box.show_all()
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
notebook, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
state_widgets += state_widgets2
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(widget)
viewport.show()
scrolledwindow = ScrolledWindow(attrs=attrs)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scrolledwindow.add(viewport)
state_widgets.append(scrolledwindow)
notebook.append_page(scrolledwindow, tab_box)
elif node.localName == 'field':
name = str(attrs['name'])
if name == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
if name not in fields:
container.empty_add(int(attrs.get('colspan', 1)))
log = logging.getLogger(__name__)
log.error('Unknown field "%s"' % str(name))
continue
ftype = attrs.get('widget', fields[name].attrs['type'])
if not ftype in WIDGETS_TYPE:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('relation', 'domain', 'selection',
'relation_field', 'string', 'views', 'invisible',
'add_remove', 'sort', 'context', 'size', 'filename',
'autocomplete', 'translate', 'create', 'delete',
'selection_change_with', 'schema_model'):
if attr_name in fields[name].attrs and \
not attr_name in attrs:
attrs[attr_name] = fields[name].attrs[attr_name]
widget_act = WIDGETS_TYPE[ftype][0](name, model_name, attrs)
self.widget_id += 1
widget_act.position = self.widget_id
dict_widget.setdefault(name, [])
dict_widget[name].append(widget_act)
yexpand = bool(attrs.get('yexpand', WIDGETS_TYPE[ftype][2]))
yfill = bool(attrs.get('yfill', WIDGETS_TYPE[ftype][3]))
hlp = fields[name].attrs.get('help', attrs.get('help', False))
if attrs.get('height', False) or attrs.get('width', False):
widget_act.widget.set_size_request(
int(attrs.get('width', -1)),
int(attrs.get('height', -1)))
container.wid_add(Alignment(widget_act.widget, attrs),
fields[name].attrs['string'], fname=name,
help_tip=hlp,
colspan=colspan,
yexpand=yexpand, yfill=yfill,
xexpand=xexpand, xfill=xfill)
elif node.localName == 'group':
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
for widget_name, lwidgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(lwidgets)
state_widgets += state_widgets2
text = ''
if 'name' in attrs and attrs['name'] in fields:
if attrs['name'] == self.screen.exclude_field:
container.empty_add(int(attrs.get('colspan', 1)))
continue
for attr_name in ('states', 'invisible'):
if attr_name in fields[attrs['name']].attrs:
attrs[attr_name] = fields[attrs['name']
].attrs[attr_name]
text = fields[attrs['name']].attrs['string']
if attrs.get('string'):
text = attrs['string']
widget.set_homogeneous(bool(int(attrs.get('homogeneous', 0))))
frame = Frame(text, attrs=attrs, widgets=widgets)
frame.add(widget)
state_widgets.append(frame)
container.wid_add(frame,
colspan=colspan,
yexpand=yexpand, yfill=yfill, ypadding=0,
xexpand=xexpand, xfill=xfill, xpadding=0)
elif node.localName == 'hpaned':
hpaned = gtk.HPaned()
container.wid_add(hpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
paned=hpaned, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
state_widgets += state_widgets2
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if 'position' in attrs:
hpaned.set_position(int(attrs['position']))
elif node.localName == 'vpaned':
vpaned = gtk.VPaned()
container.wid_add(vpaned, colspan=int(attrs.get('colspan', 4)),
yexpand=True, yfill=True)
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
paned=vpaned, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
state_widgets += state_widgets2
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if 'position' in attrs:
vpaned.set_position(int(attrs['position']))
elif node.localName == 'child':
(widget, widgets, state_widgets2, spam, notebook_list2,
cursor_widget2) = self.parse(model_name, node, fields,
paned=paned, tooltips=tooltips)
if not cursor_widget:
cursor_widget = cursor_widget2
notebook_list.extend(notebook_list2)
state_widgets += state_widgets2
for widget_name, widgets in widgets.iteritems():
dict_widget.setdefault(widget_name, [])
dict_widget[widget_name].extend(widgets)
if not paned.get_child1():
paned.pack1(widget, resize=True, shrink=True)
elif not paned.get_child2():
paned.pack2(widget, resize=True, shrink=True)
return container.pop(), dict_widget, state_widgets, on_write, \
notebook_list, cursor_widget
def set_default_date(self, record, selected_date):
attrs = common.node_attributes(self.root_node)
dtstart = attrs.get('dtstart')
record[dtstart].set(
record, datetime.datetime.combine(selected_date, datetime.time(0)))
def domain_parser(self):
view_id = self.current_view.view_id if self.current_view else None
if view_id in self._domain_parser:
return self._domain_parser[view_id]
if view_id not in self.fields_view_tree:
try:
self.fields_view_tree[view_id] = view_tree = RPCExecute(
'model', self.model_name, 'fields_view_get', False, 'tree',
context=self.context)
except RPCException:
view_tree = {
'fields': {},
}
else:
view_tree = self.fields_view_tree[view_id]
fields = copy.deepcopy(view_tree['fields'])
for name, props in fields.items():
if props['type'] not in ('selection', 'reference'):
continue
if isinstance(props['selection'], (tuple, list)):
continue
props['selection'] = self.get_selection(props)
if 'arch' in view_tree:
# Filter only fields in XML view
xml_dom = xml.dom.minidom.parseString(view_tree['arch'])
root_node, = xml_dom.childNodes
ofields = collections.OrderedDict()
for node in root_node.childNodes:
if node.nodeName != 'field':
continue
attributes = node_attributes(node)
name = attributes['name']
# If a field is defined multiple times in the XML,
# take only the first definition
if name in ofields:
continue
ofields[name] = fields[name]
for attr in ['string', 'factor']:
if attributes.get(attr):
ofields[name][attr] = attributes[attr]
fields = ofields
if 'active' in view_tree['fields']:
self.screen_container.but_active.show()
else:
self.screen_container.but_active.hide()
# Add common fields
for name, string, type_ in (
('id', _('ID'), 'integer'),
('create_uid', _('Create by'), 'many2one'),
('create_date', _('Created at'), 'datetime'),
('write_uid', _('Edited by'), 'many2one'),
('write_date', _('Edited at'), 'datetime'),
):
if name not in fields:
fields[name] = {
'string': string,
'name': name,
'type': type_,
}
if type_ == 'datetime':
fields[name]['format'] = '"%H:%M:%S"'
domain_parser = DomainParser(fields, self.context)
self._domain_parser[view_id] = domain_parser
return domain_parser
def parse(self, model_name, root_node, fields):
dict_widget = {}
button_list = []
attrs = node_attributes(root_node)
on_write = attrs.get('on_write', '')
editable = attrs.get('editable', False)
if editable:
treeview = EditableTreeView(editable)
else:
treeview = gtk.TreeView()
treeview.cells = {}
treeview.sequence = attrs.get('sequence', False)
treeview.colors = attrs.get('colors', '"black"')
treeview.keyword_open = attrs.get('keyword_open', False)
treeview.connect('focus', self.set_selection)
self.treeview = treeview
treeview.set_property('rules-hint', True)
if not self.title:
self.title = attrs.get('string', 'Unknown')
tooltips = common.Tooltips()
expandable = False
for node in root_node.childNodes:
node_attrs = node_attributes(node)
if node.localName == 'field':
fname = str(node_attrs['name'])
for boolean_fields in ('readonly', 'required', 'expand'):
if boolean_fields in node_attrs:
node_attrs[boolean_fields] = \
bool(int(node_attrs[boolean_fields]))
if fname not in fields:
continue
for attr_name in ('relation', 'domain', 'selection',
'relation_field', 'string', 'views', 'invisible',
'add_remove', 'sort', 'context', 'filename'):
if attr_name in fields[fname].attrs and \
not attr_name in node_attrs:
node_attrs[attr_name] = fields[fname].attrs[attr_name]
cell = CELLTYPES.get(node_attrs.get('widget',
fields[fname].attrs['type']))(fname, model_name,
treeview, node_attrs)
treeview.cells[fname] = cell
renderer = cell.renderer
readonly = not (editable and not node_attrs.get('readonly',
fields[fname].attrs.get('readonly', False)))
if isinstance(renderer, CellRendererToggle):
renderer.set_property('activatable', not readonly)
elif isinstance(renderer,
(gtk.CellRendererProgress, CellRendererButton)):
pass
else:
renderer.set_property('editable', not readonly)
if (not readonly
and not isinstance(renderer, CellRendererBinary)):
renderer.connect_after('editing-started', send_keys,
treeview)
col = gtk.TreeViewColumn(fields[fname].attrs['string'])
if 'icon' in node_attrs:
render_pixbuf = gtk.CellRendererPixbuf()
col.pack_start(render_pixbuf, expand=False)
icon = node_attrs['icon']
def setter(column, cell, store, iter):
if (hasattr(self.treeview, 'get_realized')
and not self.treeview.get_realized()):
return
record = store.get_value(iter, 0)
value = record[icon].get_client(record) or ''
common.ICONFACTORY.register_icon(value)
pixbuf = treeview.render_icon(stock_id=value,
size=gtk.ICON_SIZE_BUTTON, detail=None)
cell.set_property('pixbuf', pixbuf)
col.set_cell_data_func(render_pixbuf, setter)
col.pack_start(renderer, expand=True)
col.name = fname
hbox = gtk.HBox(False, 2)
label = gtk.Label(fields[fname].attrs['string'])
label.show()
help = fields[fname].attrs['string']
if fields[fname].attrs.get('help'):
help += '\n' + fields[fname].attrs['help']
tooltips.set_tip(label, help)
tooltips.enable()
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
hbox.pack_start(label, True, True, 0)
hbox.pack_start(arrow, False, False, 0)
hbox.show()
col.set_widget(hbox)
col._type = fields[fname].attrs['type']
col.set_cell_data_func(renderer, cell.setter)
col.set_clickable(True)
twidth = {
'integer': 60,
'biginteger': 60,
'float': 80,
'numeric': 80,
'float_time': 100,
'date': 90,
'datetime': 140,
'selection': 90,
'char': 100,
'one2many': 50,
'many2many': 50,
'boolean': 20,
'binary': 200,
}
if 'width' in node_attrs:
width = int(node_attrs['width'])
else:
width = twidth.get(fields[fname].attrs['type'], 100)
col.width = width
if width > 0:
col.set_fixed_width(width)
col.set_min_width(1)
expand = node_attrs.get('expand', False)
col.set_expand(expand)
expandable |= expand
if (not treeview.sequence
and not self.children_field
and fields[fname].attrs.get('sortable', True)):
col.connect('clicked', sort_model, treeview, self.screen)
col.set_resizable(True)
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
col.set_visible(not node_attrs.get('tree_invisible',
fields[fname].attrs.get('tree_invisible', False)))
if fname == self.screen.exclude_field:
col.set_visible(False)
i = treeview.append_column(col)
if 'sum' in node_attrs and fields[fname].attrs['type'] \
in ('integer', 'biginteger', 'float', 'numeric',
'float_time'):
label = gtk.Label(node_attrs['sum'] + _(': '))
label_sum = gtk.Label()
if isinstance(fields[fname].attrs.get('digits'),
basestring):
digits = 2
else:
digits = fields[fname].attrs.get('digits', (16, 2))[1]
dict_widget[i] = (fname, label, label_sum, digits)
elif node.localName == 'button':
#TODO add shortcut
cell = Button(treeview, self.screen, node_attrs)
button_list.append(cell)
renderer = cell.renderer
string = node_attrs.get('string', _('Unknown'))
col = gtk.TreeViewColumn(string, renderer)
col.name = None
label = gtk.Label(string)
label.show()
help = string
if node_attrs.get('help'):
help += '\n' + node_attrs['help']
tooltips.set_tip(label, help)
tooltips.enable()
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
col.set_widget(label)
col._type = 'button'
col.set_cell_data_func(renderer, cell.setter)
if 'width' in node_attrs:
width = int(node_attrs['width'])
else:
width = 80
col.width = width
if width > 0:
col.set_fixed_width(width)
col.set_resizable(True)
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
i = treeview.append_column(col)
if not expandable:
col = gtk.TreeViewColumn()
col.name = None
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)
col.arrow = arrow
col.arrow_show = False
col._type = 'fill'
col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
treeview.append_column(col)
treeview.set_fixed_height_mode(True)
return treeview, dict_widget, button_list, on_write, [], None
def parse(self, root_node, notebook=None, paned=None, tooltips=None):
widgets = []
attrs = common.node_attributes(root_node)
if not tooltips:
tooltips = common.Tooltips()
container = _container(tooltips)
container.new(col=int(attrs.get('col', 4)))
if not self.title:
self.title = attrs.get('string', 'Unknown')
for node in root_node.childNodes:
if not node.nodeType == node.ELEMENT_NODE:
continue
attrs = common.node_attributes(node)
yexpand = int(attrs.get('yexpand', 0))
yfill = int(attrs.get('yfill', 0))
xexpand = int(attrs.get('xexpand', 1))
xfill = int(attrs.get('xfill', 1))
colspan = int(attrs.get('colspan', 1))
if node.localName == 'image':
common.ICONFACTORY.register_icon(attrs['name'])
icon = gtk.Image()
icon.set_from_stock(attrs['name'], gtk.ICON_SIZE_DIALOG)
container.wid_add(icon,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand,
yfill=yfill,
ypadding=10,
xexpand=xexpand,
xfill=xfill)
elif node.localName == 'separator':
text = attrs.get('string', '')
vbox = VBox(attrs=attrs)
if text:
label = gtk.Label(text)
label.set_use_markup(True)
label.set_alignment(float(attrs.get('align', 0.0)), 0.5)
vbox.pack_start(label)
vbox.pack_start(gtk.HSeparator())
container.wid_add(vbox,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand,
yfill=yfill,
ypadding=10,
xexpand=xexpand,
xfill=xfill)
elif node.localName == 'label':
text = attrs.get('string', '')
if not text:
container.empty_add(int(attrs.get('colspan', 1)))
continue
label = gtk.Label(text)
label.set_use_markup(True)
label.set_alignment(float(attrs.get('xalign', 1.0)),
float(attrs.get('yalign', 0.0)))
label.set_angle(int(attrs.get('angle', 0)))
xexpand = bool(attrs.get('xexpand', 0))
container.wid_add(label,
help_tip=attrs.get('help', False),
colspan=colspan,
yexpand=yexpand,
yfill=yfill,
xexpand=xexpand,
xfill=xfill)
elif node.localName == 'newline':
container.newline()
elif node.localName == 'notebook':
notebook = gtk.Notebook()
if CONFIG['client.form_tab'] == 'top':
pos = gtk.POS_TOP
elif CONFIG['client.form_tab'] == 'left':
pos = gtk.POS_LEFT
elif CONFIG['client.form_tab'] == 'right':
pos = gtk.POS_RIGHT
elif CONFIG['client.form_tab'] == 'bottom':
pos = gtk.POS_BOTTOM
notebook.set_tab_pos(pos)
notebook.set_border_width(3)
container.wid_add(notebook,
colspan=int(attrs.get('colspan', 4)),
yexpand=True,
yfill=True)
widget, new_widgets = self.parse(node,
notebook,
tooltips=tooltips)
widgets += new_widgets
elif node.localName == 'page':
if CONFIG['client.form_tab'] == 'left':
angle = 90
elif CONFIG['client.form_tab'] == 'right':
angle = -90
else:
angle = 0
label = gtk.Label(attrs.get('string', _('No String Attr.')))
label.set_angle(angle)
widget, new_widgets = self.parse(node,
notebook,
tooltips=tooltips)
widgets += new_widgets
notebook.append_page(widget, label)
elif node.localName == 'group':
widget, new_widgets = self.parse(node, tooltips=tooltips)
widgets += new_widgets
if attrs.get('string', None):
frame = gtk.Frame(attrs['string'])
frame.add(widget)
else:
frame = widget
container.wid_add(frame,
colspan=colspan,
yexpand=yexpand,
yfill=yfill,
ypadding=0,
xexpand=xexpand,
xfill=xfill,
xpadding=0)
elif node.localName == 'hpaned':
hpaned = gtk.HPaned()
container.wid_add(hpaned,
colspan=int(attrs.get('colspan', 4)),
yexpand=True,
yfill=True)
widget, new_widgets = self.parse(node,
paned=hpaned,
tooltips=tooltips)
widgets += new_widgets
if 'position' in attrs:
hpaned.set_position(int(attrs['position']))
elif node.localName == 'vpaned':
vpaned = gtk.VPaned()
container.wid_add(vpaned,
colspan=int(attrs.get('colspan', 4)),
yexpand=True,
yfill=True)
widget, new_widgets = self.parse(node,
paned=vpaned,
tooltips=tooltips)
widgets += new_widgets
if 'position' in attrs:
vpaned.set_position(int(attrs['position']))
elif node.localName == 'child':
widget, new_widgets = self.parse(node,
paned=paned,
tooltips=tooltips)
widgets += new_widgets
if not paned.get_child1():
paned.pack1(widget, resize=True, shrink=True)
elif not paned.get_child2():
paned.pack2(widget, resize=True, shrink=True)
elif node.localName == 'action':
widget_act = Action(attrs, self.context)
widgets.append(widget_act)
yexpand = bool(attrs.get('yexpand', 1))
yfill = bool(attrs.get('yfill', 1))
container.wid_add(widget_act.widget,
colspan=colspan,
yexpand=yexpand,
yfill=yfill,
xexpand=xexpand,
xfill=xfill)
return container.pop(), widgets
