Python Screen.display方法代码示例

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import display [as 别名]
class dialog(object):
    def __init__(self, arch, fields, state, name, parent=None):
        buttons = []
        self.states=[]
        default=-1
        if not parent:
            parent = service.LocalService('gui.main').window
        self.dia = gtk.Dialog('OpenERP', parent,
            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
        for x in state:
            but = gtk.Button(x[1])
            but.show()
            if len(x) >= 3:
                icon = gtk.Image()
                icon.set_from_stock(x[2], gtk.ICON_SIZE_BUTTON)
                but.set_image(icon)
            self.dia.add_action_widget(but, len(self.states))
            if len(x) >= 4 and x[3]:
                but.set_flags(gtk.CAN_DEFAULT)
                default = len(self.states)
            self.states.append(x[0])
        if default >= 0:
            self.dia.set_default_response(default)

        val = {}
        for f in fields:
            if 'value' in fields[f]:
                val[f] = fields[f]['value']

        self.screen = Screen('wizard.'+name, view_type=[], window=self.dia, is_wizard=True)
        self.screen.new(default=False)
        self.screen.add_view_custom(arch, fields, display=True)
        self.screen.current_model.set(val)

        x,y = self.screen.screen_container.size_get()
        width, height = parent.get_size()
        self.screen.widget.set_size_request(min(width - 20, x + 20),
                min(height - 60, y + 25))
        self.screen.widget.show()

        self.dia.vbox.pack_start(self.screen.widget)
        self.dia.set_title(self.screen.current_view.title)
        self.dia.show()

    def run(self, datas={}):
        while True:
            res = self.dia.run()
            self.screen.current_view.set_value()
            if self.screen.current_model.validate() or (res<0) or (self.states[res]=='end'):
                break
            self.screen.display()
        if res<len(self.states) and res>=0:
            datas.update(self.screen.get())
            self.dia.destroy()
            return (self.states[res], datas)
        else:
            self.dia.destroy()
            self.screen.destroy()
            return False

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import display [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 display [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 display [as 别名]
class dialog(object):
    def __init__(self, model_name, parent, model=None, attrs=None, model_ctx=None,
            window=None, context=None, readonly=False):

        if attrs is None:
            attrs = {}
        if model_ctx is None:
            model_ctx = {}
        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 ('string' in attrs) and attrs['string']:
            self.dia.set_title(self.dia.get_title() + ' - ' + attrs['string'])
        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(_('Cancel'), gtk.RESPONSE_CANCEL)
        icon = gtk.Image()
        icon.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)
        self.but_cancel.set_image(icon)
        self.but_cancel.add_accelerator('clicked', self.accel_group, gtk.keysyms.Escape, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

        self.but_save_close = self.dia.add_button(_('Save & Close'), gtk.RESPONSE_APPLY)
        icon = gtk.Image()
        icon.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON)
        self.but_save_close.set_image(icon)

        self.but_save_new = self.dia.add_button(_('Save & New'), gtk.RESPONSE_OK)
        icon = gtk.Image()
        icon.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)
        self.but_save_new.set_image(icon)
        self.but_save_new.add_accelerator('clicked', self.accel_group, gtk.keysyms.Return, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

        self.context = context

        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_name, view_type=[], parent=parent,
                             window=self.dia, readonly=readonly,
                             context=context)
        self.screen.models._context.update(model_ctx)
        if not model:
            model = self.screen.new(context=context)
        else:
            self.screen.models.model_add(model)
        self.screen.current_model = model
        if ('views' in attrs) and ('form' in attrs['views']):
            arch = attrs['views']['form']['arch']
            fields = attrs['views']['form']['fields']
            self.screen.add_view(arch, fields, display=True, context=context)
        else:
            self.screen.add_view_id(False, 'form', display=True,
                                    context=context)
        if not model or model.id is None:
            self.screen.make_buttons_readonly()
        vp.add(self.screen.widget)
        x,y = self.screen.screen_container.size_get()
        vp.set_size_request(x,y+30)
        self.dia.show_all()
        self.screen.readonly = readonly
        self.screen.display()

    def new(self):
        model = self.screen.new(context=self.context)
        self.screen.models.model_add(model)
        self.screen.current_model = model
        self.screen.make_buttons_readonly()
        return True

    def run(self, datas={}):
        end = False
        while not end:
            res = self.dia.run()
            if res in(gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT):
                self.screen.current_model.cancel()
            end = (res not in (gtk.RESPONSE_OK, gtk.RESPONSE_APPLY)) or self.screen.current_model.validate()
            if not end:
                self.screen.display()
                self.screen.current_view.set_cursor()

        if res in (gtk.RESPONSE_OK, gtk.RESPONSE_APPLY) :
            self.screen.current_view.set_value()
            model = self.screen.current_model
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
            return False
        if event.keyval in (gtk.keysyms.L, gtk.keysyms.l) and event.state & gtk.gdk.CONTROL_MASK\
            and event.state & gtk.gdk.SHIFT_MASK:
            self.switch_view(widget, event)
            return False

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

    def _on_activate(self, screen, *args):
        self._sig_edit()

    def click_and_action(self, type):
        pos = self.tree_view.pos_get()
        if pos!=None:
            val = self._value[pos]
            id = val.get('id', False)
            obj = service.LocalService('action.main')
            res = obj.exec_keyword(type, {'model':self.model, 'id': id or False, 'ids':[id], 'report_type': 'pdf'})
            return True
        else:
            common.message(_('You have to select a resource !'))
            return False

    def switch_view(self, btn, arg):
        self.screen.make_buttons_readonly(True)
        self.screen.switch_view()

    def _readonly_set(self, value):
        self._readonly = value
        self.eb_new.set_sensitive(not value)
        self.eb_del.set_sensitive(not value)
        self.screen.readonly = value
        self.screen.display()

    def set_disable(self, value):
        self.eb_open.set_sensitive(value)
        self.eb_switch.set_sensitive(value)
        if self._readonly:
            value = not self._readonly
        self.eb_del.set_sensitive(value)

    def _sig_new(self, *args):
        _, event = args
        ctx = dict(self._view.model.expr_eval(self.screen.default_get), **self.context)
        ctx.update(self._view.model.expr_eval('dict(%s)' % self.attrs.get('context', '{}')))
        if event.type in (gtk.gdk.BUTTON_PRESS, gtk.gdk.KEY_PRESS):
            if (self.screen.current_view.view_type=='form') or self.screen.editable_get():
                self.screen.new(context=ctx)
                self.screen.make_buttons_readonly()
                self._readonly = False
                self.screen.current_view.widget.set_sensitive(True)
                self.set_disable(True)
            else:
                ok = True
                dia = dialog(self.attrs['relation'], parent=self._view.model, attrs=self.attrs, model_ctx=self.screen.models._context, window=self._window, readonly=self._readonly, context=ctx)
                while ok:
                    ok, value, res = dia.run()
                    if ok or res == gtk.RESPONSE_APPLY:
                        self.screen.models.model_add(value)
                        value.signal('record-changed', value.parent)
                        self.screen.display()
                        dia.new()
                        self.set_disable(True)
                self.pager.reset_pager()
                dia.destroy()

# 需要导入模块: from widget.screen import Screen [as 别名]
# 或者: from widget.screen.Screen import display [as 别名]
class dialog(object):
    def __init__(self, model, domain=None, context=None, window=None, target=False):
        if domain is None:
            domain = []
        if context is None:
            context = {}

        if not window:
            window = service.LocalService('gui.main').window

        self.dia = gtk.Dialog(_('OpenERP - Link'), 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=None, domain=domain, context=context, window=self.dia, view_type=['form'])
        self.screen.new()
        vp.add(self.screen.widget)

        x,y = self.screen.screen_container.size_get()
        width, height = window.get_size()
        vp.set_size_request(min(width - 20, x + 20),min(height - 60, y + 25))
        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 self.screen.current_model.id
                    else:
                        self.screen.display()
                        self.screen.current_view.set_cursor()
                else:
                    break
            except Exception:
                # Passing all exceptions, most preferably the one of sql_constraint
                pass
        return False

    def destroy(self):
        self.window.present()
        self.dia.destroy()
        self.screen.destroy()

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

#.........这里部分代码省略.........
            else:
                self.page_label.set_text(self.name)
                self.page_label.set_tooltip_text(self.name)
            return result
        return _decorate
    
    def sig_switch_diagram(self, widget=None):
        return self.sig_switch(widget, 'diagram')

    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')

    def sig_switch_graph(self, widget=None):
        return self.sig_switch(widget, 'graph')

    def get_resource(self, widget=None, get_id=None):
        ## This has been done due to virtual ids coming from
        ## crm meeting. like '3-20101012155505' which are not in existence
        ## and needed to be converted to real ids
        if isinstance(get_id, str):
            get_id = int(get_id.split('-')[0])
        all_ids = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'search', [])
        if widget:
            get_id = int(widget.get_value())
        if get_id in all_ids:
            current_ids = self.screen.ids_get()
            if get_id in current_ids:
                self.screen.display(get_id)
            else:
                self.screen.load([get_id])
            self.screen.current_view.set_cursor()
        else:
            if widget:
                common.message(_('Resource ID does not exist for this object!'))

    def get_event(self, widget, event, win):
        if event.keyval in (gtk.keysyms.Return, gtk.keysyms.KP_Enter):
            win.destroy()
            self.get_resource(widget)
            
    @set_tooltips
    def sig_goto(self, *args):
        if not self.modified_save():
            return

        goto_ui = openerp_gtk_builder('openerp.ui', ['dia_goto_id', 'adjustment2'])
        widget = goto_ui.get_object('goto_spinbutton')
        win = goto_ui.get_object('dia_goto_id')
        widget.connect('key_press_event',self.get_event,win)

        win.set_transient_for(self.window)
        win.show_all()

        response = win.run()
        win.destroy()

        if response == gtk.RESPONSE_OK:
            self.get_resource(widget)

    def destroy(self):

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

#.........这里部分代码省略.........
        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')

    def sig_switch_graph(self, widget=None):
        return self.sig_switch(widget, 'graph')
    
    def get_resource(self,widget):
        all_ids = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'search', [])
        get_id = int(widget.get_value())
        if get_id in all_ids:
            current_ids = self.screen.ids_get()
            if get_id in current_ids:
                self.screen.display(get_id)
            else:
                self.screen.load([get_id])    
            self.screen.current_view.set_cursor()
        else:
            common.message(_('Resource ID does not exist for this object!'))    
    
    def get_event(self, widget, event, win):
        if event.keyval in (gtk.keysyms.Return, gtk.keysyms.KP_Enter):
            win.destroy()
            self.get_resource(widget)
        
        
    def sig_goto(self, *args):
        if not self.modified_save():
            return
        
        glade2 = glade.XML(common.terp_path("openerp.glade"),'dia_goto_id',gettext.textdomain())
        widget = glade2.get_widget('goto_spinbutton')
        win = glade2.get_widget('dia_goto_id')
        widget.connect('key_press_event',self.get_event,win)
        
        win.set_transient_for(self.window)
        win.show_all()

        response = win.run()
        win.destroy()
        
        if response == gtk.RESPONSE_OK:
            self.get_resource(widget)
            

    def destroy(self):

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

#.........这里部分代码省略.........
            return False
        if event.keyval in (gtk.keysyms.L, gtk.keysyms.l) and event.state & gtk.gdk.CONTROL_MASK\
            and event.state & gtk.gdk.SHIFT_MASK:
            self.switch_view(widget, event)
            return False

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

    def _on_activate(self, screen, *args):
        self._sig_edit()

    def click_and_action(self, type):
        pos = self.tree_view.pos_get()
        if pos!=None:
            val = self._value[pos]
            id = val.get('id', False)
            obj = service.LocalService('action.main')
            res = obj.exec_keyword(type, {'model':self.model, 'id': id or False, 'ids':[id], 'report_type': 'pdf'})
            return True
        else:
            common.message(_('You have to select a resource !'))
            return False

    def switch_view(self, btn, arg):
        self.screen.make_buttons_readonly(True)
        self.screen.switch_view()

    def _readonly_set(self, value):
        self._readonly = value
        self.eb_new.set_sensitive(not value)
        self.eb_del.set_sensitive(not value)
        self.screen.readonly = value
        self.screen.display()

    def set_disable(self, value):
        self.eb_open.set_sensitive(value)
        self.eb_switch.set_sensitive(value)
        if self._readonly:
            value = not self._readonly
        self.eb_del.set_sensitive(value)
        
    ## This method is specially developed to store old values of 
    ## the modified records.
    def _get_old_values(self, models=None):

        group_model = {}
        model_value = {}
        if models is None:
            models = []
        for o2m_model in models:
            values = o2m_model.value.copy()
            model_value.setdefault(o2m_model, values)
            group_model.setdefault(o2m_model, {})
            for key, val in values.iteritems():
                if isinstance(val, ModelRecordGroup):
                    group_model[o2m_model][key] = val.models[:]
                    del model_value[o2m_model][key]
        return model_value,group_model
    
    ## This method is specially developed to restore old values 
    def _restore_values(self, modified_model_values, group_model):
        for model, value in modified_model_values.iteritems():
            model.set(value, modified=True)
            for f_name, models in group_model.get(model, {}):
                model.value[f_name].clear()

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

#.........这里部分代码省略.........
            self._sig_edit(widget, event)
            return False
        if event.keyval in (gtk.keysyms.L, gtk.keysyms.l) and event.state & gtk.gdk.CONTROL_MASK\
            and event.state & gtk.gdk.SHIFT_MASK:
            self.switch_view(widget, event)
            return False

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

    def _on_activate(self, screen, *args):
        self._sig_edit()

    def click_and_action(self, type):
        pos = self.tree_view.pos_get()
        if pos!=None:
            val = self._value[pos]
            id = val.get('id', False)
            obj = service.LocalService('action.main')
            res = obj.exec_keyword(type, {'model':self.model, 'id': id or False, 'ids':[id], 'report_type': 'pdf'})
            return True
        else:
            common.message(_('You have to select a resource !'))
            return False

    def switch_view(self, btn, arg):
        self.screen.switch_view()

    def _readonly_set(self, value):
        self._readonly = value
        self.eb_new.set_sensitive(not value)
        self.eb_del.set_sensitive(not value)
        self.screen.readonly = value
        self.screen.display()

    def _sig_new(self, *args):
        _, event = args
        ctx = self._view.model.expr_eval(self.screen.default_get)
        ctx.update(self._view.model.expr_eval('dict(%s)' % self.attrs.get('context', '')))
        if event.type in (gtk.gdk.BUTTON_PRESS, gtk.gdk.KEY_PRESS):
            if (self.screen.current_view.view_type=='form') or self.screen.editable_get():
                self.screen.new(context=ctx)
                self._readonly = False
                self.screen.current_view.widget.set_sensitive(True)
            else:
                ok = 1
                dia = dialog(self.attrs['relation'], parent=self._view.model, attrs=self.attrs, model_ctx=self.screen.models._context, default_get_ctx=ctx, window=self._window, readonly=self._readonly)
                while ok:
                    ok, value = dia.run()
                    if ok:
                        self.screen.models.model_add(value)
                        value.signal('record-changed', value.parent)
                        self.screen.display()
                        dia.new()
                dia.destroy()

    def _sig_edit(self, *args):
        if self.screen.current_model:
            dia = dialog(self.attrs['relation'], parent=self._view.model,  model=self.screen.current_model, attrs=self.attrs, window=self._window, readonly=self._readonly)
            ok, value = dia.run()
            dia.destroy()

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

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

#.........这里部分代码省略.........
            and event.state & gtk.gdk.CONTROL_MASK
            and event.state & gtk.gdk.SHIFT_MASK
        ):
            self.switch_view(widget, event)
            return False

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

    def _on_activate(self, screen, *args):
        self._sig_edit()

    def click_and_action(self, type):
        pos = self.tree_view.pos_get()
        if pos != None:
            val = self._value[pos]
            id = val.get("id", False)
            obj = service.LocalService("action.main")
            res = obj.exec_keyword(type, {"model": self.model, "id": id or False, "ids": [id], "report_type": "pdf"})
            return True
        else:
            common.message(_("You have to select a resource !"))
            return False

    def switch_view(self, btn, arg):
        self.screen.make_buttons_readonly(True)
        self.screen.switch_view()

    def _readonly_set(self, value):
        self._readonly = value
        self.eb_new.set_sensitive(not value)
        self.eb_del.set_sensitive(not value)
        self.screen.readonly = value
        self.screen.display()

    def set_disable(self, value):
        self.eb_open.set_sensitive(value)
        self.eb_switch.set_sensitive(value)
        if self._readonly:
            value = not self._readonly
        self.eb_del.set_sensitive(value)

    def _sig_new(self, *args):
        _, event = args
        ctx = dict(self._view.model.expr_eval(self.screen.default_get), **self.context)
        ctx.update(self._view.model.expr_eval("dict(%s)" % self.attrs.get("context", "{}")))
        if event.type in (gtk.gdk.BUTTON_PRESS, gtk.gdk.KEY_PRESS):
            if (self.screen.current_view.view_type == "form") or self.screen.editable_get():
                self.screen.new(context=ctx)
                self.screen.make_buttons_readonly()
                self._readonly = False
                self.screen.current_view.widget.set_sensitive(True)
                self.set_disable(True)
            else:
                ok = True
                dia = dialog(
                    self.attrs["relation"],
                    parent=self._view.model,
                    attrs=self.attrs,
                    model_ctx=self.screen.models._context,
                    window=self._window,
                    readonly=self._readonly,
                    context=ctx,
                )
                while ok:
                    ok, value, res = dia.run()