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 __init__(self,window, model, node_attr, arrow_attr, attrs, screen):
self.ui = openerp_gtk_builder('openerp.ui', ['widget_view_diagram'])
self.widget = self.ui.get_object('widget_view_diagram')
self.model = model
self.screen = screen
self.node = node_attr
self.arrow = arrow_attr
self.id = None
self.window = xdot.DotWindow(window,self.widget, self.screen, node_attr, arrow_attr, attrs)
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 __init__(self, window, parent, model, attrs={}, label=None):
interface.widget_interface.__init__(self, window, parent, model, attrs, label_ebox=label)
self.ui = openerp_gtk_builder('openerp.ui', ['widget_textbox_tag'])
self.widget = self.ui.get_object('widget_textbox_tag')
self.tv = self.ui.get_object('widget_textbox_tag_tv')
self.tv.set_wrap_mode(gtk.WRAP_WORD)
self.tv.connect('focus-out-event', lambda x,y: self._focus_out())
self.widget.show_all()
self.tags = {}
self.tags_dic = {}
self.buf = self.tv.get_buffer()
self.tagdict = {}
self.buf.connect_after('insert-text', self.sig_insert_text)
self.buf.connect('mark-set', self.sig_mark_set)
self.value=''
# self.sizeButton = self.ui.get_object('font_size')
# self.colorButton =self.ui.get_object('font_color')
self.boldButton = self.ui.get_object('toggle_bold')
self.italicButton = self.ui.get_object('toggle_italic')
self.underlineButton = self.ui.get_object('toggle_underline')
self.strikethroughButton=self.ui.get_object('toggle_strikethrough')
self.internal_toggle = False
self.setup_default_tags ()
self.justify = gtk.JUSTIFY_LEFT
self.leading = 14+7
self.ui.connect_signals({
'on_toggle_bold_toggled': gtk_signal_decorator(self._toggle, [self.bold]),
'on_toggle_italic_toggled': gtk_signal_decorator(self._toggle, [self.italic]),
'on_toggle_underline_toggled': gtk_signal_decorator(self._toggle, [self.underline]),
'on_toggle_strike_toggled': gtk_signal_decorator(self._toggle, [self.strikethrough]),
# 'on_font_size_changed': self._font_changed,
# 'on_color_changed': self._color_changed,
'on_font_button_clicked': self._font_changed,
'on_color_button_clicked': self._color_changed,
'on_radiofill_toggled': gtk_signal_decorator(self._toggle_justify, gtk.JUSTIFY_FILL),
'on_radiocenter_toggled': gtk_signal_decorator(self._toggle_justify, gtk.JUSTIFY_CENTER),
'on_radioright_toggled': gtk_signal_decorator(self._toggle_justify, gtk.JUSTIFY_RIGHT),
'on_radioleft_toggled': gtk_signal_decorator(self._toggle_justify, gtk.JUSTIFY_LEFT),
})
def field_pref_set(field, name, model, value, pwdfield, dependance=None, window=None):
ui = openerp_gtk_builder('openerp.ui', ['win_field_pref'])
if dependance is None:
dependance = []
if window is None:
window = service.LocalService('gui.main').window
win = ui.get_object('win_field_pref')
win.set_transient_for(window)
win.set_icon(common.OPENERP_ICON)
ent = ui.get_object('ent_field')
ent.set_text(name)
ent = ui.get_object('ent_domain')
ent.set_text(model)
ent = ui.get_object('ent_value')
ent.set_text((value and str(value)) or '/')
ent.set_visibility(not pwdfield)
radio = ui.get_object('radio_user_pref')
vbox = ui.get_object('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 __init__(self, window, parent, model, attrs={}):
interface.widget_interface.__init__(self, window, parent, model, attrs)
self.act_id = int(attrs['name'])
res = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.actions.actions', 'read', [self.act_id], ['type'], rpc.session.context)
if not res:
raise Exception, 'ActionNotFound'
type = res[0]['type']
self.action = rpc.session.rpc_exec_auth('/object', 'execute', type, 'read', [self.act_id], False, rpc.session.context)[0]
if 'view_mode' in attrs:
self.action['view_mode'] = attrs['view_mode']
self.action_view_ids = False
if self.action['type'] == 'ir.actions.act_window':
if not self.action.get('domain', False):
self.action['domain'] = '[]'
if attrs.get('domain',False):
self.action['domain'] = attrs.get('domain')
self.context = {'active_id': False, 'active_ids': []}
self.context.update(tools.expr_eval(self.action.get('context', '{}'), self.context.copy()))
self.domain = tools.expr_eval(self.action['domain'], self.context.copy())
view_id = []
if self.action['view_id']:
view_id = [self.action['view_id'][0]]
if self.action.get('views'):
self.action_view_ids = map(lambda y:y[0], filter(lambda x:x[1] == 'tree',self.action['views']))
if self.action['view_type']=='form':
mode = (self.action['view_mode'] or 'form,tree').split(',')
self.screen = Screen(self.action['res_model'], view_type=mode, context=self.context, view_ids = view_id, domain=self.domain)
self.ui = openerp_gtk_builder('openerp.ui', ['widget_paned'])
self.ui.connect_signals({
'on_switch_button_press_event': self._sig_switch,
'on_search_button_press_event': self._sig_search,
'on_open_button_press_event': self._sig_open,
})
label = self.ui.get_object('widget_paned_lab')
label.set_text(attrs.get('string', self.screen.current_view.title))
vbox = self.ui.get_object('widget_paned_vbox')
vbox.add(self.screen.widget)
self.widget = self.ui.get_object('widget_paned')
self.widget.set_size_request(int(attrs.get('width', -1)), int(attrs.get('height', -1)))
elif self.action['view_type']=='tree':
pass #TODO
def __init__(self, model, sel_multi=True, ids=[], view_ids=False, context={}, domain = [], parent=None):
self.model = model
self.sel_multi = sel_multi
self.ids = ids
self.ui = openerp_gtk_builder('openerp.ui', ['win_search'])
self.win = self.ui.get_object('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'], view_ids=view_ids, 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.ui.get_object('win_search_vbox')
self.wid.pack_start(self.sw)
self.wid.show_all()
def __init__(self, ids, model, view=None):
self.ui = openerp_gtk_builder('openerp.ui', ['win_selection'])
self.win = self.ui.get_object('win_selection')
self.win.set_icon(common.OPENERP_ICON)
self.parent = service.LocalService('gui.main').window
self.win.set_transient_for(parent)
self.ids = ids
self.view = self.ui.get_object('win_sel_tree')
self.view.get_selection().set_mode('single')
if view==None:
fields = { 'name': {'type': 'char', 'string':_('Name')} }
xml = '''<?xml version="1.0"?>
<tree string="%s">
<field name="name" string="%s"></field>
</tree>''' % (_('Ressource Name'), _('Names'))
else:
fields = None
xml = None
p = parse.parse(fields)
p.parse(xml, self.view)
self.view.set_expander_column(self.view.get_column(1))
self.fields_order = p.fields_order
types=[ gobject.TYPE_STRING ]
for x in self.fields_order:
types.append( fields_list_type.get(fields[x]['type'], gobject.TYPE_STRING))
self.model = gtk.ListStore(*types)
if view==None:
res_ids = rpc.session.rpc_exec_auth('/object', 'execute', model, 'name_get', self.ids, rpc.session.context)
for res in res_ids:
num = self.model.append()
self.model.set(num, 0, res[0], 1, res[1])
else:
pass # Todo
self.view.set_model(self.model)
self.view.show_all()
def __init__(self, parent=None):
ui = openerp_gtk_builder('openerp.ui', ['win_extension'])
self.win = ui.get_object('win_extension')
self.win.set_transient_for(parent)
self.win.set_icon(common.OPENERP_ICON)
model = gtk.ListStore( str, str, str )
self.treeview = ui.get_object('treeview_extension')
self.treeview.set_model(model)
for index, text in enumerate([_('Extension'), _('Application'), _('Print Processor')]):
renderer = gtk.CellRendererText()
renderer.set_property( 'editable', True )
renderer.connect( 'edited', self._on_cell_renderer_edited )
column = gtk.TreeViewColumn( text, renderer, text=index )
column.set_resizable( True )
self.treeview.append_column( column )
signal_dict = {
'on_button5_clicked' : self._sig_add,
'on_button6_clicked' : self._sig_remove,
}
ui.connect_signals(signal_dict)
self.load_from_file()
def __init__(self, model, res_id=False, domain=None, view_type=None,
view_ids=None, window=None, context=None, name=False, help={}, limit=100,
auto_refresh=False, auto_search=True, search_view=None):
if not view_type:
view_type = ['form','tree']
if domain is None:
domain = []
if view_ids is None:
view_ids = []
if context is None:
context = {}
fields = {}
self.model = model
self.window = window
self.previous_action = None
self.ui = openerp_gtk_builder('openerp.ui', ['win_form_container'])
self.widget = self.ui.get_object('win_form_container')
self.widget.show_all()
self.fields = fields
self.domain = domain
self.context = context
self.page_label = None
self.screen = Screen(self.model, view_type=view_type,
context=self.context, view_ids=view_ids, domain=domain,help=help,
hastoolbar=options.options['form.toolbar'], hassubmenu=options.options['form.submenu'],
show_search=True, window=self.window, limit=limit, readonly=bool(auto_refresh), auto_search=auto_search, search_view=search_view)
self.screen.signal_connect(self, 'record-message', self._record_message)
self.screen.widget.show()
oregistry.add_receiver('misc-message', self._misc_message)
if not name:
self.name = self.screen.current_view.title
else:
self.name = name
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
vp.add(self.screen.widget)
vp.show()
self.sw = gtk.ScrolledWindow()
self.sw.set_shadow_type(gtk.SHADOW_NONE)
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.add(vp)
self.sw.show()
self.has_backup = False
self.backup = {}
self.widget.pack_start(self.sw)
self.handlers = {
'but_new': self.sig_new,
'but_copy': self.sig_copy,
'but_save': self.sig_save,
'but_save_as': self.sig_save_as,
'but_import': self.sig_import,
'but_print_repeat': self.sig_print_repeat,
'but_remove': self.sig_remove,
'but_search': self.sig_search,
'but_previous': self.sig_previous,
'but_next': self.sig_next,
'but_goto_id': self.sig_goto,
'but_log': self.sig_logs,
'but_print': self.sig_print,
'but_reload': self.sig_reload,
'but_print_html': self.sig_print_html,
'but_action': self.sig_action,
'but_switch': self.sig_switch,
'but_attach': self.sig_attach,
'but_close': self.sig_close,
}
if 'tree' in view_type:
self.handlers['radio_tree'] = self.sig_switch_tree
if 'form' in view_type:
self.handlers['radio_form'] = self.sig_switch_form
if 'graph' in view_type:
self.handlers['radio_graph'] = self.sig_switch_graph
if 'calendar' in view_type:
self.handlers['radio_calendar'] = self.sig_switch_calendar
if 'diagram' in view_type:
self.handlers['radio_diagram'] = self.sig_switch_diagram
if res_id:
if isinstance(res_id, (int, long,)):
res_id = [res_id]
self.screen.load(res_id)
else:
if self.screen.current_view.view_type == 'form':
self.sig_new(autosave=False)
if self.screen.current_view.view_type in ('tree', 'graph', 'calendar'):
self.screen.search_filter()
if auto_refresh and int(auto_refresh):
gobject.timeout_add(int(auto_refresh) * 1000, self.sig_reload)
def execute_action(self, combo):
combo_model = combo.get_model()
active_id = combo.get_active()
flag = active_id != -1 and combo_model[active_id][1]
action_name = active_id != -1 and flag not in ['mf','blk', 'sf'] and combo_model[active_id][4]
public_action = active_id != -1 and flag not in ['mf','blk', 'sf'] and combo_model[active_id][3] == 0
# 'mf' Section manages Filters
def clear_domain_ctx():
for key in self.old_ctx.keys():
if key in self.context_init:
del self.context_init[key]
for domain in self.latest_search:
if domain in self.domain_init:
self.domain_init.remove(domain)
#append action domain to filter domain
self.domain_init += self.action_domain
if flag == 'mf':
obj = service.LocalService('action.main')
act = {'name': _('Manage Filters'),
'res_model': 'ir.filters',
'type': 'ir.actions.act_window',
'view_type': 'form',
'view_mode': 'tree,form'}
ctx = dict(self.context)
for key in ('group_by','group_by_no_leaf'):
ctx.pop(key, None)
ctx.update(search_default_my_filters=True,
search_default_model_id=self.name)
value = obj._exec_action(act, {}, ctx)
if flag in ['blk','mf']:
self.screen_container.last_active_filter = False
self.screen_container.last_active_filter_public = False
clear_domain_ctx()
if flag == 'blk':
self.search_filter()
combo.set_active(0)
return True
#This section handles shortcut and action creation
elif flag in ['sf']:
ui2 = openerp_gtk_builder('openerp.ui', ['dia_get_action'])
win = ui2.get_object('dia_get_action')
win.set_icon(common.OPENERP_ICON)
lbl = ui2.get_object('label157')
win.set_size_request(300, 165)
text_entry = ui2.get_object('action_name')
lbl.set_text('Filter Name:')
table = ui2.get_object('table8')
info_lbl = gtk.Label(_('(Any existing filter with the \nsame name will be replaced)'))
public_chk = gtk.CheckButton(_('Share with all users'))
public_chk.set_tooltip_text(_('Check this option to make the filter visible to all users'))
table.attach(public_chk,1,2,2,3, gtk.FILL, gtk.EXPAND)
table.attach(info_lbl,1,2,3,4, gtk.FILL, gtk.EXPAND)
if self.screen_container.last_active_filter:
text_entry.set_text(self.screen_container.last_active_filter)
if self.screen_container.last_active_filter_public:
public_chk.set_active(True)
win.show_all()
response = win.run()
# grab a safe copy of the entered text before destroy() to avoid GTK bug https://bugzilla.gnome.org/show_bug.cgi?id=613241
action_name = text_entry.get_text()
public_filter = public_chk.get_active()
win.destroy()
combo.set_active(0)
if response == gtk.RESPONSE_OK and action_name:
filter_domain = self.filter_widget and self.filter_widget.value.get('domain',[])
filter_context = self.filter_widget and self.filter_widget.value.get('context',{})
values = {'name': action_name,
'model_id': self.name,
'user_id': False if public_filter else rpc.session.uid}
if flag == 'sf':
domain, context = self.screen_container.get_filter(action_name)
for dom in eval(domain):
if dom not in filter_domain:
filter_domain.append(dom)
groupby_list = eval(context).get('group_by',[]) + filter_context.get('group_by',[])
filter_context.update(eval(context))
if groupby_list:
filter_context.update({'group_by':groupby_list})
values.update({'domain':str(filter_domain),
'context':str(filter_context),
})
action_id = rpc.session.rpc_exec_auth('/object', 'execute', 'ir.filters', 'create_or_replace', values, self.context)
self.screen_container.fill_filter_combo(self.name, action_id)
else:
try:
self.screen_container.last_active_filter = action_name
self.screen_container.last_active_filter_public = public_action
filter_domain = flag and tools.expr_eval(flag)
clear_domain_ctx()
if combo.get_active() >= 0:
combo_model = combo.get_model()
val = combo_model[combo.get_active()][2]
if val:
self.old_ctx = eval(val)
self.context_init.update(self.old_ctx)
self.domain_init += filter_domain or []
if isinstance(self.domain_init,type([])):
self.search_filter()
self.reload()
except Exception:
return True
def __init__(self, model, ids, fields, preload = [], parent=None, context=None):
self.ui = openerp_gtk_builder('openerp.ui', ['win_save_as', 'liststore8'])
self.win = self.ui.get_object('win_save_as')
self.ids = ids
self.model = model
self.fields_data = {}
self.fields = {}
if context is None:
context = {}
self.context = context
if parent is None:
parent = service.LocalService('gui.main').window
self.win.set_transient_for(parent)
self.win.set_icon(common.OPENERP_ICON)
self.parent = parent
self.view1 = gtk.TreeView()
self.view1.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.ui.get_object('exp_vp1').add(self.view1)
self.view2 = gtk.TreeView()
self.view2.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.ui.get_object('exp_vp2').add(self.view2)
self.view1.set_headers_visible(False)
self.view2.set_headers_visible(False)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field Name'), cell, text=0, background=2)
self.view1.append_column(column)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field Name'), cell, text=0)
self.view2.append_column(column)
#for f in preload:
# self.model2.set(self.model2.append(), 0, f[1], 1, f[0])
self.wid_import_compatible = self.ui.get_object('import_compatible')
self.model1 = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.fields_original = fields
self.model_populate(self.fields_original)
self.view1.set_model(self.model1)
self.view2.set_model(self.model2)
self.view1.show_all()
self.view2.show_all()
self.wid_action = self.ui.get_object('win_saveas_combo')
self.wid_write_field_names = self.ui.get_object('add_field_names_cb')
action = self.wid_action.set_active(os.name!='nt')
if os.name != 'nt':
self.wid_action.remove_text(0)
else:
try:
from win32com.client import Dispatch
import pywintypes
xlApp = Dispatch("Excel.Application")
except Exception,e:
if isinstance(e, pywintypes.com_error):
action = self.wid_action.set_active(isinstance(e, pywintypes.com_error))
self.wid_action.remove_text(0)
else:
pass
def __init__(self, model, axis, fields, attrs):
self.ui = openerp_gtk_builder("openerp.ui", ["widget_view_calendar"])
self.widget = self.ui.get_object("widget_view_calendar")
self._label_current = self.ui.get_object("label_current")
self._radio_month = self.ui.get_object("radio_month")
self._radio_week = self.ui.get_object("radio_week")
self._radio_day = self.ui.get_object("radio_day")
self._small_calendar = self.ui.get_object("calendar_small")
self._calendar_treeview = self.ui.get_object("calendar_treeview")
mode = attrs.get("mode", "month")
self.log = logging.getLogger("calender")
self.fields = fields
self.attrs = attrs
self.axis = axis
self.screen = None
if mode == "day":
self._radio_day.set_active(True)
elif mode == "week":
self._radio_week.set_active(True)
else:
self._radio_month.set_active(True)
self.mode = mode
self.modex = mode
self.cal_model = TinyCalModel()
self.cal_view = Calendar.Calendar(self.cal_model, mode)
self.cal_view.connect("event-clicked", self._on_event_clicked)
self.cal_view.connect("do_month_back_forward", self._back_forward)
self.cal_view.connect("day-selected", self._change_small)
vbox = self.ui.get_object("cal_vbox")
vbox.pack_start(self.cal_view)
vbox.show_all()
self.process = False
self.ui.connect_signals(
{
"on_but_forward_clicked": gtk_signal_decorator(self._back_forward, 1),
"on_but_back_clicked": gtk_signal_decorator(self._back_forward, -1),
"on_but_today_clicked": self._today,
"on_calendar_small_day_selected_double_click": gtk_signal_decorator(self._change_small, False, False),
"on_button_day_clicked": gtk_signal_decorator(self._change_view, "day"),
"on_button_week_clicked": gtk_signal_decorator(self._change_view, "week"),
"on_button_month_clicked": gtk_signal_decorator(self._change_view, "month"),
}
)
self.date = datetime.today()
self.string = attrs.get("string", "")
self.date_start = attrs.get("date_start")
self.date_delay = attrs.get("date_delay")
self.date_stop = attrs.get("date_stop")
self.color_field = attrs.get("color")
self.color_field_custom = attrs.get("color_custom", "color")
self.color_model = False
self.color_filters = {}
self.colors = {}
self.day_length = int(attrs.get("day_length", 8))
self.models = None
self.models_record_group = None
if self.color_field:
self.color_model = gtk.ListStore(str, str, str, gobject.TYPE_BOOLEAN)
self._calendar_treeview.set_model(self.color_model)
self._calendar_treeview.get_selection().set_mode(gtk.SELECTION_NONE)
for c in (self.TV_COL_ID, self.TV_COL_COLOR):
column = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=c)
self._calendar_treeview.append_column(column)
column.set_visible(False)
# Row toogle
renderer = gtk.CellRendererToggle()
renderer.set_property("activatable", True)
renderer.connect("toggled", self._treeview_toggled, self.color_model, self.color_filters)
column = gtk.TreeViewColumn(None, renderer)
column.add_attribute(renderer, "active", self.TV_COL_TOGGLE)
column.set_cell_data_func(renderer, self._treeview_setter)
self._calendar_treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(None, renderer, text=self.TV_COL_LABEL)
col_label = gtk.Label("")
col_label.set_markup("<b>%s</b>" % self.fields[self.color_field]["string"])
col_label.show()
column.set_widget(col_label)
column.set_cell_data_func(renderer, self._treeview_setter)
self._calendar_treeview.append_column(column)
def __init__(self, model, fields, preload = [], parent=None, local_context=None):
self.ui = openerp_gtk_builder('openerp.ui', ['win_import', 'liststore6', 'adjustment1'])
self.ui.get_object('import_csv_combo')
self.win = self.ui.get_object('win_import')
self.model = model
self.fields_data = {}
self.invert = False
self.context = local_context or {}
if parent is None:
parent = service.LocalService('gui.main').window
self.win.set_transient_for(parent)
self.win.set_icon(common.OPENERP_ICON)
self.parent = parent
self.autodetect_btn = self.ui.get_object('button_autodetect')
self.filechooser = self.ui.get_object('import_csv_file')
self.filechooser.set_current_folder(
options.options['client.default_path'])
self.filechooser.connect('selection-changed',self.file_changed)
self.view1 = gtk.TreeView()
self.view1.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.ui.get_object('import_vp_left').add(self.view1)
self.view2 = gtk.TreeView()
self.view2.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.ui.get_object('import_vp_right').add(self.view2)
self.view1.set_headers_visible(False)
self.view2.set_headers_visible(False)
self.encoding = self.ui.get_object('import_csv_combo')
self.encoding.set_active(0)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field name'), cell, text=0, background=2)
self.view1.append_column(column)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Field name'), cell, text=0)
self.view2.append_column(column)
self.model1 = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
for f in preload:
self.model2.set(self.model2.append(), 0, f[1], 1, f[0])
self.fields = {}
self.fields_invert = {}
def model_populate(fields, prefix_node='', prefix=None, prefix_value='', level=2):
fields_order = fields.keys()
fields_order.sort(lambda x,y: -cmp(fields[x].get('string', ''), fields[y].get('string', '')))
for field in fields_order:
if (fields[field].get('type','') not in ('reference',)) \
and (not fields[field].get('readonly', False) \
or not dict(fields[field].get('states', {}).get(
'draft', [('readonly', True)])).get('readonly', True)\
or not dict(fields[field].get('states', {}).get(
field, [('readonly', True)])).get('readonly', True)):
self.fields_data[prefix_node+field] = fields[field]
st_name = prefix_value+fields[field]['string'] or field
node = self.model1.insert(prefix, 0, [st_name, prefix_node+field,
(fields[field].get('required', False) and '#ddddff') or 'white'])
self.fields[prefix_node+field] = st_name
self.fields_invert[st_name] = prefix_node+field
if fields[field].get('type','') == 'one2many' and level>0:
fields2 = rpc.session.rpc_exec_auth('/object', 'execute', fields[field]['relation'], 'fields_get', False, rpc.session.context)
model_populate(fields2, prefix_node+field+'/', node, st_name+'/', level-1)
if fields[field].get('relation',False) and level>0:
#self.fields[field+':id'] = fields[field]['string']
#self.fields_invert[fields[field]['string']] = field+':id'
model_populate({'/id':{'string':'ID'},'.id':{'string':_('Database ID')}}, \
prefix_node+field, node, st_name+'/', level-1)
fields.update({'id':{'string':'ID'},'.id':{'string':_('Database ID')}})
model_populate(fields)
#for f in fields:
# self.model1.set(self.model1.append(), 1, f, 0, fields[f].get('string', 'unknown'))
self.view1.set_model(self.model1)
self.view2.set_model(self.model2)
self.view1.show_all()
self.view2.show_all()
self.ui.connect_signals({
'on_but_unselect_all_clicked': self.sig_unsel_all,
'on_but_select_all_clicked': self.sig_sel_all,
'on_but_select_clicked': self.sig_sel,
'on_but_unselect_clicked': self.sig_unsel,
'on_but_autodetect_clicked': self.sig_autodetect,
})
def __init__(self, model, axis, fields, attrs):
self.ui = openerp_gtk_builder('openerp.ui', ['widget_view_calendar'])
self.widget = self.ui.get_object('widget_view_calendar')
self._label_current = self.ui.get_object('label_current')
self._radio_month = self.ui.get_object('radio_month')
self._radio_week = self.ui.get_object('radio_week')
self._radio_day = self.ui.get_object('radio_day')
self._small_calendar = self.ui.get_object('calendar_small')
self._calendar_treeview = self.ui.get_object('calendar_treeview')
mode = attrs.get('mode','month')
self.log = logging.getLogger('calender')
self.fields = fields
self.attrs = attrs
self.axis = axis
self.screen = None
if mode == 'day':
self._radio_day.set_active(True)
elif mode == 'week':
self._radio_week.set_active(True)
else:
self._radio_month.set_active(True)
self.mode = mode
self.modex = mode
self.cal_model = TinyCalModel()
self.cal_view = Calendar.Calendar(self.cal_model, mode)
self.cal_view.connect('event-clicked', self._on_event_clicked)
self.cal_view.connect('do_month_back_forward', self._back_forward)
self.cal_view.connect('day-selected', self._change_small)
vbox = self.ui.get_object('cal_vbox')
vbox.pack_start(self.cal_view)
vbox.show_all()
self.process = False
self.ui.connect_signals({
'on_but_forward_clicked': gtk_signal_decorator(self._back_forward, 1),
'on_but_back_clicked': gtk_signal_decorator(self._back_forward, -1),
'on_but_today_clicked': self._today,
'on_calendar_small_day_selected_double_click': gtk_signal_decorator(self._change_small, False, False),
'on_button_day_clicked': gtk_signal_decorator(self._change_view, 'day'),
'on_button_week_clicked': gtk_signal_decorator(self._change_view, 'week'),
'on_button_month_clicked': gtk_signal_decorator(self._change_view, 'month'),
})
self.date = datetime.today()
self.string = attrs.get('string', '')
self.date_start = attrs.get('date_start')
self.date_delay = attrs.get('date_delay')
self.date_stop = attrs.get('date_stop')
self.color_field = attrs.get('color')
self.color_field_custom = attrs.get('color_custom', 'color')
self.color_model = False
self.color_filters = {}
self.colors = {}
self.day_length = int(attrs.get('day_length', 8))
self.models = None
self.models_record_group = None
if self.color_field:
self.color_model = gtk.ListStore(str, str, str, gobject.TYPE_BOOLEAN)
self._calendar_treeview.set_model(self.color_model)
self._calendar_treeview.get_selection().set_mode(gtk.SELECTION_NONE)
for c in (self.TV_COL_ID, self.TV_COL_COLOR):
column = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=c)
self._calendar_treeview.append_column(column)
column.set_visible(False)
# Row toogle
renderer = gtk.CellRendererToggle()
renderer.set_property('activatable', True)
renderer.connect('toggled', self._treeview_toggled, self.color_model, self.color_filters)
column = gtk.TreeViewColumn(None, renderer)
column.add_attribute(renderer, "active", self.TV_COL_TOGGLE)
column.set_cell_data_func(renderer, self._treeview_setter)
self._calendar_treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(None, renderer, text=self.TV_COL_LABEL)
col_label = gtk.Label('')
col_label.set_markup('<b>%s</b>' % self.fields[self.color_field]['string'])
col_label.show()
column.set_widget(col_label)
column.set_cell_data_func(renderer, self._treeview_setter)
self._calendar_treeview.append_column(column)
def __init__(self, view, model, res_id=False, domain=[], context={}, help={}, window=None, name=False):
self.ui = openerp_gtk_builder('openerp.ui', ['win_tree_container'])
self.widget = self.ui.get_object('win_tree_container')
self.widget.show_all()
self.model = view['model']
self.domain2 = domain
if view.get('field_parent', False):
self.domain = []
else:
self.domain = domain
self.view = view
self.window=window
self.context=context
self.tree_res = view_tree.view_tree(view, [], res_id, True, context=context)
self.tree_res.view.connect('row-activated', self.sig_open)
sel = self.tree_res.view.get_selection()
sel.connect('changed', self.expand_one)
if not name:
self.name = self.tree_res.name
else:
self.name = name
self.vp = self.ui.get_object('main_tree_sw')
wid = self.ui.get_object('widget_vbox')
wid.show()
widget_sc = self.ui.get_object('win_tree_sc')
widget_sc.connect('row-activated', self.sc_go)
self.tree_sc = view_tree.view_tree_sc(widget_sc, self.model)
self.handlers = {
'but_reload': self.sig_reload,
'but_switch': self.sig_edit,
'but_chroot': self.sig_chroot,
'but_open': self.sig_action,
'but_action': self.sig_action,
'but_print': self.sig_print,
'but_print_html': self.sig_print_html,
'but_close': self.sig_close,
'but_save_as': self.sig_save_as,
}
signal_dict = {
'on_but_sc_go_clicked': self.sc_go,
'on_but_sc_add_clicked': self.sc_add,
'on_but_sc_del_clicked': self.sc_del,
'on_but_expand_collapse_clicked': self.expand_collapse_all,
}
self.help = help
self.help_frame = False
wid = self.tree_res.widget_get()
if self.help:
action_tips = common.action_tips(self.help)
self.help_frame = action_tips.help_frame
if self.help_frame:
vbox = gtk.VBox()
vbox.pack_start(self.help_frame, expand=False, fill=False, padding=2)
vbox.pack_end(wid)
vbox.show_all()
wid = vbox
if self.help_frame:
self.vp.add_with_viewport(wid)
else:
self.vp.add(wid)
self.sig_reload()
self.ui.connect_signals(signal_dict)
self.expand = True
