def on_start_editing(self, event, widget, path, background_area, cell_area, flags): if not self.__is_visible(widget, cell_area): return if (event is None) or ((event.type == gtk.gdk.BUTTON_PRESS) \ or (event.type == gtk.gdk.KEY_PRESS \ and event.keyval == gtk.keysyms.space)): self.clicking = True widget.queue_draw() gtk.main_iteration() model=widget.screen.current_model if widget.screen.current_model.validate(): id = widget.screen.save_current() if not self.attrs.get('confirm',False) or \ common.sur(self.attrs['confirm']): button_type = self.attrs.get('type', 'workflow') if button_type == 'workflow': result = rpc.session.rpc_exec_auth('/object', 'exec_workflow', widget.screen.name, self.attrs['name'], id) if type(result)==type({}): if result['type']== 'ir.actions.act_window_close': widget.screen.window.destroy() else: datas = {} obj = service.LocalService('action.main') obj._exec_action(result,datas) elif button_type == 'object': if not id: return result = rpc.session.rpc_exec_auth( '/object', 'execute', widget.screen.name, self.attrs['name'], [id], model.context_get() ) datas = {} obj = service.LocalService('action.main') obj._exec_action(result,datas,context=widget.screen.context) elif button_type == 'action': obj = service.LocalService('action.main') action_id = int(self.attrs['name']) obj.execute(action_id, {'model':widget.screen.name, 'id': id or False, 'ids': id and [id] or [], 'report_type': 'pdf'}, context=widget.screen.context) else: raise Exception, 'Unallowed button type' widget.screen.reload() else: widget.screen.display() self.emit("clicked", path) def timeout(self, widget): self.clicking = False widget.queue_draw() gobject.timeout_add(60, timeout, self, widget)
def button_clicked(self, widget): model = self.form.screen.current_model self.form.set_value() button_type = self.attrs.get('special', '') if button_type == 'cancel': self.form.screen.window.destroy() if 'name' in self.attrs.keys(): type_button = self.attrs.get('type', 'object') if type_button == 'action': obj = service.LocalService('action.main') action_id = int(self.attrs['name']) context_action = self.form.screen.context.copy() if 'context' in self.attrs: context_action.update( self.form.screen.current_model.expr_eval( self.attrs['context'], check_load=False)) obj.execute(action_id, { 'model': self.form.screen.name, 'id': False, 'ids': [], 'report_type': 'pdf' }, context=context_action) elif type_button == 'object': result = rpc.session.rpc_exec_auth('/object', 'execute', self.form.screen.name, self.attrs['name'], [], model.context_get()) datas = {} obj = service.LocalService('action.main') obj._exec_action(result, datas, context=self.form.screen.context) else: raise Exception, 'Unallowed button type' elif model.validate(): id = self.form.screen.save_current() model.get_button_action(self.form.screen, id, self.attrs) self.warn('misc-message', '') else: common.warning(_('Invalid form, correct red fields !'), _('Error !'), parent=self.form.screen.current_view.window) self.warn('misc-message', _('Invalid form, correct red fields !'), "red") self.form.screen.display() self.form.screen.current_view.set_cursor()
def selection(title, values, alwaysask=False, parent=None): if not values or len(values) == 0: return None elif len(values) == 1 and (not alwaysask): key = values.keys()[0] return (key, values[key]) xml = glade.XML(terp_path("openerp.glade"), "win_selection", gettext.textdomain()) win = xml.get_widget('win_selection') if not parent: parent = service.LocalService('gui.main').window win.set_icon(OPENERP_ICON) win.set_transient_for(parent) label = xml.get_widget('win_sel_title') if title: label.set_text(title) list = xml.get_widget('win_sel_tree') list.get_selection().set_mode('single') cell = gtk.CellRendererText() column = gtk.TreeViewColumn("Widget", cell, text=0) list.append_column(column) list.set_search_column(0) model = gtk.ListStore(gobject.TYPE_STRING) keys = values.keys() keys.sort() for val in keys: model.append([val]) list.set_model(model) list.connect('row-activated', lambda x, y, z: win.response(gtk.RESPONSE_OK) or True) ok = False while not ok: response = win.run() ok = True res = None if response == gtk.RESPONSE_OK: sel = list.get_selection().get_selected() if sel: (model, iter) = sel if iter: res = model.get_value(iter, 0) try: res = (res, values[res.decode('utf8')]) except: res = (res, values[res]) else: ok = False else: ok = False else: res = None parent.present() win.destroy() return res
def __init__(self, parent=None): self.glade = glade.XML(common.terp_path("openerp.glade"), 'win_preference', gettext.textdomain()) self.win = self.glade.get_widget('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.glade.get_widget('preference_vbox') vbox.pack_start(self.screen.widget) self.win.set_title(_('Preferences')) self.win.show_all()
def sig_action(self, keyword='client_action_multi', previous=False, report_type='pdf', adds={}): ids = self.screen.ids_get() if self.screen.current_model: id = self.screen.current_model.id else: id = False if self.screen.current_view.view_type == 'form': id = self.screen.save_current() if not id: return False ids = [id] if self.screen.current_view.view_type == 'tree': sel_ids = self.screen.current_view.sel_ids_get() if sel_ids: ids = sel_ids if len(ids): obj = service.LocalService('action.main') if previous and self.previous_action: obj._exec_action(self.previous_action[1], {'model':self.screen.resource, 'id': id or False, 'ids':ids, 'report_type': report_type}, self.screen.context) else: res = obj.exec_keyword(keyword, {'model':self.screen.resource, 'id': id or False, 'ids':ids, 'report_type': report_type}, adds, self.screen.context) if res: self.previous_action = res self.sig_reload(test_modified=False) else: self.message_state(_('You must select one or several records !'),color='red')
def sig_action(self, widget=None, keyword='tree_but_action', id=None, report_type='pdf', warning=True): ids = self.ids_get() if not id and ids and len(ids): id = ids[0] if id: ctx = self.context.copy() if 'active_ids' in ctx: del ctx['active_ids'] if 'active_id' in ctx: del ctx['active_id'] obj = service.LocalService('action.main') return obj.exec_keyword(keyword, { 'model': self.model, 'id': id, 'ids': ids, 'report_type': report_type, 'window': self.window }, context=ctx, warning=warning) else: common.message(_('No resource selected!')) return False
def __init__(self, field_name, treeview=None, attrs=None, window=None): self.field_name = field_name self.attrs = attrs or {} self.renderer = gtk.CellRendererProgress() self.treeview = treeview if not window: window = service.LocalService('gui.main').window self.window = window
def sig_new(self, widget=None): #datas = {'res_model':self.model, 'domain_field': self.domain[0], 'domain_value': self.id_get(), 'res_id':None} # domain = self.domain # if self.domain: # id = self.id_get() # if id: # domain=(domain[0],id) obj = service.LocalService('gui.window') obj.create(None, self.model, None, self.domain)
def sig_chroot(self, widget=None): ids = self.ids_get() if len(ids) and self.domain: id = ids[0] datas = {'domain_field': self.domain[0][0], 'domain_value': id[0], 'res_id':id[0]} obj = service.LocalService('gui.window') obj.create(self.view, self.model, id[0], (self.domain[0],id[0]) ) else: common.message(_('Unable to chroot: no tree resource selected'))
def sur(msg, parent=None): if not parent: parent=service.LocalService('gui.main').window sur = glade.XML(terp_path("openerp.glade"), "win_sur",gettext.textdomain()) win = sur.get_widget('win_sur') win.set_transient_for(parent) win.show_all() l = sur.get_widget('lab_question') l.set_text(msg) if not parent: parent=service.LocalService('gui.main').window win.set_transient_for(parent) win.set_icon(OPENERP_ICON) response = win.run() parent.present() win.destroy() return response == gtk.RESPONSE_OK
def concurrency(resource, id, context, parent=None): dia = glade.XML(common.terp_path("openerp.glade"),'dialog_concurrency_exception',gettext.textdomain()) win = dia.get_widget('dialog_concurrency_exception') if not parent: parent=service.LocalService('gui.main').window win.set_transient_for(parent) win.set_icon(OPENERP_ICON) res= win.run() parent.present() win.destroy() if res == gtk.RESPONSE_OK: return True if res == gtk.RESPONSE_APPLY: obj = service.LocalService('gui.window') obj.create(False, resource, id, [], 'form', None, context,'form,tree') return False
def click_and_action(self, type): id = self._view.modelfield.get(self._view.model) obj = service.LocalService('action.main') res = obj.exec_keyword( type, { 'model': self.model_type, 'id': id or False, 'ids': [id], 'report_type': 'pdf' }) return True
def __init__(self, model, sel_multi=True, ids=[], context={}, domain=[], parent=None): self.model = model self.sel_multi = sel_multi self.ids = ids self.ctx = context 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'], show_search=True, domain=domain, context=context, parent=self.win, win_search=True) self.view = self.screen.current_view if self.screen.filter_widget.focusable: self.screen.filter_widget.focusable.grab_focus() self.title = _('OpenERP Search: %s') % self.screen.name self.title_results = _('OpenERP Search: %s (%%d result(s))') % ( self.screen.name, ) self.win.set_title(self.title) 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) self.view.widget_tree.connect('row_activated', self.sig_activate) self.view.widget_tree.connect('button_press_event', self.sig_button) self.screen.win_search_callback = self.update_title 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.wid = self.glade.get_widget('win_search_vbox') self.wid.pack_start(self.sw) self.wid.show_all()
def __init__(self, field_name, treeview=None, attrs=None, window=None): self.field_name = field_name self.attrs = attrs or {} self.renderer1 = gtk.CellRendererText() # TODO: Review this, not always editable self.renderer1.set_property('editable', True) self.renderer = date_renderer.DecoratorRenderer(self.renderer1, date_renderer.date_callback(treeview), self.display_format) self.treeview = treeview if not window: window = service.LocalService('gui.main').window self.window = window
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 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 search_filter(self, exact_count=True, *args): ctx = self.context.copy() ctx.update({'estimate_search_count': not exact_count}) v = self.filter_widget.value filter_keys = [key for key, _, _ in v] for element in self.domain: if not isinstance(element, tuple): # Filtering '|' symbol v.append(element) else: (key, op, value) = element if key not in filter_keys and not (key == 'active' and self.context.get( 'active_test', False)): v.append((key, op, value)) # v.extend((key, op, value) for key, op, value in domain if key not in filter_keys and not (key=='active' and self.context.get('active_test', False))) if self.latest_search != v: self.filter_widget.set_offset(0) limit = self.filter_widget.get_limit() limit = self.search_limit_add() offset = self.filter_widget.get_offset() offset = self.search_offset_add() self.latest_search = v ids = rpc.session.rpc_exec_auth('/object', 'execute', self.name, 'search', v, offset, limit, 0, ctx) if len(ids) < limit: self.search_count = len(ids) exact_count = True else: self.search_count = rpc.session.rpc_exec_auth_try( '/object', 'execute', self.name, 'search_count', v, ctx) if not exact_count: estimate_min_value = options.options[ 'client.estimate_min_value'] exact_count = self.search_count < estimate_min_value self.update_scroll() self.clear() self.load(ids) main = service.LocalService('gui.main') id = main.sb_requests.get_context_id('message') if exact_count: self.write_to_stat_state('') return exact_count
def switch_view(self, screen=None, mode=False): if isinstance(self.current_model, group_record) and mode != 'graph': return if mode == 'calendar' and self.dummy_cal: mode = 'dummycalendar' self.current_view.set_value() self.fields = {} if self.current_model and self.current_model not in self.models.models: self.current_model = None if mode: ok = False for vid in range(len(self.views)): if self.views[vid].view_type == mode: self.__current_view = vid ok = True break if len(self.view_to_load) and mode in self.view_to_load: self.load_view_to_load(mode=mode) for vid in range(len(self.views)): if self.views[vid].view_type == mode: self.__current_view = vid ok = True break if not ok: self.__current_view = len(self.views) - 1 else: if len(self.view_to_load): self.load_view_to_load() self.__current_view = len(self.views) - 1 else: self.__current_view = (self.__current_view + 1) % len( self.views) self.fields = self.view_fields.get(self.__current_view, self.fields) # Switch the fields # TODO: maybe add_fields_custom is needed instead of add_fields on some cases self.models.add_fields(self.fields, self.models) # Switch the model fields too widget = self.current_view.widget self.screen_container.set(self.current_view.widget) if self.current_model: self.current_model.validate_set() elif self.current_view.view_type == 'form': self.new() self.display() self.current_view.set_cursor() main = service.LocalService('gui.main') if main: main.sb_set()
def sig_attach(self, widget=None): id = self.id_get() if id: ctx = self.context.copy() ctx.update(rpc.session.context) action = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.attachment', 'action_get', ctx) action['domain'] = [('res_model', '=', self.model), ('res_id', '=', id)] ctx['default_res_model'] = self.model ctx['default_res_id'] = id obj = service.LocalService('action.main') obj._exec_action(action, {}, ctx) else: self.message_state(_('No record selected ! You can only attach to existing record.'), color='red') return True
def create(self, view_ids, model, res_id=False, domain=None, view_type='form', window=None, context=None, mode=None, name=False,help={}, limit=100, auto_refresh=False, auto_search=True, search_view=None): if context is None: context = {} context.update(rpc.session.context) if view_type=='form': mode = (mode or 'form,tree').split(',') win = form.form(model, res_id, domain, view_type=mode, view_ids = (view_ids or []), window=window, context=context, name=name, help=help, limit=limit, auto_refresh=auto_refresh, auto_search=auto_search, search_view=search_view) spool = service.LocalService('spool') spool.publish('gui.window', win, {}) elif view_type=='tree': if view_ids and view_ids[0]: view_base = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.ui.view', 'read', [view_ids[0]], ['model', 'type'], context)[0] model = view_base['model'] view = rpc.session.rpc_exec_auth('/object', 'execute', view_base['model'], 'fields_view_get', view_ids[0], view_base['type'],context) else: view = rpc.session.rpc_exec_auth('/object', 'execute', model, 'fields_view_get', False, view_type, context) win = tree.tree(view, model, res_id, domain, context,help=help, window=window, name=name) spool = service.LocalService('spool') spool.publish('gui.window', win, {}) else: import logging log = logging.getLogger('view') log.error('unknown view type: '+view_type) del log
def sig_edit(self, widget=None): id = False ids = self.ids_get() if ids: id = ids[0] elif self.tree_res.toolbar: wid = self.glade.get_widget('tree_toolbar') for w in wid.get_children(): if w.get_active(): id = w.get_data('id') if id: obj = service.LocalService('gui.window') obj.create(None, self.model, id, self.domain) else: common.message(_('No resource selected!'))
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
def sig_action(self, keyword='client_action_multi', previous=False, report_type='pdf', adds={}): ids = self.screen.ids_get() group_by = self.screen.context.get('group_by') if self.screen.current_model: id = self.screen.current_model.id else: id = False if self.screen.current_view.view_type == 'form': id = self.screen.save_current() if not id: return False ids = [id] if self.screen.current_view.view_type == 'tree': self.modified_save() sel_ids = self.screen.sel_ids_get() if sel_ids: ids = sel_ids if len(ids) or group_by: obj = service.LocalService('action.main') data = { 'model': self.screen.resource, 'id': id or False, 'ids': ids, 'report_type': report_type, '_domain': self.screen.domain } # When group by header is selected add it's children as a active_ids if group_by: self.screen.context.update({ 'active_id': id, 'active_ids': ids }) if previous and self.previous_action: obj._exec_action(self.previous_action[1], data, self.screen.context) else: res = obj.exec_keyword(keyword, data, adds, self.screen.context) if res: self.previous_action = res self.sig_reload(test_modified=False) else: self.message_state(_('You must select one or several records !'), color='red')
def field_pref_set(field, name, model, value, dependance=None, window=None): win_gl = glade.XML(common.terp_path('openerp.glade'), 'win_field_pref', gettext.textdomain()) if dependance is None: dependance = [] if window is None: window = service.LocalService('gui.main').window win = win_gl.get_widget('win_field_pref') win.set_transient_for(window) win.set_icon(common.OPENERP_ICON) ent = win_gl.get_widget('ent_field') ent.set_text(name) ent = win_gl.get_widget('ent_domain') ent.set_text(model) ent = win_gl.get_widget('ent_value') ent.set_text((value and str(value)) or '/') radio = win_gl.get_widget('radio_user_pref') vbox = win_gl.get_widget('pref_vbox') widgets = {} addwidget = False for (fname, fvalue, rname, rvalue) in dependance: if rvalue: addwidget = True widget = gtk.CheckButton(fname + ' = ' + str(rname)) widgets[(fvalue, rvalue)] = widget vbox.pack_start(widget) if not len(dependance) or not addwidget: vbox.pack_start(gtk.Label(_('Always applicable !'))) vbox.show_all() res = win.run() deps = False for nv in widgets.keys(): if widgets[nv].get_active(): deps = nv[0] + '=' + str(nv[1]) break window.present() win.destroy() if res == gtk.RESPONSE_OK: rpc.session.rpc_exec_auth('/object', 'execute', 'ir.values', 'set', 'default', deps, field, [(model, False)], value, True, False, False, radio.get_active(), True) return True return False
def message(msg, title=None, type=gtk.MESSAGE_INFO, parent=None): if not parent: parent=service.LocalService('gui.main').window dialog = gtk.MessageDialog(parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, type, gtk.BUTTONS_OK) msg = to_xml(msg) if title is not None: msg = '<b>%s</b>\n\n%s' % (to_xml(title), msg) dialog.set_icon(OPENERP_ICON) dialog.set_markup(msg) dialog.show_all() dialog.run() parent.present() dialog.destroy() return True
def update(self): store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) uid = rpc.session.uid sc = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.ui.view_sc', 'get_sc', uid, self.model, rpc.session.context) or [] for s in sc: num = store.append() store.set(num, self.COLUMN_RES_ID, s['res_id'], self.COLUMN_NAME, s['name'], self.COLUMN_ID, s['id']) self.last_iter = num self.tree.set_model(store) if self.model == 'ir.ui.menu': service.LocalService('gui.main').shortcut_set(sc)
def support(*args): wid_list = [ 'email_entry', 'id_entry', 'name_entry', 'phone_entry', 'company_entry', 'error_details', 'explanation_textview', 'remark_textview' ] required_wid = ['email_entry', 'name_entry', 'company_name', 'id_entry'] support_id = options['support.support_id'] recipient = options['support.recipient'] sur = glade.XML(terp_path("openerp.glade"), "dia_support", gettext.textdomain()) win = sur.get_widget('dia_support') parent = service.LocalService('gui.main').window win.set_transient_for(parent) win.set_icon(OPENERP_ICON) win.show_all() sur.get_widget('id_entry1').set_text(support_id) response = win.run() if response == gtk.RESPONSE_OK: fromaddr = sur.get_widget('email_entry1').get_text() id_contract = sur.get_widget('id_entry1').get_text() name = sur.get_widget('name_entry1').get_text() phone = sur.get_widget('phone_entry1').get_text() company = sur.get_widget('company_entry1').get_text() urgency = sur.get_widget('urgency_combo1').get_active_text() buffer = sur.get_widget('explanation_textview1').get_buffer() explanation = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter()) buffer = sur.get_widget('remark_textview').get_buffer() remarks = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter()) content = name + "(%s, %s, %s)" % (id_contract, company, phone) + _( " has reported the following bug:\n") + explanation + "\n" + _( "remarks") + ":\n" + remarks if upload_data(fromaddr, content, 'support', id_contract): common.message(_('Support request sent !'), parent=win) parent.present() win.destroy() return True
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 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
def cal_open(self, widget, event, model=None, window=None): if self.readonly: common.message(_('This widget is readonly !')) return True if not window: window = service.LocalService('gui.main').window win = gtk.Dialog(_('OpenERP - Date selection'), window, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) win.set_icon(common.OPENERP_ICON) cal = gtk.Calendar() cal.display_options(gtk.CALENDAR_SHOW_HEADING | gtk.CALENDAR_SHOW_DAY_NAMES | gtk.CALENDAR_SHOW_WEEK_NUMBERS) cal.connect('day-selected-double-click', lambda *x: win.response(gtk.RESPONSE_OK)) win.vbox.pack_start(cal, expand=True, fill=True) win.show_all() try: val = self.get_value(model) if val: cal.select_month(int(val[5:7]) - 1, int(val[0:4])) cal.select_day(int(val[8:10])) except ValueError: pass response = win.run() if response == gtk.RESPONSE_OK: year, month, day = cal.get_date() dt = DT(year, month + 1, day) try: value = dt.strftime(LDFMT) except ValueError: common.message( _('Invalid date value! Year must be greater than 1899 !')) else: self.entry.set_text(value) self._focus_out() window.present() win.destroy()