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