def client_action(self, action):
access = MODELACCESS[self.model_name]
if action == 'new':
if access['create']:
self.new()
elif action == 'delete':
if access['delete']:
self.remove(delete=not self.parent,
force_remove=not self.parent)
elif action == 'remove':
if access['write'] and access['read'] and self.parent:
self.remove(remove=True)
elif action == 'copy':
if access['create']:
self.copy()
elif action == 'next':
self.display_next()
elif action == 'previous':
self.display_prev()
elif action == 'close':
from tryton.gui import Main
Main().sig_win_close()
elif action.startswith('switch'):
self.switch_view(*action.split(None, 2)[1:])
elif action == 'reload':
if (self.current_view.view_type in ['tree', 'graph', 'calendar']
and not self.parent):
self.search_filter()
elif action == 'reload menu':
from tryton.gui import Main
RPCContextReload(Main().sig_win_menu)
elif action == 'reload context':
RPCContextReload()
def destroy(self, action=None):
super(WizardDialog, self).destroy(action=action)
self.dia.destroy()
NoModal.destroy(self)
main = Main()
if self.parent == main.window:
current_form = main.get_page()
if current_form:
for dialog in current_form.dialogs:
dialog.show()
if self.page.dialogs:
dialog = self.page.dialogs[-1]
else:
dialog = self.page
screen = getattr(dialog, 'screen', None)
if self.sensible_widget == main.window:
screen = main.menu_screen
if screen:
if (screen.current_record and self.sensible_widget != main.window):
if screen.model_name == self.model:
ids = self.ids
else:
# Wizard run from a children record so reload parent record
ids = [screen.current_record.id]
screen.reload(ids, written=True)
if action:
screen.client_action(action)
def destroy(self, action=None):
super(WizardDialog, self).destroy(action=action)
self.dia.destroy()
NoModal.destroy(self)
main = Main()
if self.parent == main.window:
current_form = main.get_page()
if current_form:
for dialog in current_form.dialogs:
dialog.show()
if self.page.dialogs:
dialog = self.page.dialogs[-1]
else:
dialog = self.page
screen = getattr(dialog, 'screen', None)
# JMO: the conditions added on 'reload' are needed
# for https://support.coopengo.com/issues/12986
if action != 'reload' and self.sensible_widget == main.window:
screen = main.menu_screen
if screen:
if (screen.current_record and self.sensible_widget != main.window
or action == 'reload'):
if screen.model_name == self.model:
ids = self.ids
else:
# Wizard run from a children record so reload parent record
ids = [screen.current_record.id]
screen.reload(ids, written=True)
if action:
screen.client_action(action)
def client_action(self, action):
access = MODELACCESS[self.model_name]
if action == 'new':
if access['create']:
self.new()
elif action == 'delete':
if access['delete']:
self.remove(delete=not self.parent,
force_remove=not self.parent)
elif action == 'remove':
if access['write'] and access['read'] and self.parent:
self.remove(remove=True)
elif action == 'copy':
if access['create']:
self.copy()
elif action == 'next':
self.display_next()
elif action == 'previous':
self.display_prev()
elif action == 'close':
from tryton.gui import Main
Main.get_main().sig_win_close()
elif action.startswith('switch'):
_, view_type = action.split(None, 1)
self.switch_view(view_type=view_type)
elif action == 'reload':
if (self.current_view.view_type in ['tree', 'graph', 'calendar']
and not self.parent):
self.search_filter()
elif action == 'reload menu':
from tryton.gui import Main
RPCContextReload(Main.get_main().sig_win_menu)
elif action == 'reload context':
RPCContextReload()
def do_single_action(self, action, access):
if action == 'new':
if access['create']:
self.new()
elif action == 'delete':
if access['delete']:
self.remove(delete=not self.parent,
force_remove=not self.parent)
elif action == 'remove':
if access['write'] and access['read'] and self.parent:
self.remove(remove=True)
elif action == 'copy':
if access['create']:
self.copy()
elif action == 'next':
self.display_next()
elif action == 'previous':
self.display_prev()
elif action == 'close':
from tryton.gui import Main
Main.get_main().sig_win_close()
elif action.startswith('switch'):
_, view_type = action.split(None, 1)
self.switch_view(view_type=view_type)
elif action == 'reload':
if (self.current_view.view_type in ['tree', 'graph', 'calendar']
and not self.parent):
self.search_filter()
elif action == 'reload menu':
from tryton.gui import Main
RPCContextReload(Main.get_main().sig_win_menu)
elif action == 'reload context':
RPCContextReload()
def create(model, **attributes):
from tryton.gui import Main
if model:
from form import Form
win = Form(model, **attributes)
else:
from board import Board
win = Board(model, **attributes)
win.icon = attributes.get('icon')
Main.get_main().win_add(win, hide_current=Window.hide_current,
allow_similar=Window.allow_similar)
def create_wizard(action, data, direct_print=False, email_print=False,
email=None, name=False, context=None, icon=None, window=False):
from tryton.gui import Main
from wizard import WizardForm, WizardDialog
if window:
win = WizardForm(name=name)
win.icon = icon
Main.get_main().win_add(win, Window.hide_current)
else:
win = WizardDialog(name=name)
win.run(action, data, direct_print=direct_print,
email_print=email_print, email=email, context=context)
def create_tabcontent(self):
self.buttons = {}
self.tooltips = common.Tooltips()
self.accel_group = Main.get_main().accel_group
self.widget = gtk.VBox(spacing=3)
self.widget.show()
title_box = self.make_title_bar()
self.widget.pack_start(title_box, expand=False, fill=True, padding=3)
self.create_info_bar()
self.widget.pack_start(self.info_bar, False, True)
self.toolbar = self.create_toolbar(self.get_toolbars())
# JCA : Allow to hide buttons through the context
if not self.context.get('disable_main_toolbar', None):
self.toolbar.show_all()
self.widget.pack_start(self.toolbar, False, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.widget_get())
viewport.show()
self.scrolledwindow = gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.widget.pack_start(self.scrolledwindow)
def __init__(self, name=''):
Wizard.__init__(self, name=name)
NoModal.__init__(self)
self.dia = Gtk.Dialog(title=self.name,
transient_for=self.parent,
destroy_with_parent=True)
Main().add_window(self.dia)
self.dia.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.dia.set_icon(TRYTON_ICON)
self.dia.set_deletable(False)
self.dia.connect('delete-event', lambda *a: True)
self.dia.connect('close', self.close)
self.dia.connect('response', self.response)
self.accel_group = Gtk.AccelGroup()
self.dia.add_accel_group(self.accel_group)
self._buttons = set()
self.dia.vbox.pack_start(self.widget,
expand=True,
fill=True,
padding=0)
self.register()
def __init__(self):
self.parent = get_toplevel_window()
self.win = gtk.Dialog(
_('Limit'), self.parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.win)
cancel_button = self.win.add_button('gtk-cancel', gtk.RESPONSE_CANCEL)
cancel_button.set_always_show_image(True)
ok_button = self.win.add_button('gtk-ok', gtk.RESPONSE_OK)
ok_button.set_always_show_image(True)
self.win.set_default_response(gtk.RESPONSE_OK)
self.win.set_icon(TRYTON_ICON)
self.win.vbox.set_spacing(3)
self.win.vbox.pack_start(gtk.Label(_('Search Limit Settings')),
expand=False,
fill=True)
self.win.vbox.pack_start(gtk.HSeparator())
hbox = gtk.HBox(spacing=3)
label = gtk.Label(_('Limit:'))
hbox.pack_start(label, expand=True, fill=True)
adjustment = gtk.Adjustment(value=CONFIG['client.limit'],
lower=1,
upper=sys.maxsize,
step_incr=10,
page_incr=100)
self.spin_limit = gtk.SpinButton()
self.spin_limit.configure(adjustment, climb_rate=1, digits=0)
self.spin_limit.set_numeric(False)
self.spin_limit.set_activates_default(True)
label.set_mnemonic_widget(self.spin_limit)
hbox.pack_start(self.spin_limit, expand=True, fill=True)
self.win.vbox.pack_start(hbox, expand=True, fill=True)
self.win.show_all()
def create_tabcontent(self):
self.buttons = {}
self.tooltips = common.Tooltips()
self.accel_group = Main.get_main().accel_group
self.widget = gtk.VBox(spacing=3)
self.widget.show()
title_box = self.make_title_bar()
self.widget.pack_start(title_box, expand=False, fill=True, padding=3)
self.create_info_bar()
self.widget.pack_start(self.info_bar, False, True)
self.toolbar = self.create_toolbar(self.get_toolbars())
self.toolbar.show_all()
self.widget.pack_start(self.toolbar, False, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.widget_get())
viewport.show()
self.scrolledwindow = gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.widget.pack_start(self.scrolledwindow)
def __init__(self, revisions, revision=None, format_='%x %H:%M:%S.%f'):
self.parent = get_toplevel_window()
self.win = gtk.Dialog(
_('Revision'), self.parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.win)
cancel_button = self.win.add_button(set_underline(_("Cancel")),
gtk.RESPONSE_CANCEL)
cancel_button.set_image(
IconFactory.get_image('tryton-cancel', gtk.ICON_SIZE_BUTTON))
cancel_button.set_always_show_image(True)
ok_button = self.win.add_button(set_underline(_("OK")),
gtk.RESPONSE_OK)
ok_button.set_image(
IconFactory.get_image('tryton-ok', gtk.ICON_SIZE_BUTTON))
ok_button.set_always_show_image(True)
self.win.set_default_response(gtk.RESPONSE_OK)
self.win.set_icon(TRYTON_ICON)
self.win.vbox.set_spacing(3)
self.win.vbox.pack_start(gtk.Label(_('Select a revision')),
expand=False,
fill=True)
self.win.vbox.pack_start(gtk.HSeparator())
hbox = gtk.HBox(spacing=3)
label = gtk.Label(_('Revision:'))
hbox.pack_start(label, expand=True, fill=True)
list_store = gtk.ListStore(str, str)
# Set model on instantiation to get the default cellrenderer as text
combobox = gtk.ComboBoxEntry(model=list_store)
# JCA : Force set text colmn for gtk2
combobox.set_text_column(0)
self.entry = combobox.get_child()
self.entry.connect('focus-out-event', self.focus_out)
self.entry.connect('activate', self.activate)
label.set_mnemonic_widget(self.entry)
combobox.connect('changed', self.changed)
self.entry.set_property('activates_default', True)
self._format = format_
if revision:
self.entry.set_text(datetime_strftime(revision, self._format))
self._value = revision
active = -1
else:
self._value = None
active = 0
list_store.append(('', ''))
for i, (rev, id_, name) in enumerate(revisions, 1):
list_store.append((datetime_strftime(rev, self._format), name))
if rev == revision:
active = i
combobox.set_active(active)
cell = gtk.CellRendererText()
combobox.pack_start(cell, True)
combobox.add_attribute(cell, 'text', 1)
hbox.pack_start(combobox, expand=True, fill=True)
combobox.set_entry_text_column(0)
self.win.vbox.pack_start(hbox, expand=True, fill=True)
self.win.show_all()
def destroy(self, action=None):
if self.toolbar_box.get_children():
toolbar = self.toolbar_box.get_children()[0]
self.toolbar_box.remove(toolbar)
super(WizardForm, self).destroy(action=action)
if action == 'reload menu':
RPCContextReload(Main().sig_win_menu)
elif action == 'reload context':
RPCContextReload()
def create(view_ids, model, res_id=False, domain=None,
context=None, order=None, mode=None, name=False, limit=None,
search_value=None, icon=None, tab_domain=None):
from tryton.gui import Main
if context is None:
context = {}
if model:
from form import Form
win = Form(model, res_id, domain, order=order, mode=mode,
view_ids=(view_ids or []), context=context, name=name,
limit=limit, search_value=search_value, tab_domain=tab_domain)
else:
from board import Board
win = Board(model, view_ids and view_ids[0] or None,
context=context, name=name)
win.icon = icon
Main.get_main().win_add(win, hide_current=Window.hide_current,
allow_similar=Window.allow_similar)
def __init__(self):
self.parent = get_toplevel_window()
self.win = Gtk.Dialog(title=_('Limit'),
transient_for=self.parent,
modal=True,
destroy_with_parent=True)
Main().add_window(self.win)
cancel_button = self.win.add_button(set_underline(_("Cancel")),
Gtk.ResponseType.CANCEL)
cancel_button.set_image(
IconFactory.get_image('tryton-cancel', Gtk.IconSize.BUTTON))
cancel_button.set_always_show_image(True)
ok_button = self.win.add_button(set_underline(_("OK")),
Gtk.ResponseType.OK)
ok_button.set_image(
IconFactory.get_image('tryton-ok', Gtk.IconSize.BUTTON))
ok_button.set_always_show_image(True)
self.win.set_default_response(Gtk.ResponseType.OK)
self.win.set_icon(GNUHEALTH_ICON)
self.win.vbox.set_spacing(3)
self.win.vbox.pack_start(Gtk.Label(label=_('Search Limit Settings')),
expand=False,
fill=True,
padding=0)
self.win.vbox.pack_start(Gtk.HSeparator(),
expand=True,
fill=True,
padding=0)
hbox = Gtk.HBox(spacing=3)
label = Gtk.Label(label=_('Limit:'))
hbox.pack_start(label, expand=True, fill=True, padding=0)
adjustment = Gtk.Adjustment(value=CONFIG['client.limit'],
lower=1,
upper=sys.maxsize,
step_incr=10,
page_incr=100)
self.spin_limit = Gtk.SpinButton()
self.spin_limit.configure(adjustment, climb_rate=1, digits=0)
self.spin_limit.set_numeric(False)
self.spin_limit.set_activates_default(True)
label.set_mnemonic_widget(self.spin_limit)
hbox.pack_start(self.spin_limit, expand=True, fill=True, padding=0)
self.win.vbox.pack_start(hbox, expand=True, fill=True, padding=0)
self.win.show_all()
def create_tabcontent(self):
self.buttons = {}
self.menu_buttons = {}
self.tooltips = common.Tooltips()
self.accel_group = Main().accel_group
self.widget = Gtk.VBox(spacing=3)
self.widget.show()
title_box = self.make_title_bar()
self.widget.pack_start(title_box, expand=False, fill=True, padding=3)
self.toolbar = self.create_toolbar(self.get_toolbars())
# JCA : Allow to hide buttons through the context
if not self.screen.context.get('disable_main_toolbar', None):
self.toolbar.show_all()
self.widget.pack_start(self.toolbar,
expand=False,
fill=True,
padding=0)
viewport = Gtk.Viewport()
viewport.set_shadow_type(Gtk.ShadowType.NONE)
viewport.add(self.widget_get())
viewport.show()
self.scrolledwindow = Gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(Gtk.ShadowType.NONE)
self.scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.widget.pack_start(self.scrolledwindow,
expand=True,
fill=True,
padding=0)
self.create_info_bar()
self.widget.pack_start(self.info_bar,
expand=False,
fill=True,
padding=0)
def __init__(self, name=''):
if not name:
name = _('Wizard')
Wizard.__init__(self, name=name)
NoModal.__init__(self)
self.dia = gtk.Dialog(self.name, self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.dia)
self.dia.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dia.set_icon(TRYTON_ICON)
self.dia.set_deletable(False)
self.dia.connect('delete-event', lambda *a: True)
self.dia.connect('close', self.close)
self.dia.connect('response', self.response)
self.accel_group = gtk.AccelGroup()
self.dia.add_accel_group(self.accel_group)
self.dia.vbox.pack_start(self.widget, expand=True, fill=True)
self.register()
def create(model, **attributes):
from tryton.gui import Main
main = Main()
if not Window.allow_similar:
for other_page in main.pages:
if other_page.compare(model, attributes):
main.win_set(other_page)
return
if model:
from .form import Form
win = Form(model, **attributes)
else:
from .board import Board
win = Board(model, **attributes)
win.icon = attributes.get('icon')
main.win_add(win, hide_current=Window.hide_current)
def create_tabcontent(self):
self.buttons = {}
self.menu_buttons = {}
self.tooltips = common.Tooltips()
self.accel_group = Main().accel_group
self.widget = Gtk.VBox(spacing=3)
self.widget.show()
title_box = self.make_title_bar()
self.widget.pack_start(title_box, expand=False, fill=True, padding=3)
self.toolbar = self.create_toolbar(self.get_toolbars())
self.toolbar.show_all()
self.widget.pack_start(self.toolbar,
expand=False,
fill=True,
padding=0)
self.main = Gtk.HPaned()
self.main.show()
self.widget.pack_start(self.main, expand=True, fill=True, padding=0)
viewport = Gtk.Viewport()
viewport.set_shadow_type(Gtk.ShadowType.NONE)
viewport.add(self.widget_get())
viewport.show()
self.scrolledwindow = Gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(Gtk.ShadowType.NONE)
self.scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.main.pack1(self.scrolledwindow, resize=True, shrink=False)
self.create_info_bar()
self.widget.pack_start(self.info_bar,
expand=False,
fill=True,
padding=0)
def search_box(self, widget):
def window_hide(window, *args):
window.hide()
self.search_entry.grab_focus()
def key_press(widget, event):
if event.keyval == gtk.keysyms.Escape:
window_hide(widget)
return True
return False
def search():
self.search_window.hide()
text = ''
for label, entry in self.search_table.fields:
if isinstance(entry, gtk.ComboBox):
value = quote(entry.get_active_text()) or None
elif isinstance(entry, (Dates, Selection)):
value = entry.get_value()
else:
value = quote(entry.get_text()) or None
if value is not None:
text += quote(label) + ': ' + value + ' '
self.set_text(text)
self.do_search()
# Store text after doing the search
# because domain parser could simplify the text
self.last_search_text = self.get_text()
if not self.search_window:
self.search_window = gtk.Window()
Main().add_window(self.search_window)
self.search_window.set_transient_for(widget.get_toplevel())
self.search_window.set_type_hint(
gtk.gdk.WINDOW_TYPE_HINT_POPUP_MENU)
self.search_window.set_destroy_with_parent(True)
self.search_window.set_decorated(False)
self.search_window.set_deletable(False)
self.search_window.connect('delete-event', window_hide)
self.search_window.connect('key-press-event', key_press)
self.search_window.connect('focus-out-event', window_hide)
def toggle_window_hide(combobox, shown):
if combobox.props.popup_shown:
self.search_window.handler_block_by_func(window_hide)
else:
self.search_window.handler_unblock_by_func(window_hide)
vbox = gtk.VBox()
fields = [
f for f in self.screen.domain_parser.fields.values()
if f.get('searchable', True)
]
self.search_table = gtk.Table(rows=len(fields), columns=2)
self.search_table.set_homogeneous(False)
self.search_table.set_border_width(5)
self.search_table.set_row_spacings(2)
self.search_table.set_col_spacings(2)
# Fill table with fields
self.search_table.fields = []
for i, field in enumerate(fields):
label = gtk.Label(field['string'])
label.set_alignment(0.0, 0.0)
self.search_table.attach(label,
0,
1,
i,
i + 1,
yoptions=gtk.FILL)
yoptions = False
if field['type'] == 'boolean':
if hasattr(gtk, 'ComboBoxText'):
entry = gtk.ComboBoxText()
else:
entry = gtk.combo_box_new_text()
entry.connect('notify::popup-shown', toggle_window_hide)
entry.append_text('')
selections = (_('True'), _('False'))
for selection in selections:
entry.append_text(selection)
elif field['type'] == 'selection':
selections = tuple(x[1] for x in field['selection'])
entry = Selection(selections)
yoptions = gtk.FILL | gtk.EXPAND
elif field['type'] in ('date', 'datetime', 'time'):
date_format = common.date_format(
self.screen.context.get('date_format'))
if field['type'] == 'date':
entry = Dates(date_format)
elif field['type'] in ('datetime', 'time'):
time_format = PYSONDecoder({}).decode(field['format'])
if field['type'] == 'time':
entry = Times(time_format)
elif field['type'] == 'datetime':
entry = DateTimes(date_format, time_format)
entry.connect_activate(lambda *a: search())
entry.connect_combo(toggle_window_hide)
else:
entry = gtk.Entry()
entry.connect('activate', lambda *a: search())
label.set_mnemonic_widget(entry)
self.search_table.attach(entry,
1,
2,
i,
i + 1,
yoptions=yoptions)
self.search_table.fields.append((field['string'], entry))
scrolled = gtk.ScrolledWindow()
scrolled.add_with_viewport(self.search_table)
scrolled.set_shadow_type(gtk.SHADOW_NONE)
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox.pack_start(scrolled, expand=True, fill=True)
find_button = gtk.Button(_('Find'))
find_button.connect('clicked', lambda *a: search())
find_button.set_image(
common.IconFactory.get_image('tryton-search',
gtk.ICON_SIZE_SMALL_TOOLBAR))
hbuttonbox = gtk.HButtonBox()
hbuttonbox.set_spacing(5)
hbuttonbox.pack_start(find_button)
hbuttonbox.set_layout(gtk.BUTTONBOX_END)
vbox.pack_start(hbuttonbox, expand=False, fill=True)
self.search_window.add(vbox)
vbox.show_all()
new_size = list(
map(
sum,
list(
zip(self.search_table.size_request(),
scrolled.size_request()))))
self.search_window.set_default_size(*new_size)
parent = widget.get_toplevel()
widget_x, widget_y = widget.translate_coordinates(parent, 0, 0)
widget_allocation = widget.get_allocation()
# Resize the window to not be out of the parent
width, height = self.search_window.get_default_size()
allocation = parent.get_allocation()
delta_width = allocation.width - (widget_x + width)
delta_height = allocation.height - (widget_y +
widget_allocation.height + height)
if delta_width < 0:
width += delta_width
if delta_height < 0:
height += delta_height
self.search_window.resize(width, height)
# Move the window under the button
if hasattr(widget.window, 'get_root_coords'):
x, y = widget.window.get_root_coords(widget_allocation.x,
widget_allocation.y)
else:
x, y = widget.window.get_origin()
self.search_window.move(x, y + widget_allocation.height)
self.search_window.show()
self.search_window.grab_focus()
if self.last_search_text.strip() != self.get_text().strip():
for label, entry in self.search_table.fields:
if isinstance(entry, gtk.ComboBox):
entry.set_active(-1)
elif isinstance(entry, Dates):
entry.set_values(None, None)
elif isinstance(entry, Selection):
entry.treeview.get_selection().unselect_all()
else:
entry.set_text('')
if self.search_table.fields:
self.search_table.fields[0][1].grab_focus()
def __init__(self):
self.parent = get_toplevel_window()
self.win = Gtk.Dialog(title=_('Email'),
transient_for=self.parent,
modal=True,
destroy_with_parent=True)
Main().add_window(self.win)
cancel_button = self.win.add_button(set_underline(_("Cancel")),
Gtk.ResponseType.CANCEL)
cancel_button.set_image(
IconFactory.get_image('tryton-cancel', Gtk.IconSize.BUTTON))
cancel_button.set_always_show_image(True)
ok_button = self.win.add_button(set_underline(_("OK")),
Gtk.ResponseType.OK)
ok_button.set_image(
IconFactory.get_image('tryton-ok', Gtk.IconSize.BUTTON))
ok_button.set_always_show_image(True)
self.win.set_default_response(Gtk.ResponseType.OK)
self.win.set_icon(TRYTON_ICON)
self.win.vbox.set_spacing(3)
self.win.vbox.pack_start(Gtk.Label(_('Email Program Settings')),
expand=False,
fill=True,
padding=0)
self.win.vbox.pack_start(Gtk.HSeparator(),
expand=True,
fill=True,
padding=0)
hbox = Gtk.HBox(spacing=3)
label = Gtk.Label(label=_('Command Line:'))
hbox.pack_start(label, expand=True, fill=True, padding=0)
self.entry = Gtk.Entry()
self.entry.set_property('activates_default', True)
self.entry.set_width_chars(50)
self.entry.set_text(CONFIG['client.email'])
label.set_mnemonic_widget(label)
hbox.pack_start(self.entry, expand=True, fill=True, padding=0)
self.win.vbox.pack_start(hbox, expand=True, fill=True, padding=0)
label = Gtk.Label(label=_('Legend of Available Placeholders:'),
halign=Gtk.Align.START,
margin_top=10,
margin_bottom=5)
self.win.vbox.pack_start(label, expand=False, fill=True, padding=0)
hbox = Gtk.HBox(spacing=3)
vboxl = Gtk.VBox(homogeneous=True, spacing=3)
label = Gtk.Label(label=_('To:'), halign=Gtk.Align.START)
vboxl.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=_('CC:'), halign=Gtk.Align.START)
vboxl.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=_('Subject:'), halign=Gtk.Align.START)
vboxl.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=_('Body:'), halign=Gtk.Align.START)
vboxl.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=_('Attachment:'), halign=Gtk.Align.START)
vboxl.pack_start(label, expand=False, fill=False, padding=0)
vboxr = Gtk.VBox(homogeneous=True, spacing=3)
label = Gtk.Label(label=' ${to}', halign=Gtk.Align.START)
vboxr.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=' ${cc}', halign=Gtk.Align.START)
vboxr.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=' ${subject}', halign=Gtk.Align.START)
vboxr.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=' ${body}', halign=Gtk.Align.START)
vboxr.pack_start(label, expand=False, fill=False, padding=0)
label = Gtk.Label(label=' ${attachment}', halign=Gtk.Align.START)
vboxr.pack_start(label, expand=False, fill=False, padding=0)
hbox.pack_start(vboxl, expand=False, fill=False, padding=0)
hbox.pack_start(vboxr, expand=False, fill=False, padding=0)
self.win.vbox.pack_start(hbox, expand=True, fill=True, padding=0)
self.win.show_all()
def sig_win_close(self, widget):
Main.get_main().sig_win_close(widget)
def sig_win_close(self, widget):
Main().sig_win_close(widget)
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_label = gtk.Label(_('Today'))
today_button = gtk.ToolButton(today_label)
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton(arrow_left, "go left")
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_icon_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.set_display_options(
gtk.CALENDAR_SHOW_HEADING |
gtk.CALENDAR_SHOW_WEEK_NUMBERS |
gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
gtkcal_item = goocanvas.Widget(widget=gtkcal)
gtkcal_item.set_property('visibility', goocanvas.ITEM_INVISIBLE)
goocalendar.get_root_item().add_child(gtkcal_item)
self.gtkcal = gtkcal
self.gtkcal_item = gtkcal_item
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton(arrow_right, "go right")
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton(arrow_left, "next year")
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton(arrow_right, "next year")
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
month_button = gtk.RadioToolButton(week_button)
month_button.set_label(_('Month View'))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
month_button.set_active(True)
self.insert(month_button, -1)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_label = gtk.Label(_('Today'))
today_button = gtk.ToolButton(today_label)
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton(arrow_left, "go left")
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_icon_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.set_display_options(
gtk.CALENDAR_SHOW_HEADING |
gtk.CALENDAR_SHOW_WEEK_NUMBERS |
gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
gtkcal_item = goocanvas.Widget(widget=gtkcal)
gtkcal_item.set_property('visibility', goocanvas.ITEM_INVISIBLE)
goocalendar.get_root_item().add_child(gtkcal_item)
self.gtkcal = gtkcal
self.gtkcal_item = gtkcal_item
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton(arrow_right, "go right")
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton(arrow_left, "next year")
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton(arrow_right, "next year")
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
month_button = gtk.RadioToolButton(week_button)
month_button.set_label(_('Month View'))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
month_button.set_active(True)
self.insert(month_button, -1)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def __init__(self, model, callback, sel_multi=True, context=None,
domain=None, order=None, view_ids=None,
views_preload=None, new=True, title='', exclude_field=None):
NoModal.__init__(self)
if view_ids is None:
view_ids = []
if views_preload is None:
views_preload = {}
self.domain = domain or []
self.context = context or {}
self.order = order
self.view_ids = view_ids
self.views_preload = views_preload
self.sel_multi = sel_multi
self.callback = callback
self.title = title
self.exclude_field = exclude_field
self.win = Gtk.Dialog(
title=_('Search'), transient_for=self.parent,
destroy_with_parent=True)
Main().add_window(self.win)
self.win.set_icon(TRYTON_ICON)
self.win.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.win.set_default_response(Gtk.ResponseType.APPLY)
self.win.connect('response', self.response)
self.win.set_default_size(*self.default_size())
self.accel_group = Gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
self.but_cancel = self.win.add_button(
set_underline(_("Cancel")), Gtk.ResponseType.CANCEL)
self.but_cancel.set_image(common.IconFactory.get_image(
'tryton-cancel', Gtk.IconSize.BUTTON))
self.but_cancel.set_always_show_image(True)
self.but_find = self.win.add_button(
set_underline(_("Search")), Gtk.ResponseType.APPLY)
self.but_find.set_image(common.IconFactory.get_image(
'tryton-search', Gtk.IconSize.BUTTON))
self.but_find.set_always_show_image(True)
if new and common.MODELACCESS[model]['create']:
self.but_new = self.win.add_button(
set_underline(_("New")), Gtk.ResponseType.ACCEPT)
self.but_new.set_image(common.IconFactory.get_image(
'tryton-create', Gtk.IconSize.BUTTON))
self.but_new.set_always_show_image(True)
self.but_new.set_accel_path('<tryton>/Form/New', self.accel_group)
self.but_ok = self.win.add_button(
set_underline(_("OK")), Gtk.ResponseType.OK)
self.but_ok.set_image(common.IconFactory.get_image(
'tryton-ok', Gtk.IconSize.BUTTON))
self.but_ok.set_always_show_image(True)
self.but_ok.add_accelerator(
'clicked', self.accel_group, Gdk.KEY_Return,
Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE)
hbox = Gtk.HBox()
hbox.show()
self.win.vbox.pack_start(hbox, expand=False, fill=True, padding=0)
self.win.vbox.pack_start(
Gtk.HSeparator(), expand=False, fill=True, padding=0)
self.screen = Screen(model, domain=domain, mode=['tree'], order=order,
context=context, view_ids=view_ids, views_preload=views_preload,
row_activate=self.sig_activate, readonly=True)
self.view = self.screen.current_view
# Prevent to set tree_state
self.screen.tree_states_done.add(id(self.view))
sel = self.view.treeview.get_selection()
self.win.set_title(_('Search %s') % self.title)
if not sel_multi:
sel.set_mode(Gtk.SelectionMode.SINGLE)
else:
sel.set_mode(Gtk.SelectionMode.MULTIPLE)
self.win.vbox.pack_start(
self.screen.widget, expand=True, fill=True, padding=0)
self.screen.widget.show()
self.model_name = model
self.register()
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_button = gtk.ToolButton()
today_button.set_label(_('Today'))
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK,
gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton()
go_back.set_icon_widget(arrow_left)
go_back.set_label(_("go back"))
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_label_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
self.__cal_popup = gtk.Window(gtk.WINDOW_POPUP)
self.__cal_popup.set_events(self.__cal_popup.get_events()
| gtk.gdk.KEY_PRESS_MASK)
self.__cal_popup.set_resizable(False)
self.__cal_popup.connect('delete-event', self.on_cal_popup_closed)
self.__cal_popup.connect('key-press-event',
self.on_cal_popup_key_pressed)
self.__cal_popup.connect('button-press-event',
self.on_cal_popup_button_pressed)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.connect('day-selected-double-click',
self.on_gtkcal_day_selected_double_click)
gtkcal.set_display_options(gtk.CALENDAR_SHOW_HEADING
| gtk.CALENDAR_SHOW_WEEK_NUMBERS
| gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
self.__cal_popup.add(gtkcal)
gtkcal.show()
self.gtkcal = gtkcal
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton()
go_forward.set_icon_widget(arrow_right)
go_forward.set_label(_("go forward"))
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton()
previous_year.set_icon_widget(arrow_left)
previous_year.set_label(_("previous year"))
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton()
next_year.set_icon_widget(arrow_right)
next_year.set_label(_("next year"))
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
if hasattr(gtk.RadioToolButton, 'new_from_widget'):
month_button = gtk.RadioToolButton.new_from_widget(week_button)
else:
month_button = gtk.RadioToolButton(week_button)
month_button.set_label_widget(gtk.Label(_('Month View')))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK,
gtk.ACCEL_VISIBLE)
self.insert(month_button, -1)
buttons = {'month': month_button, 'week': week_button}
buttons[self.goocalendar.view].set_active(True)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main().accel_group
today_button = Gtk.ToolButton()
today_button.set_label(_('Today'))
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator(
"clicked", self.accel_group, Gdk.KEY_t,
Gdk.ModifierType.MODIFIER_MASK, Gtk.AccelFlags.VISIBLE)
self.insert(today_button, -1)
arrow_left = IconFactory.get_image('tryton-arrow-left')
go_back = Gtk.ToolButton()
go_back.set_icon_widget(arrow_left)
go_back.set_label(_("go back"))
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = Gtk.Label(
width_chars=10, max_width_chars=10, ellipsize=True)
self.current_page = Gtk.ToggleToolButton()
self.current_page.set_label_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
self.__cal_popup = Gtk.Window(type=Gtk.WindowType.POPUP)
self.__cal_popup.set_events(
self.__cal_popup.get_events() | Gdk.EventMask.KEY_PRESS_MASK)
self.__cal_popup.set_resizable(False)
self.__cal_popup.connect('delete-event', self.on_cal_popup_closed)
self.__cal_popup.connect(
'key-press-event', self.on_cal_popup_key_pressed)
self.__cal_popup.connect(
'button-press-event', self.on_cal_popup_button_pressed)
gtkcal = Gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.connect(
'day-selected-double-click',
self.on_gtkcal_day_selected_double_click)
gtkcal.set_display_options(
Gtk.CalendarDisplayOptions.SHOW_HEADING |
Gtk.CalendarDisplayOptions.SHOW_WEEK_NUMBERS |
Gtk.CalendarDisplayOptions.SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
self.__cal_popup.add(gtkcal)
gtkcal.show()
self.gtkcal = gtkcal
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = IconFactory.get_image('tryton-arrow-right')
go_forward = Gtk.ToolButton()
go_forward.set_icon_widget(arrow_right)
go_forward.set_label(_("go forward"))
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = IconFactory.get_image('tryton-arrow-left')
previous_year = Gtk.ToolButton()
previous_year.set_icon_widget(arrow_left)
previous_year.set_label(_("previous year"))
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = Gtk.Label(width_chars=4)
current_year = Gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = IconFactory.get_image('tryton-arrow-right')
next_year = Gtk.ToolButton()
next_year.set_icon_widget(arrow_right)
next_year.set_label(_("next year"))
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = Gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
day_button = Gtk.RadioToolButton()
day_button.set_label(_('Day View'))
day_button.connect("clicked", self.on_day_button_clicked)
day_button.add_accelerator(
"clicked", self.accel_group, Gdk.KEY_d,
Gdk.ModifierType.MODIFIER_MASK, Gtk.AccelFlags.VISIBLE)
self.insert(day_button, -1)
week_button = Gtk.RadioToolButton.new_from_widget(day_button)
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator(
"clicked", self.accel_group, Gdk.KEY_w,
Gdk.ModifierType.MODIFIER_MASK, Gtk.AccelFlags.VISIBLE)
self.insert(week_button, -1)
month_button = Gtk.RadioToolButton.new_from_widget(week_button)
month_button.set_label_widget(Gtk.Label(label=_('Month View')))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator(
"clicked", self.accel_group, Gdk.KEY_m,
Gdk.ModifierType.MODIFIER_MASK, Gtk.AccelFlags.VISIBLE)
self.insert(month_button, -1)
buttons = {
'month': month_button,
'week': week_button,
'day': day_button,
}
buttons[self.goocalendar.view].set_active(True)
self.update_displayed_date()
self.set_style(Gtk.ToolbarStyle.ICONS)
def __init__(self, *args, **kwargs):
super(WinCSV, self).__init__(*args, **kwargs)
self.dialog = Gtk.Dialog(transient_for=self.parent,
destroy_with_parent=True)
Main().add_window(self.dialog)
self.dialog.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
self.dialog.set_default_size(*self.default_size())
self.dialog.connect('response', self.response)
dialog_vbox = Gtk.VBox()
hbox_mapping = Gtk.HBox(homogeneous=True)
dialog_vbox.pack_start(hbox_mapping, expand=True, fill=True, padding=0)
frame_fields = Gtk.Frame()
frame_fields.set_shadow_type(Gtk.ShadowType.NONE)
viewport_fields = Gtk.Viewport()
scrolledwindow_fields = Gtk.ScrolledWindow()
scrolledwindow_fields.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
viewport_fields.add(scrolledwindow_fields)
frame_fields.add(viewport_fields)
label_all_fields = Gtk.Label(label=_('<b>All fields</b>'),
use_markup=True)
frame_fields.set_label_widget(label_all_fields)
hbox_mapping.pack_start(frame_fields,
expand=True,
fill=True,
padding=0)
vbox_buttons = Gtk.VBox(homogeneous=False, spacing=10)
vbox_buttons.set_border_width(5)
hbox_mapping.pack_start(vbox_buttons,
expand=False,
fill=True,
padding=0)
button_add = Gtk.Button(label=_('_Add'),
stock=None,
use_underline=True)
button_add.set_image(
IconFactory.get_image('tryton-add', Gtk.IconSize.BUTTON))
button_add.set_always_show_image(True)
button_add.connect_after('clicked', self.sig_sel)
vbox_buttons.pack_start(button_add,
expand=False,
fill=False,
padding=0)
button_remove = Gtk.Button(label=_('_Remove'),
stock=None,
use_underline=True)
button_remove.set_image(
IconFactory.get_image('tryton-remove', Gtk.IconSize.BUTTON))
button_remove.set_always_show_image(True)
button_remove.connect_after('clicked', self.sig_unsel)
vbox_buttons.pack_start(button_remove,
expand=False,
fill=False,
padding=0)
button_remove_all = Gtk.Button(label=_('_Clear'),
stock=None,
use_underline=True)
button_remove_all.set_image(
IconFactory.get_image('tryton-clear', Gtk.IconSize.BUTTON))
button_remove_all.set_always_show_image(True)
button_remove_all.connect_after('clicked', self.sig_unsel_all)
vbox_buttons.pack_start(button_remove_all,
expand=False,
fill=False,
padding=0)
hseparator_buttons = Gtk.HSeparator()
vbox_buttons.pack_start(hseparator_buttons,
expand=False,
fill=False,
padding=3)
self.add_buttons(vbox_buttons)
frame_fields_selected = Gtk.Frame()
frame_fields_selected.set_shadow_type(Gtk.ShadowType.NONE)
viewport_fields_selected = Gtk.Viewport()
scrolledwindow_fields_selected = Gtk.ScrolledWindow()
scrolledwindow_fields_selected.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
viewport_fields_selected.add(scrolledwindow_fields_selected)
frame_fields_selected.add(viewport_fields_selected)
label_fields_selected = Gtk.Label(label=_('<b>Fields selected</b>'),
use_markup=True)
frame_fields_selected.set_label_widget(label_fields_selected)
hbox_mapping.pack_start(frame_fields_selected,
expand=True,
fill=True,
padding=0)
frame_csv_param = Gtk.Frame()
frame_csv_param.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
dialog_vbox.pack_start(frame_csv_param,
expand=False,
fill=True,
padding=0)
vbox_csv_param = Gtk.VBox()
vbox_csv_param.props.margin = 7
frame_csv_param.add(vbox_csv_param)
self.add_chooser(vbox_csv_param)
expander_csv = Gtk.Expander()
vbox_csv_param.pack_start(expander_csv,
expand=False,
fill=True,
padding=0)
label_csv_param = Gtk.Label(label=_('CSV Parameters'))
expander_csv.set_label_widget(label_csv_param)
box = Gtk.HBox(spacing=3)
expander_csv.add(box)
label_csv_delimiter = Gtk.Label(label=_('Delimiter:'),
halign=Gtk.Align.END)
box.pack_start(label_csv_delimiter, expand=False, fill=True, padding=0)
self.csv_delimiter = Gtk.Entry()
self.csv_delimiter.set_max_length(1)
if os.name == 'nt' and ',' == locale.localeconv()['decimal_point']:
delimiter = ';'
else:
delimiter = ','
self.csv_delimiter.set_text(delimiter)
self.csv_delimiter.set_width_chars(1)
label_csv_delimiter.set_mnemonic_widget(self.csv_delimiter)
box.pack_start(self.csv_delimiter, expand=False, fill=True, padding=0)
label_csv_quotechar = Gtk.Label(label=_("Quote char:"),
halign=Gtk.Align.END)
box.pack_start(label_csv_quotechar, expand=False, fill=True, padding=0)
self.csv_quotechar = Gtk.Entry()
self.csv_quotechar.set_text("\"")
self.csv_quotechar.set_width_chars(1)
label_csv_quotechar.set_mnemonic_widget(self.csv_quotechar)
box.pack_start(self.csv_quotechar, expand=False, fill=True, padding=0)
label_csv_enc = Gtk.Label(label=_("Encoding:"), halign=Gtk.Align.END)
box.pack_start(label_csv_enc, expand=False, fill=True, padding=0)
self.csv_enc = Gtk.ComboBoxText()
for i, encoding in enumerate(encodings):
self.csv_enc.append_text(encoding)
if ((os.name == 'nt' and encoding == 'cp1252')
or (os.name != 'nt' and encoding == 'utf_8')):
self.csv_enc.set_active(i)
label_csv_enc.set_mnemonic_widget(self.csv_enc)
box.pack_start(self.csv_enc, expand=False, fill=True, padding=0)
self.csv_locale = Gtk.CheckButton(label=_("Use locale format"))
self.csv_locale.set_active(True)
box.pack_start(self.csv_locale, expand=False, fill=True, padding=0)
self.add_csv_header_param(box)
button_cancel = self.dialog.add_button(set_underline(_("Cancel")),
Gtk.ResponseType.CANCEL)
button_cancel.set_image(
IconFactory.get_image('tryton-cancel', Gtk.IconSize.BUTTON))
button_ok = self.dialog.add_button(set_underline(_("OK")),
Gtk.ResponseType.OK)
button_ok.set_image(
IconFactory.get_image('tryton-ok', Gtk.IconSize.BUTTON))
self.dialog.vbox.pack_start(dialog_vbox,
expand=True,
fill=True,
padding=0)
self.view1 = Gtk.TreeView()
self.view1.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
self.view1.connect('row-expanded', self.on_row_expanded)
scrolledwindow_fields.add(self.view1)
self.view2 = Gtk.TreeView()
self.view2.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
scrolledwindow_fields_selected.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)
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)
self.model2 = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING)
self.model_populate(self._get_fields(self.model))
self.view1.set_model(self.model1)
self.view1.connect('row-activated', self.sig_sel)
self.view2.set_model(self.model2)
self.view2.connect('row-activated', self.sig_unsel)
self.dialog.show_all()
self.show()
self.register()
if sys.platform != 'darwin':
self.view2.drag_source_set(
Gdk.ModifierType.BUTTON1_MASK | Gdk.ModifierType.BUTTON3_MASK,
[
Gtk.TargetEntry.new('EXPORT_TREE',
Gtk.TargetFlags.SAME_WIDGET, 0)
], Gdk.DragAction.MOVE)
self.view2.drag_dest_set(Gtk.DestDefaults.ALL, [
Gtk.TargetEntry.new('EXPORT_TREE', Gtk.TargetFlags.SAME_WIDGET,
0)
], Gdk.DragAction.MOVE)
self.view2.connect('drag-begin', self.drag_begin)
self.view2.connect('drag-motion', self.drag_motion)
self.view2.connect('drag-drop', self.drag_drop)
self.view2.connect("drag-data-get", self.drag_data_get)
self.view2.connect('drag-data-received', self.drag_data_received)
self.view2.connect('drag-data-delete', self.drag_data_delete)
drag_column = Gtk.TreeViewColumn()
drag_column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
cell_pixbuf = Gtk.CellRendererPixbuf()
cell_pixbuf.props.pixbuf = IconFactory.get_pixbuf('tryton-drag')
drag_column.pack_start(cell_pixbuf, expand=False)
self.view2.insert_column(drag_column, 0)
def __init__(self, user, callback):
NoModal.__init__(self)
self.callback = callback
self.win = Gtk.Dialog(title=_('Preferences'),
transient_for=self.parent,
destroy_with_parent=True)
Main().add_window(self.win)
self.win.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.win.set_icon(TRYTON_ICON)
self.accel_group = Gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
self.but_cancel = self.win.add_button(set_underline(_("Cancel")),
Gtk.ResponseType.CANCEL)
self.but_cancel.set_image(
IconFactory.get_image('tryton-cancel', Gtk.IconSize.BUTTON))
self.but_cancel.set_always_show_image(True)
self.but_ok = self.win.add_button(set_underline(_("OK")),
Gtk.ResponseType.OK)
self.but_ok.set_image(
IconFactory.get_image('tryton-ok', Gtk.IconSize.BUTTON))
self.but_ok.set_always_show_image(True)
self.but_ok.add_accelerator('clicked', self.accel_group,
Gdk.KEY_Return,
Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.VISIBLE)
self.win.set_default_response(Gtk.ResponseType.OK)
self.win.connect('response', self.response)
try:
view = RPCExecute('model', 'res.user',
'get_preferences_fields_view')
except RPCException:
self.win.destroy()
self.win = None
return
title = Gtk.Label(label=_('Edit User Preferences'))
title.show()
self.win.vbox.pack_start(title, expand=False, fill=True, padding=0)
self.screen = Screen('res.user', mode=[])
# Reset readonly set automaticly by MODELACCESS
self.screen.readonly = False
self.screen.group.readonly = False
self.screen.group.skip_model_access = True
self.screen.add_view(view)
self.screen.switch_view()
self.screen.new(default=False)
try:
preferences = RPCExecute('model', 'res.user', 'get_preferences',
False)
except RPCException:
self.win.destroy()
self.win = None
return
self.screen.current_record.cancel()
self.screen.current_record.set(preferences)
self.screen.current_record.id = rpc._USER
self.screen.current_record.validate(softvalidation=True)
self.screen.display(set_cursor=True)
self.screen.widget.show()
self.win.vbox.pack_start(self.screen.widget,
expand=True,
fill=True,
padding=0)
self.win.set_title(_('Preference'))
self.win.set_default_size(*self.default_size())
self.register()
self.win.show()
def __init__(self, widget, languages, readonly):
NoModal.__init__(self)
self.widget = widget
self.win = gtk.Dialog(_('Translation'), self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.win)
self.win.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.win.set_icon(TRYTON_ICON)
self.win.connect('response', self.response)
parent_allocation = self.parent.get_allocation()
self.win.set_default_size(-1, min(400, parent_allocation.height))
self.accel_group = gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
cancel_button = self.win.add_button(set_underline(_("Cancel")),
gtk.RESPONSE_CANCEL)
cancel_button.set_image(
common.IconFactory.get_image('tryton-cancel',
gtk.ICON_SIZE_BUTTON))
cancel_button.set_always_show_image(True)
ok_button = self.win.add_button(set_underline(_("OK")),
gtk.RESPONSE_OK)
ok_button.set_image(
common.IconFactory.get_image('tryton-ok', gtk.ICON_SIZE_BUTTON))
ok_button.set_always_show_image(True)
ok_button.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Return, gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
tooltips = common.Tooltips()
self.widgets = {}
table = gtk.Table(len(languages), 4)
table.set_homogeneous(False)
table.set_col_spacings(3)
table.set_row_spacings(2)
table.set_border_width(1)
for i, language in enumerate(languages):
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL:
label = _(':') + language['name']
else:
label = language['name'] + _(':')
label = gtk.Label(label)
label.set_alignment(1.0, 0.0 if self.widget.expand else 0.5)
table.attach(label, 0, 1, i, i + 1, xoptions=gtk.FILL, xpadding=2)
context = dict(
language=language['code'],
fuzzy_translation=False,
)
try:
value = RPCExecute('model',
self.widget.record.model_name,
'read', [self.widget.record.id],
[self.widget.field_name],
context={'language': language['code']
})[0][self.widget.field_name]
except RPCException:
return
context['fuzzy_translation'] = True
try:
fuzzy_value = RPCExecute(
'model',
self.widget.record.model_name,
'read', [self.widget.record.id], [self.widget.field_name],
context=context)[0][self.widget.field_name]
except RPCException:
return
widget = self.widget.translate_widget()
label.set_mnemonic_widget(widget)
self.widget.translate_widget_set(widget, fuzzy_value)
self.widget.translate_widget_set_readonly(widget, True)
yopt = 0
if self.widget.expand:
yopt = gtk.EXPAND | gtk.FILL
table.attach(widget, 1, 2, i, i + 1, yoptions=yopt)
editing = gtk.CheckButton()
editing.connect('toggled', self.editing_toggled, widget)
editing.props.sensitive = not readonly
tooltips.set_tip(editing, _('Edit'))
table.attach(editing, 2, 3, i, i + 1, xoptions=gtk.FILL)
fuzzy = gtk.CheckButton()
fuzzy.set_active(value != fuzzy_value)
fuzzy.props.sensitive = False
tooltips.set_tip(fuzzy, _('Fuzzy'))
table.attach(fuzzy, 4, 5, i, i + 1, xoptions=gtk.FILL)
self.widgets[language['code']] = (widget, editing, fuzzy)
tooltips.enable()
vbox = gtk.VBox()
vbox.pack_start(table, self.widget.expand, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(vbox)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.add(viewport)
self.win.vbox.pack_start(scrolledwindow, True, True)
self.win.show_all()
self.register()
self.show()
def end(self, callback=None):
super(WizardForm, self).end(callback=callback)
Main()._win_del(self.widget)
def destroy(self, action=None):
super(WizardForm, self).destroy(action=action)
if action == 'reload menu':
RPCContextReload(Main().sig_win_menu)
elif action == 'reload context':
RPCContextReload()
def __init__(self,
screen,
callback,
view_type='form',
new=False,
many=0,
domain=None,
context=None,
save_current=False,
title='',
rec_name=None):
tooltips = common.Tooltips()
NoModal.__init__(self)
self.screen = screen
self.callback = callback
self.many = many
self.domain = domain
self.context = context
self.save_current = save_current
self.title = title
self.prev_view = self.screen.current_view
self.screen.screen_container.alternate_view = True
self.screen.switch_view(view_type=view_type)
if self.screen.current_view.view_type != view_type:
self.destroy()
return
if new:
self.screen.new(rec_name=rec_name)
self.win = gtk.Dialog(_('Link'), self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
Main().add_window(self.win)
self.win.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.win.set_icon(TRYTON_ICON)
self.win.set_deletable(False)
self.win.connect('delete-event', lambda *a: True)
self.win.connect('close', self.close)
self.win.connect('delete-event', self.delete_event)
self.win.connect('response', self.response)
allocation = self.parent.get_allocation()
width, height, = allocation.width, allocation.height
if self.parent != self.sensible_widget:
width = max(width - 150, 0)
height = max(height - 150, 0)
self.win.set_default_size(width, height)
self.accel_group = gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
readonly = self.screen.readonly or self.screen.group.readonly
self.but_ok = None
self.but_new = None
self._initial_value = None
if view_type == 'form':
if new:
label, icon = _("Delete"), 'tryton-delete'
else:
label, icon = _("Cancel"), 'tryton-cancel'
self._initial_value = self.screen.current_record.get_eval()
self.but_cancel = self.win.add_button(set_underline(label),
gtk.RESPONSE_CANCEL)
self.but_cancel.set_image(
common.IconFactory.get_image(icon, gtk.ICON_SIZE_BUTTON))
self.but_cancel.set_always_show_image(True)
if new and self.many:
self.but_new = self.win.add_button(set_underline(_("New")),
gtk.RESPONSE_ACCEPT)
self.but_new.set_image(
common.IconFactory.get_image('tryton-create',
gtk.ICON_SIZE_BUTTON))
self.but_new.set_always_show_image(True)
self.but_new.set_accel_path('<tryton>/Form/New', self.accel_group)
if self.save_current:
self.but_ok = gtk.Button(_('_Save'), use_underline=True)
self.but_ok.set_image(
common.IconFactory.get_image('tryton-save',
gtk.ICON_SIZE_BUTTON))
self.but_ok.set_always_show_image(True)
self.but_ok.set_accel_path('<tryton>/Form/Save', self.accel_group)
self.but_ok.set_can_default(True)
self.but_ok.show()
self.win.add_action_widget(self.but_ok, gtk.RESPONSE_OK)
if not new:
self.but_ok.props.sensitive = False
else:
self.but_ok = self.win.add_button(set_underline(_("OK")),
gtk.RESPONSE_OK)
self.but_ok.set_image(
common.IconFactory.get_image('tryton-ok',
gtk.ICON_SIZE_BUTTON))
self.but_ok.set_always_show_image(True)
self.but_ok.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Return, gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.win.set_default_response(gtk.RESPONSE_OK)
self.win.set_title(self.title)
title = gtk.Label()
title.modify_font(pango.FontDescription("bold 12"))
title.set_label(common.ellipsize(self.title, 80))
tooltips.set_tip(title, self.title)
title.set_padding(20, 3)
title.set_alignment(0.0, 0.5)
title.set_size_request(0, -1) # Allow overflow
title.set_max_width_chars(1)
title.set_ellipsize(pango.ELLIPSIZE_END)
title.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000"))
title.show()
hbox = gtk.HBox()
hbox.pack_start(title, expand=True, fill=True)
hbox.show()
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame.add(hbox)
frame.show()
eb = gtk.EventBox()
eb.add(frame)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffffff"))
eb.show()
self.win.vbox.pack_start(eb, expand=False, fill=True, padding=3)
if view_type == 'tree':
hbox = gtk.HBox(homogeneous=False, spacing=0)
access = common.MODELACCESS[screen.model_name]
but_switch = gtk.Button()
tooltips.set_tip(but_switch, _('Switch'))
but_switch.connect('clicked', self.switch_view)
but_switch.add(
common.IconFactory.get_image('tryton-switch',
gtk.ICON_SIZE_SMALL_TOOLBAR))
but_switch.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(but_switch, expand=False, fill=False)
self.but_pre = gtk.Button()
tooltips.set_tip(self.but_pre, _('Previous'))
self.but_pre.connect('clicked', self._sig_previous)
self.but_pre.add(
common.IconFactory.get_image('tryton-back',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_pre.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_pre, expand=False, fill=False)
self.label = gtk.Label('(0,0)')
hbox.pack_start(self.label, expand=False, fill=False)
self.but_next = gtk.Button()
tooltips.set_tip(self.but_next, _('Next'))
self.but_next.connect('clicked', self._sig_next)
self.but_next.add(
common.IconFactory.get_image('tryton-forward',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_next.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_next, expand=False, fill=False)
hbox.pack_start(gtk.VSeparator(), expand=False, fill=True)
if domain is not None:
self.wid_text = gtk.Entry()
self.wid_text.set_property('width_chars', 13)
self.wid_text.connect('activate', self._sig_activate)
self.wid_text.connect('focus-out-event', self._focus_out)
hbox.pack_start(self.wid_text, expand=True, fill=True)
self.but_add = gtk.Button()
tooltips.set_tip(self.but_add, _('Add'))
self.but_add.connect('clicked', self._sig_add)
self.but_add.add(
common.IconFactory.get_image('tryton-add',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_add.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_add, expand=False, fill=False)
if not access['read'] or readonly:
self.but_add.set_sensitive(False)
self.but_remove = gtk.Button()
tooltips.set_tip(self.but_remove, _('Remove <Del>'))
self.but_remove.connect('clicked', self._sig_remove, True)
self.but_remove.add(
common.IconFactory.get_image('tryton-remove',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_remove.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_remove, expand=False, fill=False)
if not access['read'] or readonly:
self.but_remove.set_sensitive(False)
hbox.pack_start(gtk.VSeparator(), expand=False, fill=True)
self.but_new = gtk.Button()
tooltips.set_tip(self.but_new, _('Create a new record <F3>'))
self.but_new.connect('clicked', self._sig_new)
self.but_new.add(
common.IconFactory.get_image('tryton-create',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_new.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_new, expand=False, fill=False)
if not access['create'] or readonly:
self.but_new.set_sensitive(False)
self.but_del = gtk.Button()
tooltips.set_tip(self.but_del, _('Delete selected record <Del>'))
self.but_del.connect('clicked', self._sig_remove, False)
self.but_del.add(
common.IconFactory.get_image('tryton-delete',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_del.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_del, expand=False, fill=False)
if not access['delete'] or readonly:
self.but_del.set_sensitive(False)
self.but_undel = gtk.Button()
tooltips.set_tip(self.but_undel,
_('Undelete selected record <Ins>'))
self.but_undel.connect('clicked', self._sig_undelete)
self.but_undel.add(
common.IconFactory.get_image('tryton-undo',
gtk.ICON_SIZE_SMALL_TOOLBAR))
self.but_undel.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(self.but_undel, expand=False, fill=False)
if not access['delete'] or readonly:
self.but_undel.set_sensitive(False)
but_switch.props.sensitive = screen.number_of_views > 1
tooltips.enable()
alignment = gtk.Alignment(1.0)
alignment.add(hbox)
alignment.show_all()
self.win.vbox.pack_start(alignment, expand=False, fill=True)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_placement(gtk.CORNER_TOP_LEFT)
scroll.set_shadow_type(gtk.SHADOW_NONE)
scroll.show()
self.win.vbox.pack_start(scroll, expand=True, fill=True)
scroll.add(self.screen.screen_container.alternate_viewport)
self.create_info_bar()
self.win.vbox.pack_start(self.info_bar, False, True)
if view_type == 'tree':
self.screen.signal_connect(self, 'record-message', self._sig_label)
self.screen.screen_container.alternate_viewport.connect(
'key-press-event', self.on_keypress)
if self.save_current and not new:
self.screen.signal_connect(self, 'record-message',
self.activate_save)
self.screen.signal_connect(self, 'record-modified',
self.activate_save)
self.register()
self.show()
self.screen.display()
self.screen.current_view.set_cursor()
