Python Screen.load方法代码示例

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
class win_preference(object):
    def __init__(self, parent=None):
        self.ui = openerp_gtk_builder('openerp.ui', ['win_preference'])
        self.win = self.ui.get_object('win_preference')
        self.win.set_icon(common.OPENERP_ICON)
        if not parent:
            parent = service.LocalService('gui.main').window
        self.win.set_transient_for(parent)
        self.parent = parent

        action_id = rpc.session.rpc_exec_auth('/object', 'execute', 'res.users', 'action_get', {})
        action = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.actions.act_window', 'read', [action_id], False, rpc.session.context)[0]

        view_ids = []
        if action.get('views', []):
            view_ids = [x[0] for x in action['views']]
        elif action.get('view_id', False):
            view_ids = [action['view_id'][0]]

        self.screen = Screen('res.users', view_type=[], window=parent)
        self.screen.add_view_id(view_ids[0], 'form', display=True)
        self.screen.load([rpc.session.uid])
        self.screen.display(rpc.session.uid)

        vbox = self.ui.get_object('preference_vbox')
        vbox.pack_start(self.screen.widget)

        self.win.set_title(_('Preferences'))
        self.win.show_all()

    def run(self, datas={}):
        lang = rpc.session.context.get('lang', 'en_US')
        end = False
        while not end:
            res = self.win.run()
            end = (res != gtk.RESPONSE_OK) or self.screen.current_model.validate()
            if not end:
                self.screen.display()
                self.screen.current_view.set_cursor()
        if res == gtk.RESPONSE_OK:
            values = self.screen.get()
            rpc.session.rpc_exec_auth('/object', 'execute', 'res.users', 'write', [rpc.session.uid], values)
            rpc.session.context_reload()
            new_lang = rpc.session.context.get('lang', 'en_US')
            if lang != new_lang:
                common.message(_("The default language of the interface has been modified, do not forget to restart " \
                                 "the client to have the interface in your language"),
                               _("Default language modified !"), parent=self.win)
        self.parent.present()
        self.win.destroy()
        return True

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
 def _click_and_relate(self, action, value, model):
     data={}
     context={}
     act=action.copy()
     if not(value):
         common.message(_('You must select a record to use the relation !'))
         return False
     from widget.screen import Screen
     screen = Screen(model)
     screen.load([value])
     act['domain'] = screen.current_model.expr_eval(act['domain'], check_load=False)
     act['context'] = str(screen.current_model.expr_eval(act['context'], check_load=False))
     obj = service.LocalService('action.main')
     value = obj._exec_action(act, data, context)
     return value

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
 def click_and_relate(self, action):
     data={}
     context={}
     act=action.copy()
     id = self._view.modelfield.get(self._view.model)
     if not(id):
         common.message(_('You must select a record to use the relation !'))
         return False
     screen = Screen(self.attrs['relation'])
     screen.load([id])
     act['domain'] = screen.current_model.expr_eval(act['domain'], check_load=False)
     act['context'] = str(screen.current_model.expr_eval(act['context'], check_load=False))
     obj = service.LocalService('action.main')
     value = obj._exec_action(act, data, context)
     return value

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [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('populate-popup', 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)

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

        self.context = tools.expr_eval(attrs.get('context',"{}"))

        self.screen = Screen(attrs['relation'], view_type=['tree'],
                views_preload=attrs.get('views', {}),
                row_activate=self.row_activate,
                limit=pager.DEFAULT_LIMIT, context=self.context)
        self.screen.signal_connect(self, 'record-message', self._sig_label)
        self.screen.type = 'many2many'
        self.model = None
        self.model_field = None
        self.name = attrs['name']
        self.pager = pager(object=self, relation=attrs['relation'], screen=self.screen)

        # Button Previous Page
        self.eb_prev_page = self.pager.create_event_box(_('Previous Page'), self._sig_prev_page, 'gtk-goto-first')
        hb.pack_start(self.eb_prev_page, expand=False, fill=False)

        # Button Previous Record
        self.eb_pre = self.pager.create_event_box(_('Previous Record'), self._sig_previous, 'gtk-go-back')
        hb.pack_start(self.eb_pre, expand=False, fill=False)

        # Record display
        self.label = gtk.Label('(0,0)')
        hb.pack_start(self.label, expand=False, fill=False)

        # Button Next
        self.eb_next = self.pager.create_event_box(_('Next Record'), self._sig_next, 'gtk-go-forward')
        hb.pack_start(self.eb_next, expand=False, fill=False)

        # Button Next Page
        self.eb_next_page = self.pager.create_event_box(_('Next Page'), self._sig_next_page, 'gtk-goto-last')
        hb.pack_start(self.eb_next_page, expand=False, fill=False)

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

        # LIMIT COMBO
        self.cb = self.pager.create_combo_box(_('Choose Limit'), self.limit_changed)
        hb.pack_start(self.cb, 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_property('height-request', 200)
        scroll.set_placement(gtk.CORNER_TOP_LEFT)
        scroll.set_shadow_type(gtk.SHADOW_NONE)

        scroll.add_with_viewport(self.screen.widget)
        self.widget.pack_start(scroll, expand=True, fill=True)

    def row_activate(self, screen):
        gui_window = service.LocalService('gui.window')
        domain = self._view.modelfield.domain_get(self._view.model)
        dia = dialog(screen.name, id=screen.id_get(), attrs=self.attrs, domain=domain, window=screen.window,context=screen.context,target=False, view_type=['form'])
        if dia.dia.get_has_separator():
            dia.dia.set_has_separator(False)
        ok, value = dia.run()
        if ok:
            screen.current_model.validate_set()
            screen.current_view.set_value()
        dia.destroy()

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

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

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
class form(object):
    def __init__(self, model, res_id=False, domain=None, view_type=None,
            view_ids=None, window=None, context=None, name=False, help={}, limit=100,
            auto_refresh=False, auto_search=True, search_view=None):
        if not view_type:
            view_type = ['form','tree']
        if domain is None:
            domain = []
        if view_ids is None:
            view_ids = []
        if context is None:
            context = {}

        fields = {}
        self.model = model
        self.window = window
        self.previous_action = None
        self.ui = openerp_gtk_builder('openerp.ui', ['win_form_container'])
        self.widget = self.ui.get_object('win_form_container')
        self.widget.show_all()
        self.fields = fields
        self.domain = domain
        self.context = context
        self.page_label = None
        self.screen = Screen(self.model, view_type=view_type,
                context=self.context, view_ids=view_ids, domain=domain,help=help,
                hastoolbar=options.options['form.toolbar'], hassubmenu=options.options['form.submenu'],
                show_search=True, window=self.window, limit=limit, readonly=bool(auto_refresh), auto_search=auto_search, search_view=search_view)
        self.screen.signal_connect(self, 'record-message', self._record_message)
        self.screen.widget.show()
        oregistry.add_receiver('misc-message', self._misc_message)

        if not name:
            self.name = self.screen.current_view.title
        else:
            self.name = name
        vp = gtk.Viewport()
        vp.set_shadow_type(gtk.SHADOW_NONE)
        vp.add(self.screen.widget)
        vp.show()
        self.sw = gtk.ScrolledWindow()
        self.sw.set_shadow_type(gtk.SHADOW_NONE)
        self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.sw.add(vp)
        self.sw.show()

        self.has_backup = False
        self.backup = {}

        self.widget.pack_start(self.sw)
        self.handlers = {
            'but_new': self.sig_new,
            'but_copy': self.sig_copy,
            'but_save': self.sig_save,
            'but_save_as': self.sig_save_as,
            'but_import': self.sig_import,
            'but_print_repeat': self.sig_print_repeat,
            'but_remove': self.sig_remove,
            'but_search': self.sig_search,
            'but_previous': self.sig_previous,
            'but_next': self.sig_next,
            'but_goto_id': self.sig_goto,
            'but_log': self.sig_logs,
            'but_print': self.sig_print,
            'but_reload': self.sig_reload,
            'but_print_html': self.sig_print_html,
            'but_action': self.sig_action,
            'but_switch': self.sig_switch,
            'but_attach': self.sig_attach,
            'but_close': self.sig_close,
        }
        if 'tree' in view_type:
            self.handlers['radio_tree'] = self.sig_switch_tree
        if 'form' in view_type:
            self.handlers['radio_form'] =  self.sig_switch_form
        if 'graph' in view_type:
            self.handlers['radio_graph'] =  self.sig_switch_graph
        if 'calendar' in view_type:
            self.handlers['radio_calendar'] =  self.sig_switch_calendar
        if 'diagram' in view_type:
            self.handlers['radio_diagram'] =  self.sig_switch_diagram
        if res_id:
            if isinstance(res_id, (int, long,)):
                res_id = [res_id]
            self.screen.load(res_id)
        else:
            if self.screen.current_view.view_type == 'form':
                self.sig_new(autosave=False)
            if self.screen.current_view.view_type in ('tree', 'graph', 'calendar'):
                self.screen.search_filter()
        if auto_refresh and int(auto_refresh):
            gobject.timeout_add(int(auto_refresh) * 1000, self.sig_reload)
    
    def set_tooltips(fn):
        def _decorate(self, *args, **kws):
            result = fn(self, *args, **kws)
            if self.screen.current_view.view_type == 'form':
                tips= unicode(self.screen.current_model and self.screen.current_model.value.get('name') or self.name)
                tooltips = tips == self.name and self.name or  self.name + ': ' + tips[:64]
                lable = tips == self.name and self.name or  self.name + ': ' + tips[:6]
#.........这里部分代码省略.........

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
class dialog(object):
    def __init__(self, model, id=None, attrs=None ,domain=None, context=None, window=None, view_ids=None, target=False,view_type=['form'], help={}):
        if attrs is None:
            attrs = {}
        if domain is None:
            domain = []
        if context is None:
            context = {}
        if not window:
            window = service.LocalService('gui.main').window

        self.dia = gtk.Dialog('OpenERP', window,
                gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT)
        self.window = window
        if not target:
            self.dia.set_property('default-width', 760)
            self.dia.set_property('default-height', 500)
            self.dia.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
            self.dia.set_icon(common.OPENERP_ICON)

            self.accel_group = gtk.AccelGroup()
            self.dia.add_accel_group(self.accel_group)

            self.but_cancel = self.dia.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
            self.but_cancel.add_accelerator('clicked', self.accel_group, gtk.keysyms.Escape, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

            self.but_ok = self.dia.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
            self.but_ok.add_accelerator('clicked', self.accel_group, gtk.keysyms.Return, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

        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.dia.vbox.pack_start(scroll, expand=True, fill=True)

        vp = gtk.Viewport()
        vp.set_shadow_type(gtk.SHADOW_NONE)
        scroll.add(vp)
        self.screen = Screen(model, view_ids=view_ids, domain=domain, context=context, window=self.dia, view_type=view_type, help=help)
        if id:
            self.screen.load([id])
        else:
            self.screen.new()

        if ('string' in attrs) and attrs['string']:
            self.dia.set_title(self.dia.get_title() + ' - ' + attrs['string'])
        elif self.screen.current_view:
            self.dia.set_title(self.dia.get_title() + ' - ' + self.screen.current_view.title)
        vp.add(self.screen.widget)

        width, height = self.screen.screen_container.size_get()
        window_width, window_height = window.get_size()
        dia_width, dia_height = self.dia.get_size()

        widget_width = min(window_width - 20, max(dia_width, width + 30))
        if target:
            widget_height = min(window_height - 60, height + 10)
        else:
            widget_height = min(window_height - 60, height + 20)
        vp.set_size_request(widget_width, widget_height)
        self.dia.show_all()
        self.screen.display()

    def run(self, datas={}):
        while True:
            try:
                res = self.dia.run()
                if res == gtk.RESPONSE_OK:
                    if self.screen.current_model.validate() and self.screen.save_current():
                        return (True, self.screen.current_model.name_get())
                    else:
                        self.screen.display()
                        self.screen.current_view.set_cursor()
                else:
                    break
            except Exception,e:
                # Passing all exceptions, most preferably the one of sql_constraint
                pass
        return (False, False)

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [as 别名]
class form(object):
    def __init__(self, model, res_id=False, domain=None, view_type=None,
            view_ids=None, window=None, context=None, name=False, limit=80,
            auto_refresh=False):
        if not view_type:
            view_type = ['form','tree']
        if domain is None:
            domain = []
        if view_ids is None:
            view_ids = []
        if context is None:
            context = {}

        fields = {}
        self.model = model
        self.window = window
        self.previous_action = None
        self.glade = glade.XML(common.terp_path("openerp.glade"),'win_form_container',gettext.textdomain())
        self.widget = self.glade.get_widget('win_form_container')
        self.widget.show_all()
        self.fields = fields
        self.domain = domain
        self.context = context

        self.screen = Screen(self.model, view_type=view_type,
                context=self.context, view_ids=view_ids, domain=domain,
                hastoolbar=options.options['form.toolbar'], show_search=True,
                window=self.window, limit=limit, readonly=bool(auto_refresh))
        self.screen.signal_connect(self, 'record-message', self._record_message)
        self.screen.widget.show()
        oregistry.add_receiver('misc-message', self._misc_message)

        if not name:
            self.name = self.screen.current_view.title
        else:
            self.name = name
        vp = gtk.Viewport()
        vp.set_shadow_type(gtk.SHADOW_NONE)
        vp.add(self.screen.widget)
        vp.show()
        self.sw = gtk.ScrolledWindow()
        self.sw.set_shadow_type(gtk.SHADOW_NONE)
        self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.sw.add(vp)
        self.sw.show()

        self.has_backup = False
        self.backup = {}

        self.widget.pack_start(self.sw)
        self.handlers = {
            'but_new': self.sig_new,
            'but_copy': self.sig_copy,
            'but_save': self.sig_save,
            'but_save_as': self.sig_save_as,
            'but_import': self.sig_import,
            'but_print_repeat': self.sig_print_repeat,
            'but_remove': self.sig_remove,
            'but_search': self.sig_search,
            'but_previous': self.sig_previous,
            'but_next': self.sig_next,
            'but_goto_id': self.sig_goto,
            'but_log': self.sig_logs,
            'but_print': self.sig_print,
            'but_reload': self.sig_reload,
            'but_print_html': self.sig_print_html,
            'but_action': self.sig_action,
            'but_switch': self.sig_switch,
            'but_attach': self.sig_attach,
            'but_close': self.sig_close,
        }
        if 'tree' in view_type:
            self.handlers['radio_tree'] = self.sig_switch_tree
        if 'form' in view_type:
            self.handlers['radio_form'] =  self.sig_switch_form
        if 'graph' in view_type:
            self.handlers['radio_graph'] =  self.sig_switch_graph
        if 'calendar' in view_type:
            self.handlers['radio_calendar'] =  self.sig_switch_calendar
        if res_id:
            if isinstance(res_id, (int, long,)):
                res_id = [res_id]
            self.screen.load(res_id)
        else:
            if self.screen.current_view.view_type == 'form':
                self.sig_new(autosave=False)
            if self.screen.current_view.view_type in ('tree', 'graph', 'calendar'):
                self.screen.search_filter()

        if auto_refresh and int(auto_refresh):
            gobject.timeout_add(int(auto_refresh) * 1000, self.sig_reload)

    def sig_switch_form(self, widget=None):
        return self.sig_switch(widget, 'form')

    def sig_switch_tree(self, widget=None):
        return self.sig_switch(widget, 'tree')

    def sig_switch_calendar(self, widget=None):
        return self.sig_switch(widget, 'calendar')
#.........这里部分代码省略.........

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import load [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 load [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 load [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 load [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()

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