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