def display(self, model, model_field):
if not model_field:
self.ok = False
self.widget_combo.child.set_text('')
return False
super(reference, self).display(model, model_field)
value = model_field.get_client(model)
self.ok = False
img = gtk.Image()
if not value:
model, (id, name) = '', (0, '')
self.wid_text.set_text('')
self.widget_combo.child.set_text('')
else:
model, (id, name) = value
if id:
self.widget_combo.child.set_text(self._selection2[model])
if not name:
id, name = RPCProxy(model).name_get([id],
rpc.session.context)[0]
self.wid_text.set_text(name)
img.set_from_stock('gtk-open', gtk.ICON_SIZE_BUTTON)
self.but_open.set_image(img)
else:
# self.wid_text.set_text('') # this is commented as this caused many2one set to be unenterable
img.set_from_stock('gtk-find', gtk.ICON_SIZE_BUTTON)
self.but_open.set_image(img)
self.ok = True
def open_remote(self, model, create=True, changed=False, text=None):
modelfield = model[self.field_name]
relation = modelfield.attrs['relation']
rpc = RPCProxy(relation)
context = model[self.field_name].context_get(model)
domain = model[self.field_name].domain_get(model)
if create:
if text and len(text) and text[0] <> '(':
domain.append(('name', '=', text))
ids = rpc.search(domain)
if ids and len(ids) == 1:
return True, ids
else:
ids = model[self.field_name].get_client(model)
win = win_search(relation,
sel_multi=True,
ids=ids,
context=context,
domain=domain)
found = win.go()
if found:
return True, found
else:
return False, None
def __init__(self,
resource,
fields,
ids=[],
parent=None,
context={},
is_wizard=False,
screen=None):
super(ModelRecordGroup, self).__init__()
self._readonly = False
self.parent = parent
self._context = context
self._context.update(rpc.session.context)
self.resource = resource
self.rpc = RPCProxy(resource)
self.fields = fields
self.mfields = {}
self.mfields_load(fields.keys(), self)
self.screen = screen
self.models = ModelList(self)
self.current_idx = None
self.load(ids)
self.models_removed = []
self.on_write = ''
self.is_wizard = is_wizard
self.list_parent = False
self.list_group = False
def _get_colors(self, models, color_field, color_field_custom):
auto_color_count = 0 # how many color do we need to generate auto.
colors = {}
for model in models:
name = value = key = model.value[color_field]
if isinstance(key, (tuple, list)):
value, name = key
key = tuple(key)
if key in colors:
# already present skip
continue
# if field is many2one, try to get color from object
# 'color' field
field_color = None
field_widget = model.mgroup.mfields.get(color_field, False)
if field_widget and field_widget.attrs['type'] == 'many2one':
fproxy = RPCProxy(field_widget.attrs['relation'])
try:
fdata = fproxy.read(value, [color_field_custom])
if fdata:
field_color = fdata.get(color_field_custom) and str(fdata.get(color_field_custom)) or None
except Exception, e:
#TODO: Need to limit exception
self.log.exception(e)
pass
if not field_color:
# increment total color to generate
auto_color_count += 1
colors[key] = (name, value, field_color)
def __init__(self,
resource,
id,
group=None,
parent=None,
new=False,
list_parent=None):
super(ModelRecord, self).__init__()
self.resource = str(resource)
self.rpc = RPCProxy(self.resource)
self.id = id
self.list_parent = list_parent
self._loaded = False
self.parent = parent
self.mgroup = group
self.value = {}
self.state_attrs = {}
self.modified = False
self.modified_fields = {}
self.pager_cache = {}
self.is_m2m_modified = False
self._concurrency_check_data = False
for key, val in self.mgroup.mfields.items():
self.value[key] = val.create(self)
if (new and val.attrs['type'] == 'one2many') and (val.attrs.get(
'mode', 'tree,form').startswith('form')):
mod = self.value[key].model_new()
self.value[key].model_add(mod)
def open_remote(self, model, create=True, changed=False, text=None):
modelfield = model.mgroup.mfields[self.field_name]
relation = modelfield.attrs['relation']
domain = modelfield.domain_get(model)
context = modelfield.context_get(model)
if create:
id = None
elif not changed:
id = modelfield.get(model)
else:
rpc = RPCProxy(relation)
names = rpc.name_search(text, domain, 'ilike', context)
if len(names) == 1:
return True, names[0]
searched = self.search_remote(relation, [x[0] for x in names],
domain=domain,
context=context)
if searched[0]:
return True, searched
return False, False
dia = M2ODialog(relation,
id,
domain=domain,
context=context,
window=self.window)
ok, value = dia.run()
dia.destroy()
if ok:
return True, value
else:
return False, False
def cond_default(self, field, value):
ir = RPCProxy('ir.values')
values = ir.get('default', '%s=%s' % (field, value),
[(self.resource, False)], False, {})
data = {}
for index, fname, value in values:
data[fname] = value
self.set_default(data)
def search_remote(self, relation, ids=[], domain=[], context={}):
rpc = RPCProxy(relation)
win = win_search(relation, sel_multi=False, ids=ids, context=context, domain=domain)
found = win.go()
if found:
return rpc.name_get([found[0]], context)[0]
else:
return False, None
def set(self, model, value, test_state=False, modified=False):
if value and isinstance(value, (int, str, unicode, long)):
rpc2 = RPCProxy(self.attrs['relation'])
result = rpc2.name_get([value], rpc.session.context)
model.value[self.name] = result and result[0] or ''
else:
model.value[self.name] = value
if modified:
model.modified = True
model.modified_fields.setdefault(self.name)
def cond_default(self, field, value):
if field in self.mgroup.mfields:
if self.mgroup.mfields[field].attrs.get('change_default', False):
ir = RPCProxy('ir.values')
values = ir.get('default', '%s=%s' % (field, value),
[(self.resource, False)], False, {})
data = {}
for index, fname, value in values:
data[fname] = value
self.set_default(data)
def value_from_text(self, model, text):
if not text:
return []
if not (text[0]<>'('):
return model[self.field_name].get(model)
relation = model[self.field_name].attrs['relation']
rpc = RPCProxy(relation)
domain = model[self.field_name].domain_get(model)
context = model[self.field_name].context_get(model)
names = rpc.name_search(text, domain, 'ilike', context)
ids = [x[0] for x in names]
win = win_search(relation, sel_multi=True, ids=ids, context=context, domain=domain)
found = win.go()
return found or []
def value_from_text(self, model, text):
if not text:
return False
relation = model[self.field_name].attrs['relation']
rpc = RPCProxy(relation)
domain = model[self.field_name].domain_get(model)
context = model[self.field_name].context_get(model)
names = rpc.name_search(text, domain, 'ilike', context)
if len(names) != 1:
return self.search_remote(relation, [x[0] for x in names],
domain=domain, context=context)[0]
return names[0]
def set(self, model, value, test_state=False, modified=False):
if not value:
model.value[self.name] = False
return
ref_model, id = value.split(',')
if id:
id = int(id)
rpc2 = RPCProxy(ref_model)
result = rpc2.name_get([id], rpc.session.context)
if result:
model.value[self.name] = ref_model, result[0]
else:
model.value[self.name] = False
if modified:
model.modified = True
model.modified_fields.setdefault(self.name)
def set_default(self, model, value):
from widget.model.group import ModelRecordGroup
fields = {}
if value and len(value):
context = self.context_get(model)
rpc2 = RPCProxy(self.attrs['relation'])
fields = rpc2.fields_get(value[0].keys(), context)
model.value[self.name] = ModelRecordGroup(
resource=self.attrs['relation'], fields=fields, parent=model)
model.value[self.name].signal_connect(model.value[self.name],
'model-changed',
self._model_changed)
mod = None
for record in (value or []):
mod = model.value[self.name].model_new(default=False)
mod.set_default(record)
model.value[self.name].model_add(mod)
model.value[self.name].current_model = mod
#mod.signal('record-changed')
return True
def drag_data_received(self, treeview, context, x, y, selection, info,
etime):
treeview.emit_stop_by_name('drag-data-received')
if treeview.sequence:
for model in self.screen.models.models:
if model['sequence'].get_state_attrs(model).get(
'readonly', False):
return
model = treeview.get_model()
data = eval(selection.data)
get_id = data[0]
drop_info = treeview.get_dest_row_at_pos(x, y)
if drop_info:
path, position = drop_info
self.source_group_child = []
rec_id = model.on_iter_has_child(
model.on_get_iter(path)) and path or path[:-1]
group_by = self.screen.context.get('group_by')
if group_by:
if data and path and data[:-1] == path[:-1] \
and isinstance(model.on_get_iter(data), ModelRecord):
if position in (gtk.TREE_VIEW_DROP_BEFORE,
gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
m_path = path[-1]
else:
m_path = path[-1] + 1
source_models_list = model.on_get_iter(path[:-1])
self.group_by_move(source_models_list, data[-1], m_path)
else:
source_group = model.on_get_iter(data)
target_group = model.on_get_iter(rec_id)
if model.on_iter_has_child(source_group):
def process(parent):
for child in parent.getChildren().lst:
if model.on_iter_has_child(child):
process(child)
else:
self.source_group_child.append(child)
process(source_group)
else:
self.source_group_child = [source_group]
if self.source_group_child:
self.screen.current_model = self.source_group_child[0]
target_domain = filter(
lambda x: x[0] in group_by,
target_group.children.context.get('__domain', []))
val = {}
map(lambda x: val.update({x[0]: x[2]}), target_domain)
rpc = RPCProxy(self.source_group_child[0].resource)
rpc.write(map(lambda x: x.id, self.source_group_child),
val)
self.reload = True
self.screen.reload()
for expand_path in (data, path):
treeview.expand_to_path(expand_path)
else:
idx = path[0]
if position in (gtk.TREE_VIEW_DROP_BEFORE,
gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
model.move(data, idx)
rec_id = idx
else:
model.move(data, idx + 1)
rec_id = idx + 1
context.drop_finish(False, etime)
if treeview.sequence and drop_info and not group_by:
self.screen.models.set_sequence(get_id, rec_id, field='sequence')
def __init__(self,
model_name,
view_ids=None,
view_type=None,
help={},
parent=None,
context=None,
views_preload=None,
tree_saves=True,
domain=None,
create_new=False,
row_activate=None,
hastoolbar=False,
hassubmenu=False,
default_get=None,
show_search=False,
window=None,
limit=100,
readonly=False,
auto_search=True,
is_wizard=False,
search_view=None,
win_search=False):
if view_ids is None:
view_ids = []
if view_type is None:
view_type = ['tree', 'form']
if views_preload is None:
views_preload = {}
if not domain:
domain = []
if default_get is None:
default_get = {}
if search_view is None:
search_view = "{}"
super(Screen, self).__init__()
self.win_search = win_search
self.win_search_domain = []
self.win_search_ids = []
self.win_search_callback = False
self.show_search = show_search
self.auto_search = auto_search
self.search_count = 0
self.hastoolbar = hastoolbar
self.hassubmenu = hassubmenu
self.default_get = default_get
self.sort = False
self.type = None
self.dummy_cal = False
if not row_activate:
self.row_activate = lambda self, screen=None: self.switch_view(
screen, 'form')
else:
self.row_activate = row_activate
self.create_new = create_new
self.name = model_name
self.domain_init = domain
self.action_domain = []
self.action_domain += domain
self.latest_search = []
self.views_preload = views_preload
self.resource = model_name
self.rpc = RPCProxy(model_name)
self.context_init = context or {}
self.context_update()
self.views = []
self.fields = {}
self.view_ids = view_ids
self.models = None
self.parent = parent
self.window = window
self.is_wizard = is_wizard
self.search_view = eval(search_view)
models = ModelRecordGroup(model_name,
self.fields,
parent=self.parent,
context=self.context,
is_wizard=is_wizard,
screen=self)
self.models_set(models)
self.current_model = None
self.screen_container = screen_container(self.win_search)
self.filter_widget = None
self.widget = self.screen_container.widget_get()
self.__current_view = 0
self.tree_saves = tree_saves
self.limit = limit
self.old_limit = limit
self.offset = 0
self.readonly = readonly
self.custom_panels = []
self.view_fields = {
} # Used to switch self.fields when the view switchs
self.sort_domain = []
self.old_ctx = {}
self.help_mode = False
if view_type:
self.view_to_load = view_type[1:]
view_id = False
if view_ids:
view_id = view_ids.pop(0)
if view_type[0] in ('tree', 'graph', 'calendar'):
self.screen_container.help = help
self.help_mode = view_type[0]
view = self.add_view_id(view_id, view_type[0], help=help)
self.screen_container.set(view.widget)
self.display()
def __init__(self,
model_name,
view_ids=None,
view_type=None,
parent=None,
context=None,
views_preload=None,
tree_saves=True,
domain=None,
create_new=False,
row_activate=None,
hastoolbar=False,
default_get=None,
show_search=False,
window=None,
limit=80,
readonly=False,
is_wizard=False):
if view_ids is None:
view_ids = []
if view_type is None:
view_type = ['tree', 'form']
if context is None:
context = {}
if views_preload is None:
views_preload = {}
if domain is None:
domain = []
if default_get is None:
default_get = {}
super(Screen, self).__init__()
self.show_search = show_search
self.search_count = 0
self.hastoolbar = hastoolbar
self.default_get = default_get
if not row_activate:
self.row_activate = lambda self, screen=None: self.switch_view(
screen, 'form')
else:
self.row_activate = row_activate
self.create_new = create_new
self.name = model_name
self.domain = domain
self.latest_search = []
self.views_preload = views_preload
self.resource = model_name
self.rpc = RPCProxy(model_name)
self.context = context
self.context.update(rpc.session.context)
self.views = []
self.fields = {}
self.view_ids = view_ids
self.models = None
self.parent = parent
self.window = window
self.is_wizard = is_wizard
models = ModelRecordGroup(model_name,
self.fields,
parent=self.parent,
context=self.context,
is_wizard=is_wizard)
self.models_set(models)
self.current_model = None
self.screen_container = screen_container()
self.filter_widget = None
self.widget = self.screen_container.widget_get()
self.__current_view = 0
self.tree_saves = tree_saves
self.limit = limit
self.readonly = readonly
self.view_fields = {
} # Used to switch self.fields when the view switchs
if view_type:
self.view_to_load = view_type[1:]
view_id = False
if view_ids:
view_id = view_ids.pop(0)
view = self.add_view_id(view_id, view_type[0])
self.screen_container.set(view.widget)
self.display()
def __init__(self, object, relation, screen):
self.object = object
self.rpc = RPCProxy(relation)
self.screen = screen
self.domain = []
self.type = screen.type
def __init__(self, cmdname, options):
self.proxy = RPCProxy()
self.cmdname = cmdname
self.options = options
