def response(self, win, response_id):
res = None
if response_id == gtk.RESPONSE_OK:
res = [r.id for r in self.screen.selected_records]
elif response_id == gtk.RESPONSE_APPLY:
self.screen.search_filter(self.screen.screen_container.get_text())
return
elif response_id == gtk.RESPONSE_ACCEPT:
screen = Screen(self.model_name,
domain=self.domain,
context=self.context,
mode=['form'])
def callback(result):
if result and screen.save_current():
record = screen.current_record
res = [(record.id, record.value.get('rec_name', ''))]
self.callback(res)
else:
self.callback(None)
self.destroy()
WinForm(screen, callback, new=True, title=self.title)
return
if res:
group = self.screen.group
res = [(id_, group.get(id_).value.get('rec_name', ''))
for id_ in res]
self.callback(res)
self.destroy()
def row_activate(self):
if not self.screen.current_record:
return
if (self.screen.current_view.view_type == 'tree' and int(
self.screen.current_view.attributes.get('keyword_open', 0))):
GenericAction.exec_keyword(
'tree_open', {
'model':
self.screen.model_name,
'id': (self.screen.current_record.id
if self.screen.current_record else None),
'ids': [r.id for r in self.screen.selected_records],
},
context=self.screen.group._context.copy(),
warning=False)
else:
def callback(result):
if result:
self.screen.current_record.save()
else:
self.screen.current_record.cancel()
WinForm(self.screen, callback)
def _sig_edit(self):
if self.screen.current_record:
def callback(result):
if result:
self.screen.current_record.save()
else:
self.screen.current_record.cancel()
WinForm(self.screen, callback)
def _sig_edit(self, widget=None):
if not self.but_open.props.sensitive:
return
if not self._validate():
return
record = self.screen.current_record
if record:
WinForm(self.screen, lambda a: None)
def _sig_edit(self, widget=None):
if not common.MODELACCESS[self.screen.model_name]['read']:
return
if not self._validate():
return
record = self.screen.current_record
if record:
WinForm(self.screen, lambda a: None)
def sig_edit(self, entry=None, icon_pos=None, *args):
model = self.get_model()
if not model or not common.MODELACCESS[model]['read']:
return
if not self.focus_out or not self.field:
return
self.changed = False
self.focus_out = False
value = self.field.get(self.record)
if (icon_pos == Gtk.EntryIconPosition.SECONDARY
and not self._readonly
and self.has_target(value)):
self.field.set_client(self.record, self.value_from_id(None, ''))
self.wid_text.set_text('')
self.changed = True
self.focus_out = True
return
if self.has_target(value):
screen = self.get_screen()
screen.load([self.id_from_value(self.field.get(self.record))])
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(screen.current_record.id,
screen.current_record.rec_name()),
force_change=True)
self.focus_out = True
self.changed = True
WinForm(screen, callback, save_current=True,
title=self.attrs.get('string'))
return
if not self._readonly:
domain = self.field.domain_get(self.record)
context = self.field.get_search_context(self.record)
order = self.field.get_search_order(self.record)
text = self.wid_text.get_text()
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(*result[0]), force_change=True)
self.focus_out = True
self.changed = True
win = WinSearch(model, callback, sel_multi=False,
context=context, domain=domain, order=order,
view_ids=self.attrs.get('view_ids', '').split(','),
views_preload=self.attrs.get('views', {}),
new=self.create_access, title=self.attrs.get('string'),
exclude_field=self.attrs.get('relation_field'))
win.screen.search_filter(quote(text))
win.show()
return
self.focus_out = True
self.changed = True
def sig_edit(self, *args):
model = self.get_model()
if not model or not common.MODELACCESS[model]['read']:
return
if not self.focus_out or not self.field:
return
self.changed = False
value = self.field.get(self.record)
model = self.get_model()
self.focus_out = False
if model and self.has_target(value):
screen = self.get_screen()
screen.load([self.id_from_value(self.field.get(self.record))])
def callback(result):
if result:
self.field.set_client(
self.record,
self.value_from_id(screen.current_record.id,
screen.current_record.rec_name()),
force_change=True)
self.focus_out = True
self.changed = True
WinForm(screen, callback, save_current=True)
return
elif model and not self._readonly:
domain = self.field.domain_get(self.record)
context = self.field.context_get(self.record)
text = self.wid_text.get_text().decode('utf-8')
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(*result[0]),
force_change=True)
self.focus_out = True
self.changed = True
win = WinSearch(model,
callback,
sel_multi=False,
context=context,
domain=domain,
view_ids=self.attrs.get('view_ids', '').split(','),
views_preload=self.attrs.get('views', {}),
new=self.create_access)
win.screen.search_filter(quote(text))
win.show()
return
self.focus_out = True
self.changed = True
return
def open_remote(self, record, create=True, changed=False, text=None,
callback=None):
field = record.group.fields[self.attrs['name']]
relation = field.attrs['relation']
access = common.MODELACCESS[relation]
if (create
and not (self.attrs.get('create', True) and access['create'])):
return
elif not access['read']:
return
domain = field.domain_get(record)
context = field.get_context(record)
if create:
obj_id = None
elif not changed:
obj_id = field.get(record)
else:
self.search_remote(record, field, text, callback=callback).show()
return
screen = Screen(relation, domain=domain, context=context,
mode=['form'], view_ids=self.attrs.get('view_ids', '').split(','),
exclude_field=field.attrs.get('relation_field'))
def open_callback(result):
if result:
value = (screen.current_record.id,
screen.current_record.rec_name())
field.set_client(record, value, force_change=True)
if callback:
callback()
if obj_id:
screen.load([obj_id])
WinForm(screen, open_callback, save_current=True,
title=field.attrs.get('string'))
else:
WinForm(screen, open_callback, new=True, save_current=True,
title=field.attrs.get('string'), rec_name=text)
def _sig_new(self):
screen = self._get_screen_form()
def callback(result):
self.focus_out = True
if result:
record = screen.current_record
self.screen.load([record.id], modified=True)
self.wid_text.set_text('')
self.wid_text.grab_focus()
self.focus_out = False
WinForm(screen, callback, new=True, save_current=True,
title=self.attrs.get('string'), rec_name=self.wid_text.get_text())
def sig_new(self, *args):
model = self.get_model()
if not model or not common.MODELACCESS[model]['create']:
return
self.focus_out = False
screen = self.get_screen()
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(screen.current_record.id,
screen.current_record.rec_name()))
self.focus_out = True
WinForm(screen, callback, new=True, save_current=True)
def _sig_edit(self):
if not self.screen.current_record:
return
# Create a new screen that is not linked to the parent otherwise on the
# save of the record will trigger the save of the parent
screen = self._get_screen_form()
screen.load([self.screen.current_record.id])
def callback(result):
if result:
screen.current_record.save()
# Force a reload on next display
self.screen.current_record.cancel()
# Force a display to clear the CellCache
self.screen.display()
WinForm(screen, callback, title=self.attrs.get('string'))
def _new_single(self):
sequence = self._sequence()
def update_sequence():
if sequence:
self.screen.group.set_sequence(field=sequence)
if self.screen.current_view.editable:
self.screen.new()
self.screen.current_view.widget.set_sensitive(True)
update_sequence()
else:
field_size = self.record.expr_eval(self.attrs.get('size')) or -1
field_size -= len(self.field.get_eval(self.record)) + 1
WinForm(self.screen, lambda a: update_sequence(), new=True,
many=field_size, title=self.attrs.get('string'))
def open_remote(self, record, create=True, changed=False, text=None,
callback=None):
group = record.value[self.field_name]
field = record.group.fields[self.field_name]
relation = field.attrs['relation']
context = field.context_get(record)
domain = field.domain_get(record)
screen = Screen(relation, mode=['tree', 'form'],
exclude_field=field.attrs.get('relation_field'))
screen.group = group
def open_callback(result):
if callback:
callback()
WinForm(screen, open_callback, view_type='tree', domain=domain,
context=context)
def row_activate(self):
if not self.screen.current_record:
return
if (self.screen.current_view.view_type == 'tree' and
self.screen.current_view.treeview.keyword_open):
GenericAction.exec_keyword('tree_open', {
'model': self.screen.model_name,
'id': self.screen.id_get(),
'ids': [self.screen.id_get()],
}, context=self.screen.context.copy(), warning=False)
else:
def callback(result):
if result:
self.screen.current_record.save()
else:
self.screen.current_record.cancel()
WinForm(self.screen, callback)
def sig_new(self, *args):
if not self.create_access:
return
self.focus_out = False
screen = self.get_screen(search=True)
def callback(result):
if result:
self.field.set_client(
self.record,
self.value_from_id(screen.current_record.id,
screen.current_record.rec_name()))
self.focus_out = True
WinForm(screen,
callback,
new=True,
save_current=True,
rec_name=self.wid_text.get_text())
def open_remote(self, record, create=True, changed=False, text=None,
callback=None):
group = record.value[self.field_name]
field = record.group.fields[self.field_name]
relation = field.attrs['relation']
context = field.context_get(record)
access = common.MODELACCESS[relation]
if not access['read']:
return
screen = Screen(relation, mode=['tree', 'form'],
exclude_field=field.attrs.get('relation_field'))
screen.pre_validate = bool(int(self.attrs.get('pre_validate', 0)))
screen.group = group
def open_callback(result):
if callback:
callback()
WinForm(screen, open_callback, view_type='tree', context=context)
def _completion_action_activated(self, completion, index):
if index == 0:
self._sig_add(win_search=True)
self.wid_text.grab_focus()
elif index == 1:
model = self.attrs['relation']
domain = self.field.domain_get(self.record)
context = self.field.context_get(self.record)
screen = Screen(model, domain, context=context, mode=['form'])
def callback(result):
self.focus_out = True
if result:
record = screen.current_record
self.screen.load([record.id], modified=True)
self.wid_text.set_text('')
self.wid_text.grab_focus()
self.focus_out = False
WinForm(screen, callback, new=True, save_current=True)
def response(self, win, response_id):
res = None
if response_id == gtk.RESPONSE_OK:
res = [r.id for r in self.screen.selected_records]
elif response_id == gtk.RESPONSE_APPLY:
self.screen.search_filter(self.screen.screen_container.get_text())
return
elif response_id == gtk.RESPONSE_ACCEPT:
# Remove first tree view as mode if form only
view_ids = self.view_ids[1:]
screen = Screen(self.model_name,
domain=self.domain,
context=self.context,
order=self.order,
mode=['form'],
view_ids=view_ids,
views_preload=self.views_preload)
def callback(result):
# JMO : TODO : see if that diff from tryton is needed
if result and screen.save_current():
record = screen.current_record
res = [(record.id, record.value.get('rec_name', ''))]
self.callback(res)
else:
self.callback(None)
self.destroy()
WinForm(screen,
callback,
new=True,
save_current=True,
title=self.title)
return
if res:
group = self.screen.group
res = [(id_, group.get(id_).value.get('rec_name', ''))
for id_ in res]
self.callback(res)
self.destroy()
def _new_single(self):
ctx = {}
ctx.update(self.field.context_get(self.record))
sequence = None
for view in self.screen.views:
if view.view_type == 'tree':
sequence = view.attributes.get('sequence')
if sequence:
break
def update_sequence():
if sequence:
self.screen.group.set_sequence(field=sequence)
if self.screen.current_view.editable:
self.screen.new()
self.screen.current_view.widget.set_sensitive(True)
update_sequence()
else:
field_size = self.record.expr_eval(self.attrs.get('size')) or -1
field_size -= len(self.field.get_eval(self.record)) + 1
WinForm(self.screen, lambda a: update_sequence(), new=True,
many=field_size, context=ctx, title=self.attrs.get('string'))
def response(self, win, response_id):
res = None
if response_id == Gtk.ResponseType.OK:
res = [r.id for r in self.screen.selected_records]
elif response_id == Gtk.ResponseType.APPLY:
self.screen.search_filter(self.screen.screen_container.get_text())
return
elif response_id == Gtk.ResponseType.ACCEPT:
# Remove first tree view as mode if form only
view_ids = self.view_ids[1:]
screen = Screen(self.model_name,
domain=self.domain,
context=self.context,
order=self.order,
mode=['form'],
view_ids=view_ids,
views_preload=self.views_preload,
exclude_field=self.exclude_field,
breadcrumb=[self.title])
def callback(result):
if result:
record = screen.current_record
res = [(record.id, record.value.get('rec_name', ''))]
self.callback(res)
else:
self.callback(None)
self.destroy()
WinForm(screen, callback, new=True, save_current=True)
return
if res:
group = self.screen.group
res = [(id_, group.get(id_).value.get('rec_name', ''))
for id_ in res]
self.callback(res)
self.destroy()
def _sig_new(self, widget=None):
if not common.MODELACCESS[self.screen.model_name]['create']:
return
if not self._validate():
return
ctx = {}
ctx.update(self.field.context_get(self.record))
sequence = None
if self.screen.current_view.view_type == 'tree':
sequence = self.screen.current_view.widget_tree.sequence
def update_sequence():
if sequence:
self.screen.group.set_sequence(field=sequence)
if self.screen.current_view.editable:
self.screen.new()
self.screen.current_view.widget.set_sensitive(True)
update_sequence()
else:
field_size = self.record.expr_eval(self.attrs.get('size')) or -1
field_size -= len(self.field.get_eval(self.record)) + 1
WinForm(self.screen, lambda a: update_sequence(), new=True,
many=field_size, context=ctx)
def _sig_new(self):
domain = self.field.domain_get(self.record)
add_remove = self.record.expr_eval(self.attrs.get('add_remove'))
if add_remove:
domain = [domain, add_remove]
context = self.field.context_get(self.record)
screen = Screen(self.attrs['relation'],
domain=domain,
view_ids=self.attrs.get('view_ids', '').split(','),
mode=['form'],
views_preload=self.attrs.get('views', {}),
context=context)
def callback(result):
self.focus_out = True
if result:
record = screen.current_record
self.screen.load([record.id], modified=True)
self.wid_text.set_text('')
self.wid_text.grab_focus()
self.focus_out = False
WinForm(screen, callback, new=True, save_current=True)
def sig_edit(self, *args):
model = self.get_model()
if not model or not common.MODELACCESS[model]['read']:
return
if not self.focus_out or not self.field:
return
self.changed = False
value = self.field.get(self.record)
model = self.get_model()
self.focus_out = False
if model and self.has_target(value):
screen = self.get_screen()
screen.load([self.id_from_value(self.field.get(self.record))])
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(screen.current_record.id,
screen.current_record.rec_name()),
force_change=True)
self.focus_out = True
self.changed = True
WinForm(screen, callback, save_current=True)
return
elif model and not self._readonly:
domain = self.field.domain_get(self.record)
context = self.field.context_get(self.record)
self.wid_text.grab_focus()
try:
if self.wid_text.get_text():
dom = [('rec_name', 'ilike',
'%' + self.wid_text.get_text() + '%'),
domain]
else:
dom = domain
ids = RPCExecute('model', model, 'search', dom, 0,
CONFIG['client.limit'], None, context=context)
except RPCException:
self.focus_out = True
self.changed = True
return False
if len(ids) == 1:
self.field.set_client(self.record, self.value_from_id(ids[0]),
force_change=True)
self.focus_out = True
return True
def callback(result):
if result:
self.field.set_client(self.record,
self.value_from_id(*result[0]), force_change=True)
self.focus_out = True
self.changed = True
WinSearch(model, callback, sel_multi=False,
ids=ids, context=context, domain=domain,
view_ids=self.attrs.get('view_ids', '').split(','),
views_preload=self.attrs.get('views', {}),
new=self.but_new.get_property('sensitive'))
return
self.focus_out = True
self.changed = True
return
