Python Screen.clear方法代码示例

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]

#.........这里部分代码省略.........
        id = self.screen.id_get()
        if mode<>self.screen.current_view.view_type:
            self.screen.switch_view(mode=mode)
            if id:
                self.sig_reload()
                self.get_resource(get_id=id)

    def sig_logs(self, widget=None):
        id = self.id_get()
        if not id:
            self.message_state(_('You have to select a record !'), color='red')
            return False
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'perm_read', [id])
        message = ''
        for line in res:
            todo = [
                ('id', _('ID')),
                ('create_uid', _('Creation User')),
                ('create_date', _('Creation Date')),
                ('write_uid', _('Latest Modification by')),
                ('write_date', _('Latest Modification Date')),
                ('xmlid', _('Internal Module Data ID'))
            ]
            for (key,val) in todo:
                if line[key] and key in ('create_uid','write_uid','uid'):
                    line[key] = line[key][1]
                message+=val+': '+str(line[key] or '/')+'\n'
        common.message(message)
        return True
    
    @set_tooltips
    def sig_remove(self, widget=None):
        if not self.id_get():
            msg = _('Record is not saved ! \n Do you want to clear current record ?')
        else:
            if self.screen.current_view.view_type == 'form':
                msg = _('Are you sure to remove this record ?')
            else:
                msg = _('Are you sure to remove those records ?')
        if common.sur(msg):
            id = self.screen.remove(unlink=True)
            if not id:
                self.message_state(_('Resources cleared.'), color='darkgreen')
            else:
                self.message_state(_('Resources successfully removed.'), color='darkgreen')
        self.sig_reload()

    def sig_import(self, widget=None):
        fields = []
        while(self.screen.view_to_load):
            self.screen.load_view_to_load(mode = self.screen.view_to_load[0])
        screen_fields = copy.deepcopy(self.screen.models.fields)
        win = win_import.win_import(self.model, screen_fields, fields, parent=self.window,local_context= self.screen.context)
        res = win.go()
        
    def sig_save_as(self, widget=None):
        fields = []
        while(self.screen.view_to_load):
            self.screen.load_view_to_load(mode = self.screen.view_to_load[0])
        screen_fields = copy.deepcopy(self.screen.models.fields)
        win = win_export.win_export(self.model, self.screen.ids_get(), screen_fields, fields, parent=self.window, context=self.context)
        res = win.go()
    
    def sig_new(self, widget=None, autosave=True):
        if autosave:
            if not self.modified_save():

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]

#.........这里部分代码省略.........
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['model'], 'default_get', [self.name])
        self.value = res.get(self.name, False)

    def _sig_add(self, *args):
        domain = self._view.modelfield.domain_get(self._view.model)
        context = self._view.modelfield.context_get(self._view.model)
        records = rpc.session.rpc_exec_auth('/object', 'execute',
                                        self.attrs['relation'], 'name_search',
                                        self.wid_text.get_text(), domain, 'ilike', context)
        ids = [oid for oid, _ in records]
        #Updating the context in order to avoid domain of name_search and custom domain of search_context
        context.update({'name_search':self.wid_text.get_text()})
        self.wid_text.set_text('')
        win = win_search(self.attrs['relation'], sel_multi=True, ids=ids, context=context, domain=domain, parent=self._window)
        ids = win.go()

        if ids == None:
            ids = []
        if self.name in self.model.pager_cache:
            self.model.pager_cache[self.name] = list(set(self.model.pager_cache[self.name] + ids))
        else:
            self.model.pager_cache[self.name] = ids
        self.model.is_m2m_modified = True
        self._focus_out()
        self.pager.reset_pager()
        self.pager.search_count()

    def _sig_remove(self, *args):
        remove_ids = self.screen.current_view.sel_ids_get()
        if not remove_ids:
           return
        for oid in remove_ids:
            if oid in self.model.pager_cache[self.name]:
                self.model.pager_cache[self.name].remove(oid)
        self.model.is_m2m_modified = True
        self.screen.remove()
        self.screen.display()
        self._focus_out()
        self.pager.reset_pager()
        self.pager.search_count()

    def _sig_activate(self, *args):
        self._sig_add()

    def _readonly_set(self, ro):
        self.wid_text.set_editable(not ro)
        self.wid_text.set_sensitive(not ro)
        self.wid_but_remove.set_sensitive(not ro)
        self.wid_but_add.set_sensitive(not ro)

    def limit_changed(self,*args):
        self.pager.limit_changed()


    def _sig_prev_page(self, *args):
        self.pager.prev_page()

    def _sig_next_page(self, *args):
        self.pager.next_page()

    def _sig_next(self, *args):
        _, event = args
        if event.type == gtk.gdk.BUTTON_PRESS:
            self.pager.next_record()


    def _sig_previous(self, *args):
        _, event = args
        if event.type == gtk.gdk.BUTTON_PRESS:
            self.pager.prev_record()

    def _sig_label(self, screen, signal_data):
        name = '_'
        if signal_data[0] >= 0:
            name = str(signal_data[0] + 1)
        line = '(%s/%s of %s)' % (name, signal_data[1], signal_data[2])
        self.label.set_text(line)

    def display(self, model, model_field):
        self.model = model
        self.model_field = model_field
        super(many2many, self).display(model, model_field)
        ids = []
        if model_field:
            ids = model_field.get_client(model)
            self.model.pager_cache.setdefault(model_field.name, model.value[model_field.name] or [])
            self.pager.search_count()
        self.screen.clear()
        self.screen.load(ids)
        self.screen.display()
        self.pager.set_sensitivity()
        return True

    def set_value(self, model, model_field):
        self.model.pager_cache.setdefault(model_field.name, model.value[model_field.name] or [])
        if self.name in model.pager_cache:
            model_field.set_client(model, model.pager_cache[self.name])

    def grab_focus(self):
        return self.wid_text.grab_focus()

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]

#.........这里部分代码省略.........
    def sig_logs(self, widget=None):
        id = self.id_get()
        if not id:
            self.message_state(_('You have to select a record !'), color='red')
            return False
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'perm_read', [id])
        message = ''
        for line in res:
            todo = [
                ('id', _('ID')),
                ('create_uid', _('Creation User')),
                ('create_date', _('Creation Date')),
                ('write_uid', _('Latest Modification by')),
                ('write_date', _('Latest Modification Date'))
            ]
            for (key,val) in todo:
                if line[key] and key in ('create_uid','write_uid','uid'):
                    line[key] = line[key][1]
                message+=val+': '+str(line[key] or '/')+'\n'
        common.message(message)
        return True

    def sig_remove(self, widget=None):
        if not self.id_get():
            msg = _('Record is not saved ! \n Do You want to Clear Current Record ?')
        else:
            if self.screen.current_view.view_type == 'form':
                msg = _('Are you sure to remove this record ?')
            else:
                msg = _('Are you sure to remove those records ?')
        if common.sur(msg):
            id = self.screen.remove(unlink=True)
            if not id:
                self.message_state(_('Resources cleared.'), color='darkgreen')
            else:
                self.message_state(_('Resources successfully removed.'), color='darkgreen')
        self.sig_reload()
        
    def sig_import(self, widget=None):
        fields = []
        while(self.screen.view_to_load):
            self.screen.load_view_to_load()
        win = win_import.win_import(self.model, self.screen.fields, fields, parent=self.window,local_context= self.screen.context)
        res = win.go()

    def sig_save_as(self, widget=None):
        fields = []
        while(self.screen.view_to_load):
            self.screen.load_view_to_load()
        win = win_export.win_export(self.model, self.screen.ids_get(), self.screen.fields, fields, parent=self.window, context=self.context)
        res = win.go()

    def sig_new(self, widget=None, autosave=True):
        if autosave:
            if not self.modified_save():
                return
        self.screen.new()
        self.message_state('')

    def sig_copy(self, *args):
        if not self.modified_save():
            return
        res_id = self.id_get()
        ctx = self.context.copy()
        ctx.update(rpc.session.context)
        new_id = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'copy', res_id, {}, ctx)

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]
class action(interface.widget_interface):
    def __init__(self, window, parent, model, attrs={}):
        interface.widget_interface.__init__(self, window, parent, model, attrs)

        self.act_id=attrs['name']
        res = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.actions.actions', 'read', [self.act_id], ['type'], rpc.session.context)
        if not res:
            raise Exception, 'ActionNotFound'
        type=res[0]['type']
        self.action = rpc.session.rpc_exec_auth('/object', 'execute', type, 'read', [self.act_id], False, rpc.session.context)[0]
        if 'view_mode' in attrs:
            self.action['view_mode'] = attrs['view_mode']

        if self.action['type']=='ir.actions.act_window':
            if not self.action.get('domain', False):
                self.action['domain']='[]'
            self.context = {'active_id': False, 'active_ids': []}
            self.context.update(eval(self.action.get('context', '{}'), self.context.copy()))
            a = self.context.copy()
            a['time'] = time
            a['datetime'] = datetime
            self.domain = tools.expr_eval(self.action['domain'], a)

            view_id = []
            if self.action['view_id']:
                view_id = [self.action['view_id'][0]]
            if self.action['view_type']=='form':
                mode = (self.action['view_mode'] or 'form,tree').split(',')
                self.screen = Screen(self.action['res_model'], view_type=mode, context=self.context, view_ids = view_id, domain=self.domain)
                self.win_gl = glade.XML(common.terp_path("openerp.glade"), 'widget_paned', gettext.textdomain())

                self.win_gl.signal_connect('on_switch_button_press_event', self._sig_switch)
                self.win_gl.signal_connect('on_search_button_press_event', self._sig_search)
                self.win_gl.signal_connect('on_open_button_press_event', self._sig_open)
                label=self.win_gl.get_widget('widget_paned_lab')
                label.set_text(attrs.get('string', self.screen.current_view.title))
                vbox=self.win_gl.get_widget('widget_paned_vbox')
                vbox.add(self.screen.widget)
                self.widget=self.win_gl.get_widget('widget_paned')
                self.widget.set_size_request(int(attrs.get('width', -1)), int(attrs.get('height', -1)))
            elif self.action['view_type']=='tree':
                pass #TODO

    def _sig_switch(self, *args):
        self.screen.switch_view()

    def _sig_search(self, *args):
        win = win_search(self.action['res_model'], domain=self.domain, context=self.context)
        res = win.go()
        if res:
            self.screen.clear()
            self.screen.load(res)

    def _sig_open(self, *args):
        obj = service.LocalService('action.main')
        obj.execute(self.act_id, {})

    def set_value(self, mode, model_field):
        self.screen.current_view.set_value()
        return True

    def display(self, model, model_field):
        res_id = rpc.session.rpc_exec_auth('/object', 'execute',
                self.action['res_model'], 'search', self.domain, 0,
                self.action.get('limit', 80),False,self.context)
        self.screen.clear()
        self.screen.load(res_id)
        return True

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]
class action(interface.widget_interface):
    def __init__(self, window, parent, model, attrs={}):
        interface.widget_interface.__init__(self, window, parent, model, attrs)

        self.act_id = int(attrs['name'])
        res = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.actions.actions', 'read', [self.act_id], ['type'], rpc.session.context)
        if not res:
            raise Exception, 'ActionNotFound'
        type = res[0]['type']
        self.action = rpc.session.rpc_exec_auth('/object', 'execute', type, 'read', [self.act_id], False, rpc.session.context)[0]
        if 'view_mode' in attrs:
            self.action['view_mode'] = attrs['view_mode']
        self.action_view_ids = False
        if self.action['type'] == 'ir.actions.act_window':
            if not self.action.get('domain', False):
                self.action['domain'] = '[]'
            if attrs.get('domain',False):
                self.action['domain'] = attrs.get('domain')
            self.context = {'active_id': False, 'active_ids': []}
            self.context.update(tools.expr_eval(self.action.get('context', '{}'), self.context.copy()))
            self.domain = tools.expr_eval(self.action['domain'], self.context.copy())
            view_id = []
            if self.action['view_id']:
                view_id = [self.action['view_id'][0]]
            if self.action.get('views'):
                self.action_view_ids = map(lambda y:y[0], filter(lambda x:x[1] == 'tree',self.action['views']))
            if self.action['view_type']=='form':
                mode = (self.action['view_mode'] or 'form,tree').split(',')
                self.screen = Screen(self.action['res_model'], view_type=mode, context=self.context, view_ids = view_id, domain=self.domain)
                self.ui = openerp_gtk_builder('openerp.ui', ['widget_paned'])
                self.ui.connect_signals({
                    'on_switch_button_press_event': self._sig_switch,
                    'on_search_button_press_event': self._sig_search,
                    'on_open_button_press_event': self._sig_open,
                })
                label = self.ui.get_object('widget_paned_lab')
                label.set_text(attrs.get('string', self.screen.current_view.title))
                vbox = self.ui.get_object('widget_paned_vbox')
                vbox.add(self.screen.widget)
                self.widget = self.ui.get_object('widget_paned')
                self.widget.set_size_request(int(attrs.get('width', -1)), int(attrs.get('height', -1)))
            elif self.action['view_type']=='tree':
                pass #TODO

    def _sig_switch(self, *args):
        self.screen.switch_view()

    def _sig_search(self, *args):
        win = win_search(self.action['res_model'], view_ids = self.action_view_ids, domain=self.domain, context=self.context)
        res = win.go()
        if res:
            self.screen.clear()
            self.screen.load(res)

    def _sig_open(self, *args):
        obj = service.LocalService('action.main')
        obj.execute(self.act_id, datas={}, type=None, context={})

    def set_value(self, mode, model_field):
        self.screen.current_view.set_value()
        return True

    def display(self, model, model_field):
        limit = self.screen.current_view.view_type != 'graph' and self.action.get('limit', 100)  or False
        res_id = rpc.session.rpc_exec_auth('/object', 'execute',
                self.action['res_model'], 'search', self.domain, 0,
                limit, False, self.context)
        self.screen.clear()
        self.screen.load(res_id)
        return True

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]
class many2many(interface.widget_interface):
    def __init__(self, window, parent, model, attrs={}):
        interface.widget_interface.__init__(self, window, parent, model, attrs)

        self.widget = gtk.VBox(homogeneous=False, spacing=1)

        hb = gtk.HBox(homogeneous=False, spacing=3)
        self.wid_text = gtk.Entry()
        self.wid_text.set_property('width_chars', 13)
        self.wid_text.connect('activate', self._sig_activate)
        self.wid_text.connect('button_press_event', self._menu_open)
        hb.pack_start(self.wid_text, expand=True, fill=True)

        hb.pack_start(gtk.VSeparator(), padding=2, expand=False, fill=False)

        self.wid_but_add = gtk.Button(stock='gtk-add')
        self.wid_but_add.set_relief(gtk.RELIEF_HALF)
        self.wid_but_add.set_focus_on_click(True)
        self.wid_but_add.connect('clicked', self._sig_add)
        hb.pack_start(self.wid_but_add, padding=3, expand=False, fill=False)

        self.wid_but_remove = gtk.Button(stock='gtk-remove')
        self.wid_but_remove.set_relief(gtk.RELIEF_HALF)
        self.wid_but_remove.set_focus_on_click(True)
        self.wid_but_remove.connect('clicked', self._sig_remove)
        hb.pack_start(self.wid_but_remove, expand=False, fill=False)

        self.widget.pack_start(hb, expand=False, fill=False)
        self.widget.pack_start(gtk.HSeparator(), expand=False, fill=True)

        scroll = gtk.ScrolledWindow()
        scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        scroll.set_placement(gtk.CORNER_TOP_LEFT)
        scroll.set_shadow_type(gtk.SHADOW_NONE)

        self.screen = Screen(attrs['relation'], view_type=['tree'],
                views_preload=attrs.get('views', {}))
        scroll.add_with_viewport(self.screen.widget)
        self.widget.pack_start(scroll, expand=True, fill=True)

#        self.old = None
        self.avail_ids = set()

    def check_exist(self):
        if not len(self.screen.models.models):
            self.avail_ids.clear()
        else:
            for i in self.screen.models.models:
                self.avail_ids.add(i.id)

    def destroy(self):
        self.screen.destroy()
        self.widget.destroy()
        del self.widget

    def _menu_sig_default(self, obj):
        res = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['model'], 'default_get', [self.attrs['name']])
        self.value = res.get(self.attrs['name'], False)

    def _sig_add(self, *args):
        flag=False
        newids=[]
        domain = self._view.modelfield.domain_get(self._view.model)
        context = self._view.modelfield.context_get(self._view.model)

        ids = rpc.session.rpc_exec_auth('/object', 'execute', self.attrs['relation'], 'name_search', self.wid_text.get_text(), domain, 'ilike', context)
        ids = map(lambda x: x[0], ids)
        self.check_exist()
#        if len(ids)<>1:
        win = win_search(self.attrs['relation'], sel_multi=True, ids=ids, context=context, domain=domain, parent=self._window)
        ids = win.go()
            
        if ids == None:
            ids=[]
        if len(self.avail_ids) and len(ids):
            for i in ids:
                if i not in self.avail_ids:
                    newids.append(i)
                    flag=True
            if flag==True:
                ids=newids
            else:
                ids=[]
        self.screen.load(ids)
        for i in ids:
            self.avail_ids.add(i)
        self.screen.display()
        self.wid_text.set_text('')
        self._focus_out()

    def _sig_remove(self, *args):
        rem_id=[]
        self.check_exist()
        rem_id=self.screen.current_view.sel_ids_get()
        for i in rem_id:
            self.avail_ids.remove(i)
        self.screen.remove()
        self.screen.display()
        self._focus_out()

#.........这里部分代码省略.........

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import clear [as 别名]
class win_search(object):
    def __init__(self, model, sel_multi=True, ids=[], context={}, domain = [], parent=None):
        self.model = model
        self.first = True
        self.domain =domain
        self.context = context
        self.context.update(rpc.session.context)
        self.sel_multi = sel_multi
        self.glade = glade.XML(common.terp_path("openerp.glade"),'win_search',gettext.textdomain())
        self.win = self.glade.get_widget('win_search')
        self.win.set_icon(common.OPENERP_ICON)
        if not parent:
            parent = service.LocalService('gui.main').window
        self.parent = parent
        self.win.set_transient_for(parent)

        self.screen = Screen(model, view_type=['tree'], context=self.context, parent=self.win)
        self.view = self.screen.current_view
        self.view.unset_editable()
        sel = self.view.widget_tree.get_selection()

        if not sel_multi:
            sel.set_mode('single')
        else:
            sel.set_mode(gtk.SELECTION_MULTIPLE)
        vp = gtk.Viewport()
        vp.set_shadow_type(gtk.SHADOW_NONE)
        vp.add(self.screen.widget)
        sw = self.glade.get_widget('search_sw')
        sw.add(vp)
        sw.show_all()
        self.view.widget_tree.connect('row_activated', self.sig_activate)
        self.view.widget_tree.connect('button_press_event', self.sig_button)

        self.model_name = model

        view_form = rpc.session.rpc_exec_auth('/object', 'execute', self.model_name, 'fields_view_get', False, 'form', self.context)
        self.form = widget_search.form(view_form['arch'], view_form['fields'], model, parent=self.win)

        self.title = _('OpenERP Search: %s') % self.form.name
        self.title_results = _('OpenERP Search: %s (%%d result(s))') % self.form.name
        self.win.set_title(self.title)
        x, y = self.form.widget.size_request()

        hbox = self.glade.get_widget('search_hbox')
        hbox.pack_start(self.form.widget)
        self.ids = ids
        if self.ids:
            self.reload()
        self.old_search = None
        self.old_offset = self.old_limit = None
        if self.ids:
            self.old_search = []
            self.old_limit = self.form.get_limit()
            self.old_offset = self.form.get_offset()

        self.view.widget.show_all()
        if self.form.focusable:
            self.form.focusable.grab_focus()

    def sig_activate(self, treeview, path, column, *args):
        self.view.widget_tree.emit_stop_by_name('row_activated')
        if not self.sel_multi:
            self.win.response(gtk.RESPONSE_OK)
        return False

    def sig_button(self, view, event):
        if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
            self.win.response(gtk.RESPONSE_OK)
        return False

    def find(self, widget=None, *args):
        limit = self.form.get_limit()
        offset = self.form.get_offset()
        if (self.old_search == self.form.value) and (self.old_limit==limit) and (self.old_offset==offset) and not self.first:
            self.win.response(gtk.RESPONSE_OK)
            return False
        self.first = False
        self.old_offset = offset
        self.old_limit = limit
        v = self.form.value
        v_keys = map(lambda x: x[0], v)
        v += self.domain
        try:
            self.ids = rpc.session.rpc_exec_auth_try('/object', 'execute', self.model_name, 'search', v, offset, limit, 0, self.context)
        except:
            # Try if it is not an old server
            self.ids = rpc.session.rpc_exec_auth('/object', 'execute', self.model_name, 'search', v, offset, limit)
        self.reload()
        self.old_search = self.form.value
        self.win.set_title(self.title_results % len(self.ids))
        return True

    def reload(self):
        self.screen.clear()
        self.screen.load(self.ids)
        sel = self.view.widget_tree.get_selection()
        if sel.get_mode() == gtk.SELECTION_MULTIPLE:
            sel.select_all()

#.........这里部分代码省略.........