def menuTool(self):
self.fileMenusub = gtk.Menu()
agr = gtk.AccelGroup()
self.fileMenuitem = {}
# self.fileMenuitem[0] = gtk.MenuItem("Nowy")
self.fileMenuitem[0] = gtk.ImageMenuItem(gtk.STOCK_NEW, agr)
key, mod = gtk.accelerator_parse("<Control>N")
agr.connect_group(key, mod, gtk.ACCEL_VISIBLE, self.fileInterpret)
self.fileMenuitem[0].add_accelerator("activate", agr, key, mod,
gtk.ACCEL_VISIBLE)
# self.fileMenuitem[1] = gtk.MenuItem("Otworz")
self.fileMenuitem[1] = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr)
key, mod = gtk.accelerator_parse("<Control>O")
self.fileMenuitem[1].add_accelerator("activate", agr, key, mod,
gtk.ACCEL_VISIBLE)
# self.fileMenuitem[2] = gtk.MenuItem("Zapisz")
self.fileMenuitem[2] = gtk.ImageMenuItem(gtk.STOCK_SAVE, agr)
key, mod = gtk.accelerator_parse("<Control>S")
self.fileMenuitem[2].add_accelerator("activate", agr, key, mod,
gtk.ACCEL_VISIBLE)
# self.fileMenuitem[3] = gtk.MenuItem("Zamknij")
self.fileMenuitem[3] = gtk.ImageMenuItem(gtk.STOCK_CLOSE, agr)
key, mod = gtk.accelerator_parse("<Control>E")
self.fileMenuitem[3].add_accelerator("activate", agr, key, mod,
gtk.ACCEL_VISIBLE)
self.deviceMenusub = gtk.Menu()
self.deviceMenuItem = {}
self.deviceMenuItem[0] = gtk.MenuItem("Wybierz urządzenie")
self.deviceMenusub.append(self.deviceMenuItem[0])
self.fileMenuitem[0].connect("activate", self.fileInterpret, 'new')
self.fileMenuitem[1].connect("activate", self.fileInterpret, 'open')
self.fileMenuitem[2].connect("activate", self.fileInterpret, 'save')
self.fileMenuitem[3].connect("activate", gtk.main_quit)
self.deviceMenuItem[0].connect("activate", self.setDevice)
self.deviceMenu = gtk.MenuItem("Narzędzia")
self.fileMenu = gtk.MenuItem("Plik")
self.fileMenu.set_submenu(self.fileMenusub)
self.deviceMenu.set_submenu(self.deviceMenusub)
self.menu_bar = gtk.MenuBar()
self.menu_bar.append(self.fileMenu)
self.menu_bar.append(self.deviceMenu)
self.fileMenu.show()
self.fileMenusub.show()
self.menu_bar.show()
for i in range(0, len(self.fileMenuitem)):
self.fileMenusub.append(self.fileMenuitem[i])
self.fileMenuitem[i].show()
self.deviceMenu.show()
self.deviceMenusub.show()
self.deviceMenuItem[0].show()
return self.menu_bar
def __init__(self):
# Init WIndow
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_default_size(800, 500)
self.window.set_resizable(True)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
# Focus Check
self.window.set_events(gtk.gdk.FOCUS_CHANGE_MASK)
self.window.connect("focus_in_event", self.infocus)
self.window.connect("focus_out_event", self.notinfocus)
self.window.set_border_width(10)
self.window.set_title("Sost-Sat Data Logger")
# Init Quit Button
self.button_quit = gtk.Button("Quit")
self.button_quit.connect_object("clicked", gtk.Widget.destroy,
self.window)
self.button_view = gtk.Button("Connect")
self.button_view.connect("clicked", self.connect, None)
self.button_clear = gtk.Button("Clear")
self.button_clear.connect("clicked", self.clear_text, None)
# Init Text View
self.textview = gtk.TextView()
self.textview.set_editable(True)
self.textbuffer = self.textview.get_buffer()
self.textview.set_overwrite(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
# Init ScrollWindow
self.scrolledwindow = gtk.ScrolledWindow(hadjustment=None,
vadjustment=None)
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.add(self.textview)
# Init Label
self.label_baud = gtk.Label("Baud Rate : ")
self.label_port = gtk.Label("Port : ")
self.label_input = gtk.Label("Input : ")
self.label_about = gtk.Label(
" Nano-Sat Serial Data Logger\n \n Version :7.1.0 \n Designed @ SOST Lab \n Designed By Priyashraba Misra\n International Instiute of Information Technology\n Pune "
)
self.label_about.set_justify(gtk.JUSTIFY_CENTER)
# Combo for Baud, Port
self.combobox_baud = gtk.combo_box_new_text()
for i in self.baud_rates:
self.combobox_baud.append_text(i)
self.combobox_baud.set_active(0)
self.combobox_port = gtk.combo_box_new_text()
for i in self.port:
self.combobox_port.append_text(i)
self.combobox_port.set_active(1)
#Text entru for USART write
self.entry_usart = gtk.Entry(max=0)
self.entry_usart.connect("changed", self.transmitUSART)
self.entry_usart.set_sensitive(False)
#HBox for Text
self.hbox1 = gtk.HBox(False, 0)
self.hbox1.pack_start(self.scrolledwindow,
expand=True,
fill=True,
padding=0)
#HBox for Text
self.hbox2 = gtk.HBox(False, 0)
self.hbox2.pack_start(self.label_input,
expand=False,
fill=False,
padding=0)
self.hbox2.pack_start(self.entry_usart,
expand=True,
fill=True,
padding=0)
#HBox for Menus
self.hbox3 = gtk.HBox(False, 0)
self.hbox3.pack_start(self.label_baud,
expand=False,
fill=False,
padding=0)
self.hbox3.pack_start(self.combobox_baud,
expand=True,
fill=False,
padding=0)
self.hbox3.pack_start(self.label_port,
expand=False,
fill=False,
padding=5)
self.hbox3.pack_start(self.combobox_port,
expand=True,
fill=False,
padding=5)
self.hbox3.pack_start(self.button_view,
expand=True,
fill=False,
padding=5)
self.hbox3.pack_start(self.button_clear,
expand=True,
fill=False,
padding=5)
self.hbox3.pack_start(self.button_quit,
expand=True,
fill=False,
padding=5)
#Vbox for stacking HBox(s)
self.vbox1 = gtk.VBox(False, 10)
self.vbox1.pack_start(self.hbox1, expand=True, fill=True, padding=5)
self.vbox1.pack_start(self.hbox2, expand=False, fill=False, padding=5)
self.vbox1.pack_start(self.hbox3, expand=False, fill=False, padding=5)
#Drawing area for graph
self.area = gtk.DrawingArea()
self.area.set_size_request(600, 300)
self.area.connect("expose-event", self.area_expose_cb)
#self.area_expose_cb(self.area)
self.area.show()
#button for drawing area
self.button_plottemp = gtk.Button("Start Plot")
self.button_plottemp.connect("clicked", self.plotTemp, None)
self.button_plotclear = gtk.Button("Clear Plot")
self.button_plotclear.connect("clicked", self.plotClear, None)
#hbox and vbox for drawing area
self.hbox4 = gtk.HBox()
self.hbox4.pack_start(self.area, expand=False, fill=False, padding=5)
self.hbox5 = gtk.HBox()
self.hbox5.pack_start(self.button_plottemp,
expand=False,
fill=False,
padding=5)
self.hbox5.pack_start(self.button_plotclear,
expand=False,
fill=False,
padding=5)
self.vbox2 = gtk.VBox()
self.vbox2.pack_start(self.hbox4, expand=True, fill=True, padding=5)
self.vbox2.pack_start(self.hbox5, expand=True, fill=True, padding=5)
# Notebook for Tabs
self.label_notepage1 = gtk.Label("Terminal")
self.label_notepage2 = gtk.Label("Plot")
self.label_notepage3 = gtk.Label("About")
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_TOP)
self.notebook.append_page(self.vbox1, self.label_notepage1)
self.notebook.append_page(self.vbox2, self.label_notepage2)
self.notebook.append_page(self.label_about, self.label_notepage3)
self.notebook.show()
# add to window
self.window.add(self.notebook)
# add accelerators
self.accel_group = gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
self.button_view.add_accelerator("clicked", self.accel_group, ord('c'),
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.button_quit.add_accelerator("clicked", self.accel_group, ord('x'),
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
#show all
self.button_view.show()
self.button_quit.show()
self.button_clear.show()
self.button_plottemp.show()
self.button_plotclear.show()
self.scrolledwindow.show()
self.textview.show()
self.hbox1.show()
self.hbox2.show()
self.hbox3.show()
self.hbox4.show()
self.hbox5.show()
self.vbox1.show()
self.vbox2.show()
self.window.show()
self.label_baud.show()
self.label_port.show()
self.label_input.show()
self.label_about.show()
self.label_notepage1.show()
self.label_notepage2.show()
self.label_notepage3.show()
self.combobox_baud.show()
self.combobox_port.show()
self.entry_usart.show()
# Init Timeout
#timer = gobject.timeout_add(100,self.display)
idle1 = gobject.idle_add(self.display)
def __init__(self,
model,
callback,
sel_multi=True,
context=None,
domain=None,
view_ids=None,
views_preload=None,
new=True,
title=''):
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.view_ids = view_ids
self.views_preload = views_preload
self.sel_multi = sel_multi
self.callback = callback
self.title = title
self.win = gtk.Dialog(_('Search'), self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
self.win.set_icon(TRYTON_ICON)
self.win.set_default_response(gtk.RESPONSE_APPLY)
self.win.connect('response', self.response)
self.accel_group = gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
self.but_cancel = self.win.add_button(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL)
self.but_find = self.win.add_button(gtk.STOCK_FIND, gtk.RESPONSE_APPLY)
if new and common.MODELACCESS[model]['create']:
self.but_new = self.win.add_button(gtk.STOCK_NEW,
gtk.RESPONSE_ACCEPT)
self.but_new.set_accel_path('<tryton>/Form/New', self.accel_group)
self.but_ok = self.win.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
self.but_ok.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Return, gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
hbox = gtk.HBox()
hbox.show()
self.win.vbox.pack_start(hbox, expand=False, fill=True)
self.win.vbox.pack_start(gtk.HSeparator(), expand=False, fill=True)
scrollwindow = gtk.ScrolledWindow()
scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.win.vbox.pack_start(scrollwindow, expand=True, fill=True)
self.screen = Screen(model,
domain=domain,
mode=['tree'],
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.SELECTION_SINGLE)
else:
sel.set_mode(gtk.SELECTION_MULTIPLE)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.screen.widget)
self.screen.widget.show()
viewport.show()
scrollwindow.add(viewport)
scrollwindow.show()
self.model_name = model
self.win.set_default_size(700, 500)
self.register()
sensible_allocation = self.sensible_widget.get_allocation()
self.win.set_default_size(sensible_allocation.width,
sensible_allocation.height)
def __init__(self,
model,
id=None,
attrs=None,
domain=None,
context=None,
window=None,
view_ids=None,
target=False,
view_type=['form'],
help={}):
if attrs is None:
attrs = {}
if domain is None:
domain = []
if context is None:
context = {}
if not window:
window = service.LocalService('gui.main').window
self.dia = gtk.Dialog(
'OpenERP', window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.window = window
if not target:
self.dia.set_property('default-width', 760)
self.dia.set_property('default-height', 500)
self.dia.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dia.set_icon(common.OPENERP_ICON)
self.accel_group = gtk.AccelGroup()
self.dia.add_accel_group(self.accel_group)
self.but_cancel = self.dia.add_button(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL)
self.but_cancel.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Escape,
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.but_ok = self.dia.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
self.but_ok.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Return,
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
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)
self.dia.vbox.pack_start(scroll, expand=True, fill=True)
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
scroll.add(vp)
self.screen = Screen(model,
view_ids=view_ids,
domain=domain,
context=context,
window=self.dia,
view_type=view_type,
help=help)
if id:
self.screen.load([id])
else:
self.screen.new()
if ('string' in attrs) and attrs['string']:
self.dia.set_title(self.dia.get_title() + ' - ' + attrs['string'])
elif self.screen.current_view:
self.dia.set_title(self.dia.get_title() + ' - ' +
self.screen.current_view.title)
vp.add(self.screen.widget)
width, height = self.screen.screen_container.size_get()
window_width, window_height = window.get_size()
dia_width, dia_height = self.dia.get_size()
widget_width = min(window_width - 20, max(dia_width, width + 30))
if target:
widget_height = min(window_height - 60, height + 10)
else:
widget_height = min(window_height - 60, height + 20)
vp.set_size_request(widget_width, widget_height)
self.dia.show_all()
self.screen.display()
def __init__(self):
gtk.Dialog.__init__(
self,
title=_("Program Information"),
parent=common.get_main_window(),
flags=gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK,
gtk.RESPONSE_OK))
self.set_border_width(5)
self.accel_group = gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.hbox = gtk.HBox()
self.hbox.set_spacing(6)
self.vbox.pack_start(self.hbox, expand=True, fill=True, padding=0)
# Icon setup
self.vbox_icon = gtk.VBox()
self.hbox.pack_start(self.vbox_icon,
expand=False,
fill=False,
padding=0)
self.button_icon = gtk.Button()
self.button_icon.set_accel_path
self.button_icon.add_accelerator('grab-focus', self.accel_group,
ord('i'), gtk.gdk.MOD1_MASK, 0)
self.vbox_icon.pack_start(self.button_icon,
expand=False,
fill=False,
padding=0)
self.button_icon_aspectframe = gtk.AspectFrame()
self.button_icon_aspectframe.set_shadow_type(gtk.SHADOW_NONE)
self.button_icon.add(self.button_icon_aspectframe)
self.icon = gtk.Image()
self.icon.filename = None
self.button_icon_aspectframe.add(self.icon)
# Fields setup
self.table = gtk.Table()
self.table.set_row_spacings(6)
self.table.set_col_spacings(6)
self.hbox.pack_start(self.table, expand=True, fill=True, padding=0)
row = 0
self.label_type = gtk.Label(_('_Type:'))
self.label_type.set_use_underline(True)
self.label_type.set_alignment(1.0, 0.5)
self.combobox_type = gtk.combo_box_new_text()
self.combobox_type.append_text(_('Application'))
self.combobox_type.append_text(_('Application in Terminal'))
self.label_type.set_mnemonic_widget(self.combobox_type)
self.table.attach(self.label_type, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.combobox_type, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_name = gtk.Label(_('_Name:'))
self.label_name.set_use_underline(True)
self.label_name.set_alignment(1.0, 0.5)
self.entry_name = gtk.Entry()
self.label_name.set_mnemonic_widget(self.entry_name)
self.table.attach(self.label_name, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_name, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_command = gtk.Label(_('Comm_and:'))
self.label_command.set_use_underline(True)
self.label_command.set_alignment(1.0, 0.5)
self.entry_command = gtk.Entry()
self.label_command.set_mnemonic_widget(self.entry_command)
self.button_command = gtk.Button(_('_Browse...'))
self.table.attach(self.label_command, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_command, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
self.table.attach(self.button_command, 2, 3, row, row + 1, gtk.FILL, 0)
row += 1
self.label_comment = gtk.Label(_('Co_mment:'))
self.label_comment.set_use_underline(True)
self.label_comment.set_alignment(1.0, 0.5)
self.entry_comment = gtk.Entry()
self.label_comment.set_mnemonic_widget(self.entry_comment)
self.table.attach(self.label_comment, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_comment, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_uninstall = gtk.Label(_('_Uninstall:'))
self.label_uninstall.set_use_underline(True)
self.label_uninstall.set_alignment(1.0, 0.5)
self.entry_uninstall = gtk.Entry()
self.label_uninstall.set_mnemonic_widget(self.entry_uninstall)
self.table.attach(self.label_uninstall, 0, 1, row, row + 1, gtk.FILL,
0)
self.table.attach(self.entry_uninstall, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_category = gtk.Label(_('C_ategory:'))
self.label_category.set_use_underline(True)
self.label_category.set_alignment(1.0, 0.5)
self.combobox_category = gtk.ComboBoxEntry()
self.combobox_category_completion = gtk.EntryCompletion()
self.combobox_category.child.set_completion(
self.combobox_category_completion)
self.combobox_category_model = gtk.ListStore(str)
self.combobox_category.set_model(self.combobox_category_model)
self.combobox_category.set_text_column(0)
self.combobox_category_completion.set_model(
self.combobox_category_model)
self.combobox_category_completion.set_text_column(0)
for category in wine.common.XDG_MENU_CATEGORIES:
self.combobox_category_model.append((category, ))
self.label_category.set_mnemonic_widget(self.combobox_category)
self.checkbutton_showinmenu = gtk.CheckButton(_('_Show in menu'), True)
self.checkbutton_showinmenu.set_tooltip_text(
_("Note that the program may not show up in the menu until you have clicked ok"
))
self.table.attach(self.label_category, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.combobox_category, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
self.table.attach(self.checkbutton_showinmenu, 2, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_pulseaudio = gtk.Label(_('_PulseAudio:'))
self.label_pulseaudio.set_use_underline(True)
self.label_pulseaudio.set_alignment(1.0, 0.5)
self.checkbutton_pulseaudio = gtk.CheckButton(
_('_Disable PulseAudio whilst running'), True)
self.checkbutton_pulseaudio.set_tooltip_text(
_("Shut down PulseAudio when starting this program and start it again afterwards"
))
self.label_pulseaudio.set_mnemonic_widget(self.checkbutton_pulseaudio)
self.table.attach(self.label_pulseaudio, 0, 1, row, row + 1, gtk.FILL,
0)
self.table.attach(self.checkbutton_pulseaudio, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self._set_default_icon()
self.connect('delete-event', self._destroy)
self.connect('destroy-event', self._destroy)
self.set_deletable(False)
self.filechooser_command = FileChooserProgram()
self.filechooser_icon = FileChooserIcon()
self.button_command.connect('clicked', self._on_edit_program_command)
self.button_icon.connect('clicked', self._on_edit_program_icon)
self.filechooser_command.connect('response',
self._on_filechooser_command_response)
self.filechooser_icon.connect('response',
self._on_filechooser_icon_response)
def __init__(self, app):
self.app = app
self.scripts = {}
self.snipsdir = app.snipsdir
self.OSD = None
self.OSD_txt = ""
tb,tv = create_tbtv()
s = gtk.ScrolledWindow()
s.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC)
s.set_size_request(660,400)
s.add(tv)
s.show_all()
self.clinb = gtk.Notebook()
frame = gtk.Frame("Snippets")
self.snview,self.snmodel,self.scroll = make_cli_view(self)
self.snview.connect("row-activated", self.on_row_activated)
frame.add(self.scroll)
self.restore_state()
if len(self.scripts) == 0:
tab_lbl = TabLabel("New 1")
tab_lbl.connect("close-clicked", tab_lbl.on_tab_close_clicked, self.clinb, s, self.scripts, "script")
self.clinb.append_page(s, tab_lbl)
self.clinb.set_tab_reorderable(s, True)
self.clinb.show_all()
self.scripts[len(self.scripts)] = [tb,"New 1",tab_lbl]
mainhb = gtk.HBox()
mainhb.pack_start(self.clinb,1,1,0)
mainhb.pack_start(frame,0,0,0)
new_btn = gtk.Button("New")
open_btn = gtk.Button("Open")
save_btn = gtk.Button("Save")
run_btn = gtk.Button("Run")
hbox = gtk.HBox()
hbox.pack_start(new_btn,0,0,0)
hbox.pack_start(open_btn,0,0,0)
hbox.pack_start(save_btn,0,0,0)
hbox.pack_end(run_btn,0,0,0)
vbox = gtk.VBox()
vbox.pack_start(mainhb)
vbox.pack_start(hbox,0,0,0)
runwin = gtk.Window(gtk.WINDOW_TOPLEVEL)
# runwin.set_icon_from_file(os.path.join(self.app.execpath,"pixmaps/icon.png"))
accgrp = gtk.AccelGroup()
accgrp.connect_group(110, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #N
accgrp.connect_group(111, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #O
accgrp.connect_group(114, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #R
accgrp.connect_group(115, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #S
accgrp.connect_group(105, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #I
accgrp.connect_group(117, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.on_key_press) #U
runwin.add_accel_group(accgrp)
runwin.set_resizable(True)
runwin.set_border_width(2)
runwin.add(vbox)
runwin.set_title("colupatr CLI")
runwin.connect ("destroy", self.del_runwin)
run_btn.connect("button-press-event",self.cli_on_run)
new_btn.connect("button-press-event",self.cli_on_new)
open_btn.connect("button-press-event",self.cli_on_open)
save_btn.connect("button-press-event",self.cli_on_save)
runwin.show_all()
tv.grab_focus()
self.app.run_win = runwin
def __init__(self):
gtk.Window.__init__(self)
self.set_title('PDF Quench %s' % VERSION)
self.set_default_size(900, 800)
self.connect('delete_event', self.__on_delete_window)
vbox = gtk.VBox()
self.add(vbox)
# toolbar
toolbar = gtk.Toolbar()
buttons = (
(gtk.ToolButton(gtk.STOCK_OPEN), self.__open_btn_clicked, 'Open'),
(gtk.ToolButton(gtk.STOCK_SAVE), self.__save_btn_clicked, 'Save'),
(gtk.ToolButton(gtk.STOCK_ZOOM_IN), self.__on_zoom_in_btn_clicked,
'Zoom In'),
(gtk.ToolButton(gtk.STOCK_ZOOM_OUT),
self.__on_zoom_out_btn_clicked, 'Zoom Out'),
)
for button, callback, tooltip in buttons:
button.set_tooltip_text(tooltip)
button.connect_after('clicked', callback)
toolbar.insert(button, -1)
vbox.pack_start(toolbar, expand=False, fill=False, padding=0)
# main component
paned = gtk.HPaned()
paned.set_position(100)
vbox.pack_start(paned, expand=True, fill=True, padding=0)
self.__pages_model = gtk.ListStore(str, object)
self.__pages_view = gtk.TreeView(self.__pages_model)
self.__pages_view.set_enable_search(False)
self.__pages_view.get_selection().set_mode(gtk.SELECTION_SINGLE)
self.__pages_view.get_selection().connect_after(
'changed', self.__on_page_selected)
# columns
column = gtk.TreeViewColumn()
column.set_title('Pages')
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
renderer = gtk.CellRendererText()
column.pack_start(renderer, False)
column.add_attribute(renderer, 'text', 0)
column.set_cell_data_func(renderer, self.__render_page_number)
self.__pages_view.append_column(column)
sw = gtk.ScrolledWindow()
sw.add(self.__pages_view)
paned.add1(sw)
self.__zoom_level = DEFAULT_ZOOM_LEVEL
self.__canvas = goocanvas.Canvas()
self.__canvas.set_data('scale', ZOOM_LEVELS[self.__zoom_level])
self.__canvas.modify_base(gtk.STATE_NORMAL,
gtk.gdk.color_parse('#F0F0F0'))
self.__dragging = False
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
frame.set_border_width(10)
paned.add2(frame)
sw = gtk.ScrolledWindow()
sw.add(self.__canvas)
frame.add(sw)
accels = gtk.AccelGroup()
accels.connect_group(ord('o'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED,
self.__on_ctrl_o_pressed)
accels.connect_group(ord('O'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED,
self.__on_ctrl_o_pressed)
accels.connect_group(ord('s'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED,
self.__on_ctrl_s_pressed)
accels.connect_group(ord('S'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED,
self.__on_ctrl_s_pressed)
accels.connect_group(ord('+'), 0, gtk.ACCEL_LOCKED,
self.__on_zoom_in_pressed)
accels.connect_group(ord('-'), 0, gtk.ACCEL_LOCKED,
self.__on_zoom_out_pressed)
self.add_accel_group(accels)
self.__current_page = None
self.__pdf_filename = None
self.__pdf_document = None
self.__n_pages = None
self.__pdf_view = None
self.__default_crop = CropSetting()
self.__odd_crop = CropSetting(self.__default_crop)
self.__even_crop = CropSetting(self.__default_crop)
def __init__(self, parent):
self.db = parent.db
parent_window = parent._main_window
self.view_star = parent.view_star # LEMONJuicerGUI.view_star()
self.toggle_toolbar_button = parent.set_finding_chart_button_active
self.builder = gtk.Builder()
self.builder.add_from_file(glade.FINDING_CHART_DIALOG)
self.dialog = self.builder.get_object('finding-chart-dialog')
self.dialog.set_resizable(True)
self.dialog.set_title("Finding Chart: %s" % self.db.field_name)
# gtk.RESPONSE_PREFERENCES doesn't exist: use gtk.RESPONSE_OK
self.dialog.add_button(gtk.STOCK_PREFERENCES, gtk.RESPONSE_OK)
self.dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.dialog.set_default_response(gtk.RESPONSE_CLOSE)
# Connect to the accelerators of the parent window
self.dialog.add_accel_group(parent.global_accelators)
# This private variable stores whether the gtk.Dialog is currently
# visible or not. It is update to True and False when the show() and
# hide() methods are called, respectively.
self._currently_shown = False
# The matplotlib figure...
matplotlib_container = self.builder.get_object('matplotlib-container')
self.image_box = self.builder.get_object('image-container-box')
self.figure = matplotlib.figure.Figure()
canvas = FigureCanvas(self.figure)
self.image_box.pack_start(canvas)
# ... and the navigation toolbar
self.navigation_box = self.builder.get_object('navigation-toolbar-box')
self.navig = NavigationToolbar(canvas, self.image_box.get_window())
self.navigation_box.pack_start(self.navig)
matplotlib_container.show_all()
# Use the field name as the suggested filename of the FileChooserDialog
# when the user clicks on the 'Save' button on the navigation toolbar.
# See the docstring of app.StarDetailsGUI.update_file_selector_name()
# for an explanation on why we are monkey-patching this method.
canvas.get_window_title = lambda: self.db.field_name
self.dialog.set_transient_for(parent_window)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
ax1 = self.figure.add_subplot(111)
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
# Temporarily save to disk the FITS file used as a reference frame
path = self.db.mosaic
atexit.register(util.clean_tmp_files, path)
self.wcs = astropy.wcs.WCS(path)
with pyfits.open(path) as hdu:
data = hdu[0].data
# Ignore any NaN pixels
self.data_min = numpy.nanmin(data)
self.data_max = numpy.nanmax(data)
self.aplpy_plot = aplpy.FITSFigure(path, figure=self.figure)
self.figure.canvas.mpl_connect('button_press_event',
self.mark_closest_star)
self.aplpy_plot.show_grayscale()
self.aplpy_plot.add_grid()
self.aplpy_plot.grid.set_alpha(0.2)
# Create a PreferencesDialog object, whose __init__() method reads Vmin
# and Vmax from the LEMONdB or, in case these values are not stored in
# the database, uses the values computed by FITSFigure.show_grayscale()
# and stored in the APLpyNormalize object. After the PreferencesDialog
# is created we can call its normalize_plot() method for the first time
# in order to apply the normalization parameters to the finding chart.
#
# Note: we must create the PreferencesDialog *after* show_grayscale()
# has been called, because until then the underlying APLpyNormalize
# object (i.e., aplpy.FITSFigure.image.norm) does not exist, and the
# __init__() method of the PreferencesDialog class needs to access to
# it if the values of Vmin and Vmax cannot be read from the LEMONdB.
assert hasattr(self.aplpy_plot.image, 'norm')
self.preferences_dialog = PreferencesDialog(self)
self.preferences_dialog.normalize_plot()
# The dialog has always the same width; the height is adjusted
# proportionally depending on the dimensions of the FITS image.
size = data.shape[::-1]
size_ratio = size[1] / size[0]
new_size = self.WIDTH, int(self.WIDTH * size_ratio)
self.dialog.resize(*new_size)
# We cannot run() the dialog because it blocks in a recursive main
# loop, while we want it to be non-modal. Therefore, we need to show()
# it. But this means that we cannot get the response ID directly from
# run(), so we have to connect to the dialog 'response' event.
self.dialog.connect('response', self.handle_response)
# Don't destroy the gtk.Dialog if we click on the window's close button
self.dialog.connect('delete-event', self.on_delete_event)
# Button to, when a star is selected, view its details. We want to
# render a stock button, STOCK_GO_FORWARD, but with a different label.
# In order to achieve this, we register our own stock icon, reusing
# the image from the existing stock item, as seen in the PyGTK FAQ:
# http://faq.pygtk.org/index.py?req=show&file=faq09.005.htp
STOCK_GOTO_STAR = 'goto-star-custom'
gtk.stock_add([(STOCK_GOTO_STAR, '_Go to Star', 0, 0, None)])
factory = gtk.IconFactory()
factory.add_default()
style = self.dialog.get_style()
icon_set = style.lookup_icon_set(gtk.STOCK_GO_FORWARD)
factory.add(STOCK_GOTO_STAR, icon_set)
args = STOCK_GOTO_STAR, gtk.RESPONSE_APPLY
self.goto_button = self.dialog.add_button(*args)
self.goto_button.set_sensitive(False)
# <Ctrl>G also activates the 'Go to Star' button
accelerators = gtk.AccelGroup()
self.dialog.add_accel_group(accelerators)
key, modifier = gtk.accelerator_parse('<Control>G')
args = 'activate', accelerators, key, modifier, gtk.ACCEL_VISIBLE
self.goto_button.add_accelerator(*args)
def build_menu(self, window, items):
accel_group = gtk.AccelGroup()
item_factory = gtk.ItemFactory(gtk.Menu, "<pydoc>", accel_group)
item_factory.create_items(items)
self.item_factory = item_factory
return item_factory.get_widget("<pydoc>")
def __init__(self):
QTWindow.__init__(self, 'source', 'Source')
self.connect("delete-event", self._delete_event_cb)
self._find_string = ''
self._find_ofs = 0
menu = [{
'name':
_L('File'),
'submenu': [{
'name': _L('Open'),
'action': self._open_cb,
'accel': '<Control>o'
}, {
'name': _L('Close'),
'action': self._close_cb,
'accel': '<Control>x'
}, {
'name': _L('Save'),
'action': self._save_cb,
'accel': '<Control>s'
}, {
'name': _L('Save as'),
'action': self._save_as_cb
}, {
'name': _L('Run'),
'action': self._run_clicked_cb,
'accel': '<Control>r'
}]
}, {
'name':
_L('Edit'),
'submenu': [
{
'name': _L('Find'),
'action': self._find_cb,
'accel': '<Control>f'
},
{
'name': _L('Find next'),
'action': self._find_next_cb,
'accel': '<Control>n'
},
{
'name': _L('Find previous'),
'action': self._find_prev_cb,
'accel': '<Control>p'
},
]
}]
self._accel_group = gtk.AccelGroup()
self.add_accel_group(self._accel_group)
self._menu = gui.build_menu(menu, accelgroup=self._accel_group)
# Run menu
self._name = gtk.Entry()
self._run_button = gtk.Button(_L('Run'))
self._run_button.connect('clicked', self._run_clicked_cb)
self._options = gui.pack_hbox(
[gtk.Label(_L('Name')), self._name, self._run_button])
# Directory and edit panes
self._file_info = {}
self._notebook = gtk.Notebook()
self._dir_pane = DirPane()
self._dir_pane.dir_browser.connect('file-activated',
self._file_activated_cb)
self._panes = gtk.HPaned()
self._panes.add1(self._dir_pane)
self._panes.add2(self._notebook)
# Put everything together
self._vbox = gtk.VBox()
self._vbox.pack_start(self._menu, False, False)
self._vbox.pack_start(self._options, False, False)
self._vbox.pack_start(self._panes, True, True)
self.add(self._vbox)
self._vbox.show_all()
def __init__(self, *args, **kwargs):
gtk.Window.__init__(self, *args, **kwargs)
self.set_title('Spell check')
self.set_default_size(350, 200)
self._checker = None
self._numContext = 40
self.errors = None
# create accel group
accel_group = gtk.AccelGroup()
self.add_accel_group(accel_group)
# list of widgets to disable if there's no spell error left
self._conditional_widgets = []
conditional = self._conditional_widgets.append
# layout
mainbox = gtk.VBox(spacing=5)
hbox = gtk.HBox(spacing=5)
self.add(mainbox)
mainbox.pack_start(hbox, padding=5)
box1 = gtk.VBox(spacing=5)
hbox.pack_start(box1, padding=5)
conditional(box1)
# unreconized word
text_view_lable = gtk.Label('Unreconized word')
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
box1.pack_start(text_view_lable, False, False)
text_view = gtk.TextView()
text_view.set_wrap_mode(gtk.WRAP_WORD)
text_view.set_editable(False)
text_view.set_cursor_visible(False)
self.error_text = text_view.get_buffer()
text_buffer = text_view.get_buffer()
text_buffer.create_tag("fg_black", foreground="black")
text_buffer.create_tag("fg_red", foreground="red")
box1.pack_start(text_view)
# Change to
change_to_box = gtk.HBox()
box1.pack_start(change_to_box, False, False)
change_to_label = gtk.Label('Change to:')
self.replace_text = gtk.Entry()
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
change_to_box.pack_start(change_to_label, False, False)
change_to_box.pack_start(self.replace_text)
# scrolled window
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box1.pack_start(sw)
self.suggestion_list_view = create_list_view('Suggestions')
self.suggestion_list_view.connect("button_press_event",
self._onButtonPress)
self.suggestion_list_view.connect("cursor-changed",
self._onSuggestionChanged)
sw.add(self.suggestion_list_view)
#---Buttons---#000000#FFFFFF----------------------------------------------------
button_box = gtk.VButtonBox()
hbox.pack_start(button_box, False, False)
# Ignore
button = gtk.Button("Ignore")
button.connect("clicked", self._onIgnore)
button.add_accelerator("activate", accel_group, gtk.keysyms.Return, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_start(button)
conditional(button)
# Ignore all
button = gtk.Button("Ignore All")
button.connect("clicked", self._onIgnoreAll)
button_box.pack_start(button)
conditional(button)
# Replace
button = gtk.Button("Replace")
button.connect("clicked", self._onReplace)
button_box.pack_start(button)
conditional(button)
# Replace all
button = gtk.Button("Replace All")
button.connect("clicked", self._onReplaceAll)
button_box.pack_start(button)
conditional(button)
# Recheck button
button = gtk.Button("_Add")
button.connect("clicked", self._onAdd)
button_box.pack_start(button)
conditional(button)
# Close button
button = gtk.Button(stock=gtk.STOCK_CLOSE)
button.connect("clicked", self._onClose)
button.add_accelerator("activate", accel_group, gtk.keysyms.Escape, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_end(button)
# dictionary label
self._dict_lable = gtk.Label('')
mainbox.pack_start(self._dict_lable, False, False, padding=5)
mainbox.show_all()
def __init__(self, filenames):
self.editors = weakref.WeakKeyDictionary()
self.todo = []
self.tip = Tip()
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_LEFT)
self.notebook.set_scrollable(True)
open_vbox = gtk.VBox(False, 5)
label = gtk.Label('open')
label.set_alignment(0.0, 0.0)
label.show()
open_vbox.pack_start(label, False, False)
open_entry, scroller = make_file_completion(self.open_editor)
open_vbox.pack_start(open_entry, True, True)
self.notebook.append_page(scroller, open_vbox)
def focusin(*etc):
self.notebook.set_current_page(self.notebook.page_num(scroller))
open_entry.grab_focus()
open_entry.connect('focus-in-event', focusin)
vbox = gtk.VBox(False, 5)
label = gtk.Label('line')
label.set_alignment(0.0, 0.0)
vbox.pack_start(label, False, False)
self.line_entry = gtk.Entry()
self.line_entry.connect('changed', self.line_edited)
self.line_entry.connect('activate', self.entry_activate)
vbox.pack_start(self.line_entry, False, False)
label = gtk.Label('find')
label.set_alignment(0.0, 0.0)
vbox.pack_start(label, False, False)
self.find_entry = gtk.Entry()
self.find_entry.connect('changed', self.find_edited)
self.find_entry.connect('activate', self.entry_activate)
allow_tabs_in_entry(self.find_entry)
vbox.pack_start(self.find_entry, False, False)
self.find_hbox = gtk.HBox(False, 0)
vbox.pack_start(self.find_hbox, False, False)
left = gtk.Button('prev')
left.connect('clicked', self.find_prev)
self.find_hbox.pack_start(left)
right = gtk.Button('next')
right.connect('clicked', self.find_next)
self.find_hbox.pack_start(right)
self.prefix_label = gtk.Label('prefix')
self.prefix_label.set_alignment(0.0, 0.0)
vbox.pack_start(self.prefix_label, False, False)
self.prefix_entry = gtk.Entry()
self.prefix_entry.connect('changed', self.prefix_edited)
self.prefix_entry.connect('activate', self.entry_activate)
allow_tabs_in_entry(self.prefix_entry) #!
vbox.pack_start(self.prefix_entry, False, False)
vbox.show_all()
page = gtk.Label('')
self.notebook.append_page(page, vbox)
def on_switch(widget, _, page_number):
if page_number > 0 and page_number == self.notebook.page_num(page):
self.notebook.emit_stop_by_name('switch-page')
self.notebook.connect('switch-page', on_switch)
#TODO:
#toolbox = gtk.Label('')
#label = gtk.Label('tools')
#label.set_alignment(0.0,0.0)
#self.notebook.append_page(toolbox, label)
self.window = gtk.Window()
self.window.resize(900, 700)
self.window.set_title('yaedit')
self.window.add(self.notebook)
def delete_event(*etc):
self.window.hide()
self.tip.show('Ctrl-Q')
gobject.timeout_add(TIP_TIMEOUT, lambda: self.window.destroy())
return True
self.window.connect('delete-event', delete_event)
self.accel_group = gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
self.accel_group.connect_group(ord('Q'), gtk.gdk.CONTROL_MASK, 0,
lambda *etc: self.window.destroy())
self.accel_group.connect_group(
ord('I'), gtk.gdk.CONTROL_MASK, 0,
lambda *etc: self.line_entry.grab_focus())
self.tip.add_click_tip(self.line_entry, 'Ctrl-I')
self.accel_group.connect_group(
ord('F'), gtk.gdk.CONTROL_MASK, 0,
lambda *etc: self.find_entry.grab_focus())
self.tip.add_click_tip(self.find_entry, 'Ctrl-F')
self.accel_group.connect_group(ord('O'), gtk.gdk.CONTROL_MASK, 0,
lambda *etc: open_entry.grab_focus())
self.tip.add_click_tip(open_entry, 'Ctrl-O')
def close_editor():
page = self.notebook.get_nth_page(self.notebook.get_current_page())
if page in self.editors:
page.destroy()
self.accel_group.connect_group(ord('W'), gtk.gdk.CONTROL_MASK, 0,
lambda *etc: close_editor())
def make_tab_focuser(x):
def focus_tab(*etc):
countdown = x
for i in xrange(self.notebook.get_n_pages()):
if self.notebook.get_nth_page(i) in self.editors:
countdown -= 1
if countdown == 0:
self.notebook.set_current_page(i)
return focus_tab
for i in range(1, 10):
self.accel_group.connect_group(ord(str(i)), gtk.gdk.MOD1_MASK, 0,
make_tab_focuser(i))
def prefix_focuser(*etc):
settings = self.prefix_entry.get_settings()
old = settings.get_property('gtk-entry-select-on-focus')
settings.set_property('gtk-entry-select-on-focus', False)
self.prefix_entry.grab_focus()
pos = 0
for char in self.prefix_entry.get_text():
if char not in ' \t': break
pos += 1
self.prefix_entry.set_position(pos)
settings.set_property('gtk-entry-select-on-focus', old)
self.accel_group.connect_group(ord('P'), gtk.gdk.CONTROL_MASK, 0,
prefix_focuser)
self.tip.add_click_tip(self.prefix_entry, 'Ctrl-P')
self.window.show_all()
self.find_hbox.hide()
self.busy = 0
self.last_active = None
self.search_required = False
self.search_matches = []
self.search_from = 0
for filename in filenames:
self.open_editor(filename)
if not filenames:
open_entry.grab_focus()
else:
self.notebook.set_current_page(0)
self.notebook.get_nth_page(0).child.grab_focus()
def timeout():
for editor in self.editors.values():
editor.sync_from_disk()
return True
gobject.timeout_add(1000, timeout)
self.refresh()
def __init__(self, frame):
""" Create NowPlayer interface """
# Build the window
self.frame = frame
self.accel_group = gtk.AccelGroup()
builder = gtk.Builder()
builder.set_translation_domain('nicotine')
builder.add_from_file(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "ui",
"nowplaying.ui"))
self.NowPlaying = builder.get_object("NowPlaying")
builder.connect_signals(self)
for i in builder.get_objects():
try:
self.__dict__[gtk.Buildable.get_name(i)] = i
except TypeError:
pass
self.NowPlaying.set_icon(self.frame.images["n"])
self.NowPlaying.set_transient_for(self.frame.MainWindow)
self.NowPlaying.add_accel_group(self.accel_group)
self.NowPlaying.connect("destroy", self.quit)
self.NowPlaying.connect("destroy-event", self.quit)
self.NowPlaying.connect("delete-event", self.quit)
self.NowPlaying.connect("key-press-event", self.OnKeyPress)
self.title_clear()
# Set the active radio button
config = self.frame.np.config.sections
self.player_replacers = []
self.OnNPPlayer(None)
self.SetPlayer(config["players"]["npplayer"])
# Default format list
self.NPFormat_List = gtk.ListStore(gobject.TYPE_STRING)
self.defaultlist = [
"$n", "$n ($f)", "$a - $t", "[$a] $t", "$a - $b - $t",
"$a - $b - $t ($l/$r KBps) from $y $c"
]
for item in self.defaultlist:
self.NPFormat_List.append([str(item)])
# Add custom formats
if config["players"]["npformatlist"] != []:
for item in config["players"]["npformatlist"]:
self.NPFormat_List.append([str(item)])
# Set the NPFormat model
self.NPFormat.set_entry_text_column(0)
self.NPFormat.set_model(self.NPFormat_List)
if config["players"]["npformat"] == "":
# If there's no default format in the config: set the first of the list
self.NPFormat.set_active(0)
else:
# If there's is a default format in the config: select the right item
for (i, v) in enumerate(self.NPFormat_List):
if v[0] == config["players"]["npformat"]:
self.NPFormat.set_active(i)
# Set the command from the config
self.NPCommand.set_text(config["players"]["npothercommand"])
def __init__(self, core, host=''):
super(reportWin, self).__init__()
self.TITLE = "Report"
self.uicore = core
self.host = host
# Window properties
self.connect("destroy", self.win_destroy)
self.set_size_request(800, 600)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title(self.TITLE)
# VBox for Menu and Textview
self.vbox = gtk.VBox()
# Menu
self.mb = gtk.MenuBar()
agr = gtk.AccelGroup()
self.add_accel_group(agr)
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
savi = gtk.ImageMenuItem(gtk.STOCK_SAVE, agr)
key, mod = gtk.accelerator_parse("S")
savi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(savi)
savi.connect("activate", self.save_report)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("Q")
exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(exit)
exit.connect("activate", self.win_destroy)
self.mb.append(filem)
# Add Menu to VBox
self.vbox.pack_start(self.mb, False, False, 0)
# Textview
self.reporttv = gtk.TextView()
self.reporttv.set_wrap_mode(gtk.WRAP_NONE)
self.reporttv.set_editable(False)
#self.reporttv.set_cursor_visible(False)
# Change text font
fontdesc = pango.FontDescription("MonoSpace 10")
#fontdesc = pango.FontDescription("Purisa 10")
self.reporttv.modify_font(fontdesc)
# Scrolled Window for Textview
self.sw = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
self.sw.add_with_viewport(self.reporttv)
# Get KB to parse for report
self.textbuffer = self.reporttv.get_buffer()
if self.host:
self.report_data = generateReport(self.uicore.get_kbList(),
self.host)
else:
self.report_data = generateReport(self.uicore.get_kbList())
self.textbuffer.set_text(self.report_data)
# Add Textview to VBox
self.vbox.pack_start(self.sw, True, True, 0)
# Show all
self.add(self.vbox)
self.show_all()
def setup_menus(self):
menuGwibber = gtk.Menu()
menuView = gtk.Menu()
menuAccounts = gtk.Menu()
menuHelp = gtk.Menu()
accelGroup = gtk.AccelGroup()
self.add_accel_group(accelGroup)
key, mod = gtk.accelerator_parse("Escape")
accelGroup.connect_group(key, mod, gtk.ACCEL_VISIBLE,
self.on_cancel_reply)
def create_action(name, accel, stock, fn, parent=menuGwibber):
mi = gtk.Action("gwibber%s" % name, "%s" % name, None, stock)
gtk.accel_map_add_entry("<Gwibber>/%s" % name,
*gtk.accelerator_parse(accel))
mi.set_accel_group(accelGroup)
mi.set_accel_path("<Gwibber>/%s" % name)
mi.connect("activate", fn)
parent.append(mi.create_menu_item())
return mi
actRefresh = create_action(_("_Refresh"), "<ctrl>R", gtk.STOCK_REFRESH,
self.on_refresh)
actSearch = create_action(_("_Search"), "<ctrl>F", gtk.STOCK_FIND,
self.on_search)
# XXX: actCloseWindow should be disabled (greyed out) when false self.preferences['minimize_to_tray'] as it is the same as quitting
actCloseWindow = create_action(_("_Close Window"), "<ctrl><shift>W",
None, self.on_window_close_btn)
actCloseTab = create_action(_("_Close Tab"), "<ctrl>W",
gtk.STOCK_CLOSE, self.on_tab_close_btn)
menuGwibber.append(gtk.SeparatorMenuItem())
actClear = create_action(_("C_lear"), "<ctrl>L", gtk.STOCK_CLEAR,
self.on_clear)
menuGwibber.append(gtk.SeparatorMenuItem())
actPreferences = create_action(_("_Preferences"), "<ctrl>P",
gtk.STOCK_PREFERENCES,
self.on_preferences)
menuGwibber.append(gtk.SeparatorMenuItem())
actQuit = create_action(_("_Quit"), "<ctrl>Q", gtk.STOCK_QUIT,
self.on_quit)
#actThemeTest = gtk.Action("gwibberThemeTest", "_Theme Test", None, gtk.STOCK_PREFERENCES)
#actThemeTest.connect("activate", self.theme_preview_test)
#menuHelp.append(actThemeTest.create_menu_item())
actHelpOnline = gtk.Action("gwibberHelpOnline",
_("Get Help Online..."), None, None)
actHelpOnline.connect(
"activate", lambda *a: gintegration.load_url(
"https://answers.launchpad.net/gwibber"))
actTranslate = gtk.Action("gwibberTranslate",
_("Translate This Application..."), None,
None)
actTranslate.connect(
"activate", lambda *a: gintegration.load_url(
"https://translations.launchpad.net/gwibber"))
actReportProblem = gtk.Action("gwibberReportProblem",
_("Report a Problem"), None, None)
actReportProblem.connect(
"activate", lambda *a: gintegration.load_url(
"https://bugs.launchpad.net/gwibber/+filebug"))
actAbout = gtk.Action("gwibberAbout", _("_About"), None,
gtk.STOCK_ABOUT)
actAbout.connect("activate", self.on_about)
menuHelp.append(actHelpOnline.create_menu_item())
menuHelp.append(actTranslate.create_menu_item())
menuHelp.append(actReportProblem.create_menu_item())
menuHelp.append(gtk.SeparatorMenuItem())
menuHelp.append(actAbout.create_menu_item())
for w, n in list(CONFIGURABLE_UI_ELEMENTS.items()):
mi = gtk.CheckMenuItem(_(n))
self.preferences.bind(mi, "show_%s" % w)
menuView.append(mi)
if gintegration.SPELLCHECK_ENABLED:
mi = gtk.CheckMenuItem(_("S_pellcheck"), True)
self.preferences.bind(mi, "spellcheck_enabled")
menuView.append(mi)
mi = gtk.MenuItem(_("E_rrors"))
mi.connect("activate", self.on_errors_show)
menuView.append(gtk.SeparatorMenuItem())
menuView.append(mi)
menuGwibberItem = gtk.MenuItem(_("_Gwibber"))
menuGwibberItem.set_submenu(menuGwibber)
menuViewItem = gtk.MenuItem(_("_View"))
menuViewItem.set_submenu(menuView)
menuAccountsItem = gtk.MenuItem(_("_Accounts"))
menuAccountsItem.set_submenu(menuAccounts)
menuAccountsItem.connect("select", self.on_accounts_menu)
menuHelpItem = gtk.MenuItem(_("_Help"))
menuHelpItem.set_submenu(menuHelp)
self.throbber = gtk.Image()
menuSpinner = gtk.ImageMenuItem("")
menuSpinner.set_right_justified(True)
menuSpinner.set_sensitive(False)
menuSpinner.set_image(self.throbber)
actDisplayBubbles = gtk.CheckMenuItem(_("Display bubbles"))
self.preferences.bind(actDisplayBubbles, "show_notifications")
menuTray = gtk.Menu()
menuTray.append(actDisplayBubbles)
menuTray.append(actRefresh.create_menu_item())
menuTray.append(gtk.SeparatorMenuItem())
menuTray.append(actPreferences.create_menu_item())
menuTray.append(actAbout.create_menu_item())
menuTray.append(gtk.SeparatorMenuItem())
menuTray.append(actQuit.create_menu_item())
menuTray.show_all()
self.tray_icon.connect(
"popup-menu", lambda i, b, a: menuTray.popup(
None, None, gtk.status_icon_position_menu, b, a, self.tray_icon
))
menubar = gtk.MenuBar()
menubar.append(menuGwibberItem)
menubar.append(menuViewItem)
menubar.append(menuAccountsItem)
menubar.append(menuHelpItem)
menubar.append(menuSpinner)
return menubar
def init(self, *args, **kw):
self.__acels = gtk.AccelGroup()
self._create_uim()
hbox.pack_start(quit, expand=False,fill=False)
vbox = gtk.VBox()
vbox.pack_start(draw, expand=True, fill=True)
vbox.pack_start(hbox, expand=False, fill=False)
window.add(vbox)
font = pango.FontDescription()
font.set_family("sans-serif")
font.set_size(60*pango.SCALE)
layout = draw.create_pango_layout(get_text())
layout.set_font_description(font)
layout.set_alignment(pango.ALIGN_CENTER)
accel = gtk.AccelGroup()
key, mod = gtk.accelerator_parse("<Ctrl>Q")
accel.connect_group(key, mod, 0, gtk.main_quit)
key, mod = gtk.accelerator_parse("Escape")
#accel.connect_group(key, mod, 0, gtk.main_quit)
#key, mod = gtk.accelerator_parse("<Ctrl>C")
accel.connect_group(key, mod, 0, (lambda x,y,z,v: tb.set_text("")))
window.add_accel_group(accel)
window.connect("destroy", gtk.main_quit)
window.show_all()
need_resize=True
need_quick=True
def __init__(self, buffer=None):
menu_items = [
( "/_File", None, None, 0, "<Branch>" ),
( "/File/_New", "<control>N", self.do_new, 0, None ),
( "/File/New _View", None, self.do_new_view, 0, None ),
( "/File/_Open", "<control>O", self.do_open, 0, None ),
( "/File/_Save", "<control>S", self.do_save, 0, None ),
( "/File/Save _As...", None, self.do_save_as, 0, None ),
( "/File/sep1", None, None, 0, "<Separator>" ),
( "/File/_Close", "<control>W" , self.do_close, 0, None ),
( "/File/E_xit", "<control>Q" , self.do_exit, 0, None ),
( "/_Edit", None, None, 0, "<Branch>" ),
( "/Edit/Find...", None, self.do_search, 0, None ),
( "/_Settings", None, None, 0, "<Branch>" ),
( "/Settings/Wrap _Off", None, self.do_wrap_changed, gtk.WRAP_NONE, "<RadioItem>" ),
( "/Settings/Wrap _Words", None, self.do_wrap_changed, gtk.WRAP_WORD, "/Settings/Wrap Off" ),
( "/Settings/Wrap _Chars", None, self.do_wrap_changed, gtk.WRAP_CHAR, "/Settings/Wrap Off" ),
( "/Settings/sep1", None, None, 0, "<Separator>" ),
( "/Settings/Editable", None, self.do_editable_changed, True, "<RadioItem>" ),
( "/Settings/Not editable", None, self.do_editable_changed, False, "/Settings/Editable" ),
( "/Settings/sep1", None, None, 0, "<Separator>" ),
( "/Settings/Cursor visible", None, self.do_cursor_visible_changed, True, "<RadioItem>" ),
( "/Settings/Cursor not visible", None, self.do_cursor_visible_changed, False, "/Settings/Cursor visible" ),
( "/Settings/sep1", None, None, 0, "<Separator>" ),
( "/Settings/Left-to-Right", None, self.do_direction_changed, gtk.TEXT_DIR_LTR, "<RadioItem>" ),
( "/Settings/Right-to-Left", None, self.do_direction_changed, gtk.TEXT_DIR_RTL, "/Settings/Left-to-Right" ),
( "/Settings/sep1", None, None, 0, "<Separator>" ),
( "/Settings/Sane spacing", None, self.do_spacing_changed, False, "<RadioItem>" ),
( "/Settings/Funky spacing", None, self.do_spacing_changed, True, "/Settings/Sane spacing" ),
( "/Settings/sep1", None, None, 0, "<Separator>" ),
( "/Settings/Don't cycle color tags", None, self.do_color_cycle_changed, False, "<RadioItem>" ),
( "/Settings/Cycle colors", None, self.do_color_cycle_changed, True, "/Settings/Don't cycle color tags" ),
( "/_Attributes", None, None, 0, "<Branch>" ),
( "/Attributes/Editable", None, self.do_apply_editable, True, None ),
( "/Attributes/Not editable", None, self.do_apply_editable, False, None ),
( "/Attributes/Invisible", None, self.do_apply_invisible, False, None ),
( "/Attributes/Visible", None, self.do_apply_invisible, True, None ),
( "/Attributes/Custom tabs", None, self.do_apply_tabs, False, None ),
( "/Attributes/Default tabs", None, self.do_apply_tabs, True, None ),
( "/Attributes/Color cycles", None, self.do_apply_colors, True, None ),
( "/Attributes/No colors", None, self.do_apply_colors, False, None ),
( "/Attributes/Remove all tags", None, self.do_remove_tags, 0, None ),
( "/Attributes/Properties", None, self.do_properties, 0, None ),
( "/_Test", None, None, 0, "<Branch>" ),
( "/Test/_Example", None, self.do_example, 0, None ),
( "/Test/_Insert and scroll", None, self.do_insert_and_scroll, 0, None ),
( "/Test/_Add movable children", None, self.do_add_children, 0, None ),
( "/Test/A_dd focusable children", None, self.do_add_focus_children, 0, None ),
]
if not buffer:
buffer = Buffer()
gtk.Window.__init__(self)
TestText.views.push(self)
buffer.ref()
if not TestText.colormap:
TestText.colormap = self.get_colormap()
self.connect("delete_event", self.delete_event_cb)
self.accel_group = gtk.AccelGroup()
self.item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>",
self.accel_group)
self.item_factory.set_data("view", self)
self.item_factory.create_items(menu_items)
self.add_accel_group(self.accel_group)
vbox = gtk.VBox(False, 0)
self.add(vbox)
vbox.pack_start(self.item_factory.get_widget("<main>"),
False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.text_view = gtk.TextView(buffer)
self.text_view.set_wrap_mode(gtk.WRAP_WORD)
# Make sure border width works, no real reason to do this other
# than testing
self.text_view.set_border_width(10)
# Draw tab stops in the top and bottom windows.
self.text_view.set_border_window_size(gtk.TEXT_WINDOW_TOP, 15)
self.text_view.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 15)
self.text_view.connect("expose_event", self.tab_stops_expose)
self.bhid = buffer.connect("mark_set", self.cursor_set_callback)
# Draw line numbers in the side windows; we should really be
# more scientific about what width we set them to.
self.text_view.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 30)
self.text_view.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 30)
self.text_view.connect("expose_event", self.line_numbers_expose)
vbox.pack_start(sw, True, True, 0)
sw.add(self.text_view)
self.set_default_size(500, 500)
self.text_view.grab_focus()
self.set_view_title()
self.init_menus()
self.add_example_widgets()
self.show_all()
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
if view_type not in (x.view_type for x in self.screen.views) and \
view_type not in self.screen.view_to_load:
self.screen.add_view_id(None, view_type)
self.screen.switch_view(view_type=view_type)
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('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:
stock_id = gtk.STOCK_DELETE
else:
stock_id = gtk.STOCK_CANCEL
self._initial_value = self.screen.current_record.get_eval()
self.but_cancel = self.win.add_button(stock_id,
gtk.RESPONSE_CANCEL)
self.but_cancel.set_always_show_image(True)
if new and self.many:
self.but_new = self.win.add_button(gtk.STOCK_NEW,
gtk.RESPONSE_ACCEPT)
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)
img_save = gtk.Image()
img_save.set_from_stock('tryton-save', gtk.ICON_SIZE_BUTTON)
self.but_ok.set_image(img_save)
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(gtk.STOCK_OK, gtk.RESPONSE_OK)
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]
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)
img_add = gtk.Image()
img_add.set_from_stock('tryton-list-add',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_add.set_alignment(0.5, 0.5)
self.but_add.add(img_add)
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)
img_remove = gtk.Image()
img_remove.set_from_stock('tryton-list-remove',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_remove.set_alignment(0.5, 0.5)
self.but_remove.add(img_remove)
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)
img_new = gtk.Image()
img_new.set_from_stock('tryton-new', gtk.ICON_SIZE_SMALL_TOOLBAR)
img_new.set_alignment(0.5, 0.5)
self.but_new.add(img_new)
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)
img_del = gtk.Image()
img_del.set_from_stock('tryton-delete',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_del.set_alignment(0.5, 0.5)
self.but_del.add(img_del)
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)
img_undel = gtk.Image()
img_undel.set_from_stock('tryton-undo',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_undel.set_alignment(0.5, 0.5)
self.but_undel.add(img_undel)
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)
hbox.pack_start(gtk.VSeparator(), expand=False, fill=True)
self.but_pre = gtk.Button()
tooltips.set_tip(self.but_pre, _('Previous'))
self.but_pre.connect('clicked', self._sig_previous)
img_pre = gtk.Image()
img_pre.set_from_stock('tryton-go-previous',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_pre.set_alignment(0.5, 0.5)
self.but_pre.add(img_pre)
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)
img_next = gtk.Image()
img_next.set_from_stock('tryton-go-next',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_next.set_alignment(0.5, 0.5)
self.but_next.add(img_next)
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)
but_switch = gtk.Button()
tooltips.set_tip(but_switch, _('Switch'))
but_switch.connect('clicked', self.switch_view)
img_switch = gtk.Image()
img_switch.set_from_stock('tryton-fullscreen',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_switch.set_alignment(0.5, 0.5)
but_switch.add(img_switch)
but_switch.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(but_switch, expand=False, fill=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()
def translate(self, widget, event, model, name, src, widget_entry, screen,
window):
"""Translation window for object data strings"""
#widget accessor functions
def value_get(widget):
if type(widget) == type(gtk.Entry()):
return widget.get_text()
elif type(widget.child) == type(gtk.TextView()):
buffer = widget.child.get_buffer()
iter_start = buffer.get_start_iter()
iter_end = buffer.get_end_iter()
return buffer.get_text(iter_start, iter_end, False)
else:
return None
def value_set(widget, value):
if type(widget) == type(gtk.Entry()):
widget.set_text(value)
elif type(widget.child) == type(gtk.TextView()):
if value == False:
value = ''
buffer = widget.child.get_buffer()
buffer.delete(buffer.get_start_iter(), buffer.get_end_iter())
iter_start = buffer.get_start_iter()
buffer.insert(iter_start, value)
def widget_duplicate(widget):
if type(widget) == type(gtk.Entry()):
entry = gtk.Entry()
entry.set_property('activates_default', True)
entry.set_max_length(widget.get_max_length())
entry.set_width_chars(widget.get_width_chars())
return entry, gtk.FILL
elif type(widget.child) == type(gtk.TextView()):
tv = gtk.TextView()
tv.set_wrap_mode(gtk.WRAP_WORD)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
sw.set_shadow_type(gtk.SHADOW_NONE)
sw.set_size_request(-1, 80)
sw.add(tv)
tv.set_accepts_tab(False)
return sw, gtk.FILL | gtk.EXPAND
else:
return None, False
if not value_get(widget_entry):
common.message(_(
'Enter some text to the related field before adding translations!'
),
parent=self.window)
return False
id = screen.current_model.id
if not id:
common.message(
_('You need to save resource before adding translations!'),
parent=self.window)
return False
id = screen.current_model.save(reload=False)
uid = rpc.session.uid
# Find the translatable languages
lang_ids = rpc.session.rpc_exec_auth('/object', 'execute', 'res.lang',
'search',
[('translatable', '=', '1')])
if not lang_ids:
common.message(_('No other language available!'), parent=window)
return False
langs = rpc.session.rpc_exec_auth('/object', 'execute', 'res.lang',
'read', lang_ids, ['code', 'name'])
# get the code of the current language
current_lang = rpc.session.context.get('lang', 'en_US')
# There used to be a adapt_context() function here, to make sure we sent
# False instead of 'en_US'. But why do that at all ?
# Window
win = gtk.Dialog(_('Add Translation'), window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
win.vbox.set_spacing(5)
win.set_property('default-width', 600)
win.set_property('default-height', 400)
win.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
win.set_icon(common.OPENERP_ICON)
# Accelerators
accel_group = gtk.AccelGroup()
win.add_accel_group(accel_group)
# Buttons
but_cancel = win.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
but_cancel.add_accelerator('clicked', accel_group, gtk.keysyms.Escape,
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
but_ok = win.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
but_ok.add_accelerator('clicked', accel_group, gtk.keysyms.Return,
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
# Vertical box
vbox = gtk.VBox(spacing=5)
# Grid with all the translations
entries_list = []
table = gtk.Table(len(langs), 2)
table.set_homogeneous(False)
table.set_col_spacings(3)
table.set_row_spacings(0)
table.set_border_width(1)
i = 0
for lang in langs:
# Make sure the context won't mutate
context = copy.copy(rpc.session.context)
context['lang'] = lang['code']
# Read the string in this language
val = rpc.session.rpc_exec_auth('/object', 'execute', model,
'read', [id], [name], context)
val = val[0]
# Label
#TODO space before ':' depends of lang (ex: english no space)
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL:
label = gtk.Label(': ' + lang['name'])
else:
label = gtk.Label(lang['name'] + ' :')
label.set_alignment(1.0, 0.5)
(entry, yoptions) = widget_duplicate(widget_entry)
# Setting the writable property according to main widget
if isinstance(entry, gtk.Entry):
entry.set_sensitive(widget_entry.get_editable())
elif isinstance(entry, gtk.ScrolledWindow):
entry.child.set_sensitive(widget_entry.child.get_editable())
# Label and text box side by side
hbox = gtk.HBox(homogeneous=False)
# Take the latest text in the user's language
if lang['code'] == current_lang:
value_set(entry, value_get(widget_entry))
else:
value_set(entry, val[name])
entries_list.append((lang['code'], entry))
table.attach(label,
0,
1,
i,
i + 1,
yoptions=False,
xoptions=gtk.FILL,
ypadding=2,
xpadding=5)
table.attach(entry,
1,
2,
i,
i + 1,
yoptions=yoptions,
ypadding=2,
xpadding=5)
i += 1
# Open the window
vbox.pack_start(table)
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
vp.add(vbox)
sv = gtk.ScrolledWindow()
sv.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sv.set_shadow_type(gtk.SHADOW_NONE)
sv.add(vp)
win.vbox.add(sv)
win.show_all()
# process the response
ok = False
data = []
while not ok:
response = win.run()
ok = True
if response == gtk.RESPONSE_OK:
# Get the values of all the text boxes
for code, entry in entries_list:
value = value_get(entry)
# update the previous form if the string in the user's language was just changed
if code == current_lang:
value_set(widget_entry, value)
# write the new translation
context = copy.copy(rpc.session.context)
context['lang'] = code
rpc.session.rpc_exec_auth('/object', 'execute', model,
'write', [id],
{str(name): value}, context)
if response == gtk.RESPONSE_CANCEL:
window.present()
win.destroy()
return
screen.current_model.reload()
window.present()
win.destroy()
return True
def gui_setup(self):
pbox = gtk.VBox(False,0)
self.search_criteria = {}
self.set_default_size(*self.default_size)
menu_items = (
("/File/Save Resource", "<control>S", self.file_save, 0, None),
("/File/Revert", None, self.revert, 0, None),
#("/File/Export CSV", None, self.export_csv, 0, None),
#("/File/Import CSV", None, self.import_csv, 0, None),
#("/Edit/Cut", "<control>X", None, 0, None),
#("/Edit/Copy", "<control>C", None, 0, None),
#("/Edit/Paste", "<control>V", None, 0, None),
#("/Edit/Delete", None, None, 0, None),
("/Edit/Insert Entry", "<control>N", self.edit_insert,0,None),
("/Edit/Select All", "<control>A", self.select_all,0,None),
("/Map/Open Map", "<control>M", self.open_map, 0, None),
("/Map/Send Selection to Map", "<alt>S",
self.send_selection, 0, None),
("/Map/Reload Map", "<alt>R", self.reload_map, 0, None),
#("/Select/Container Contents", "<control>O",None,0,None),
#("/Select/Others in Cell","<control>T",None,0,None),
#("/Select/Parent","<control>P",None,0,None),
#("/Select/Scroll to Selected","<control>F",None,0,None),
)
accel = gtk.AccelGroup()
ifc = gtk.ItemFactory(gtk.MenuBar, "<main>", accel)
self.add_accel_group(accel)
ifc.create_items(menu_items)
self.menu_bar = ifc.get_widget("<main>")
pbox.pack_start(self.menu_bar, False, True, 0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC)
self.data_view = gtk.TreeView()
self.data_view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
dc = gtk.TreeViewColumn()
dc.set_title("Index")
c = gtk.CellRendererText()
c.set_property('editable',False)
dc.pack_start(c,True)
dc.add_attribute(c,"text",0)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Flags")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_flags)
dc.pack_start(c,True)
dc.add_attribute(c,"text",1)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Free")
c = gtk.CellRendererToggle()
#c.connect('toggled', self.editor_callback_free)
dc.pack_start(c,True)
dc.add_attribute(c,"active",12)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Prop Type")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_proptype)
dc.pack_start(c,True)
dc.add_attribute(c,"text",2)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Location")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_location)
dc.pack_start(c,True)
dc.add_attribute(c,"text",3)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Rotate?")
c = gtk.CellRendererToggle()
#c.set_activatable(True)
#c.connect('toggled', self.editor_callback_rotate)
dc.pack_start(c,True)
dc.add_attribute(c,"active",4)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Aspect")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_aspect)
dc.pack_start(c,True)
dc.add_attribute(c,"text",5)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("D1")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_d1)
dc.pack_start(c,True)
dc.add_attribute(c,"text",6)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("D2")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_d2)
dc.pack_start(c,True)
dc.add_attribute(c,"text",7)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("D3")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_d3)
dc.pack_start(c,True)
dc.add_attribute(c,"text",8)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Prop Reference")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_propref)
dc.pack_start(c,True)
dc.add_attribute(c,"text",9)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Storage")
c = gtk.CellRendererText()
c.set_property('editable',True)
c.connect('edited', self.editor_callback_storage)
dc.pack_start(c,True)
dc.add_attribute(c,"text",10)
self.data_view.append_column(dc)
dc = gtk.TreeViewColumn()
dc.set_title("Unknown")
c = gtk.CellRendererText()
c.set_property('editable',False)
#c.connect('edited', self.editor_callback_u)
dc.pack_start(c,True)
dc.add_attribute(c,"text",13)
self.data_view.append_column(dc)
sw.add(self.data_view)
pbox.pack_start(sw, True, True, 5)
hbox = gtk.HBox(False,0)
#hbox.pack_start(gtk.Label("Search:"))
hbox.pack_start(gtk.Label("Search by... Index:"))
self.search_index = gtk.Entry()
self.search_index.set_width_chars(6)
self.search_index.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 11)))
hbox.pack_start(self.search_index)
hbox.pack_start(gtk.Label("Flags:"))
self.search_flags = gtk.Entry()
self.search_flags.set_width_chars(6)
self.search_flags.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 1)))
hbox.pack_start(self.search_flags)
hbox.pack_start(gtk.Label("PropType:"))
self.search_proptype = gtk.Entry()
self.search_proptype.set_width_chars(12)
self.search_proptype.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 2)))
hbox.pack_start(self.search_proptype)
hbox.pack_start(gtk.Label("Location:"))
self.search_location = gtk.Entry()
self.search_location.set_width_chars(8)
self.search_location.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 3)))
hbox.pack_start(self.search_location)
hbox.pack_start(gtk.Label("Aspect:"))
self.search_aspect = gtk.Entry()
self.search_aspect.set_width_chars(4)
self.search_aspect.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 5)))
hbox.pack_start(self.search_aspect)
hbox.pack_start(gtk.Label("d1:"))
self.search_d1 = gtk.Entry()
self.search_d1.set_width_chars(6)
self.search_d1.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 6)))
hbox.pack_start(self.search_d1)
hbox.pack_start(gtk.Label("d2:"))
self.search_d2 = gtk.Entry()
self.search_d2.set_width_chars(6)
self.search_d2.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 7)))
hbox.pack_start(self.search_d2)
hbox.pack_start(gtk.Label("d3:"))
self.search_d3 = gtk.Entry()
self.search_d3.set_width_chars(8)
self.search_d3.connect("changed", self.criterion_change,
(lambda i: self.tree_data.get_value(i, 8)))
hbox.pack_start(self.search_d3)
#self.searchbutton = gtk.Button("Search")
#hbox.pack_start(self.searchbutton)
#self.showall = gtk.Button("Show All")
#hbox.pack_start(self.showall)
pbox.pack_start(hbox, False, True, 0)
self.add(pbox)
#look up the keypress and call the action
try:
_actions_keypress_dict[(keyval, mod_mask)]()
except KeyError:
return False #not handled
return True #handled here
_all_actions_list = list()
def get_all_actions():
return _all_actions_list
_accel_group = gtk.AccelGroup()
def get_accel_group():
return _accel_group
class Action(gtk.Action):
"""
A custom Action class based on gtk.Action.
Pass additional arguments such as keypresses.
Register actions and keypresses with this module.
"""
def __init__(self,
keypresses=(),
name=None,
def gui_setup(self):
self.mouse_position = 0,0
pbox = gtk.VBox(False,0)
self.set_default_size(*self.default_size)
menu_items = (
("/File/Save Resource", "<control>S", None, 0, None),
("/File/Revert", None, self.revert, 0, None),
("/File/Export Image", None, self.export_img, 0, None),
("/Edit/Cut", "<control>X", None, 0, None),
("/Edit/Copy", "<control>C", None, 0, None),
("/Edit/Paste", "<control>V", None, 0, None),
("/Edit/Clear", None, None, 0, None),
("/Tool/Cursor", "C", None, 0, None),
("/Tool/Pencil", "N", None, 0, None),
("/Tool/Brush", "B", None, 0, None),
("/Tool/Rectangle Select", "R", None, 0, None),
("/Tool/Tile Select", "T", self.tile_select, 0, None),
("/Tool/Stamp", "M", None, 0, None),
("/Tool/Eyedropper", "E", None, 0, None),
("/Tool/Prop Select", "P", self.prop_select, 0, None),
("/Tool/Select None", "X", self.select_none, 0, None),
("/View/Preview Palette Animation",None,None, 0, None),
("/View/Display Roof Layer",None, None, 0, None),
("/View/Display Props", None, None, 0, None),
("/View/Send Selection to Prop List","<alt>S",self.send_selection,
0,None),
("/View/Scroll to Selection","L",self.scroll_to_selection,0,None),
("/Windows/Tile Selector", "<control>T", None, 0, None),
("/Windows/Props List", "<control>P", self.open_props, 0, None),
("/Windows/Brushes", "<control>B", None, 0, None),
("/Windows/Stamps", "<control>M", None, 0, None),
("/Windows/Map Boundaries", None, None, 0, None),
)
accel = gtk.AccelGroup()
ifc = gtk.ItemFactory(gtk.MenuBar, "<main>", accel)
self.add_accel_group(accel)
ifc.create_items(menu_items)
self.menu_bar = ifc.get_widget("<main>")
pbox.pack_start(self.menu_bar, False, True, 0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC)
self.display = gtk.Image()
self.eventbox = gtk.EventBox()
self.eventbox.add_events(
gtk.gdk.POINTER_MOTION_MASK|gtk.gdk.BUTTON_PRESS)
self.eventbox.connect("motion-notify-event", self.mouse_movement)
self.eventbox.connect("button-press-event", self.mouse_click)
self.eventbox.add(self.display)
self.sbox = gtk.Fixed()
self.sbox.put(self.eventbox, 0,0)
sw.add_with_viewport(self.sbox)
pbox.pack_start(sw, True, True, 0)
self.sw = sw
hbox = gtk.HBox(False,0)
hbox.pack_start(gtk.Label("Cursor:"),False,True,0)
self.w_xpos = gtk.Entry()
self.w_xpos.set_width_chars(4)
self.w_xpos.set_editable(False)
hbox.pack_start(self.w_xpos,False,True,0)
self.w_ypos = gtk.Entry()
self.w_ypos.set_width_chars(4)
self.w_ypos.set_editable(False)
hbox.pack_start(self.w_ypos,False,True,0)
hbox.pack_start(gtk.Label("Map Data:"),False,True,0)
self.w_mapdata = gtk.Entry()
self.w_mapdata.set_width_chars(6)
self.w_mapdata.set_editable(False)
hbox.pack_start(self.w_mapdata,False,True,0)
hbox.pack_start(gtk.Label("Name:"),False,True,0)
self.w_name = gtk.Entry()
self.w_name.set_editable(False)
hbox.pack_start(self.w_name,False,True,0)
hbox.pack_start(gtk.Label("Attr:"),False,True,0)
self.w_attr = gtk.Entry()
self.w_attr.set_width_chars(10)
self.w_attr.set_editable(False)
hbox.pack_start(self.w_attr,True, True, 0)
hbox.pack_start(gtk.Label("Faux Prop:"),False,True,0)
self.w_faux = gtk.Entry()
self.w_faux.set_width_chars(9)
self.w_faux.set_editable(False)
hbox.pack_start(self.w_faux,True, True, 0)
hbox.pack_start(gtk.Label("FP Tile:"),False,True,0)
self.w_fauxtile = gtk.Entry()
self.w_fauxtile.set_width_chars(6)
self.w_fauxtile.set_editable(False)
hbox.pack_start(self.w_fauxtile,True, True, 0)
hbox.pack_start(gtk.Label("FP Attr:"),False,True,0)
self.w_fauxattr = gtk.Entry()
self.w_fauxattr.set_width_chars(10)
self.w_fauxattr.set_editable(False)
hbox.pack_start(self.w_fauxattr,True, True, 0)
hbox.pack_start(gtk.Label("FP Offs:"),False,True,0)
self.w_fauxoffs = gtk.Entry()
self.w_fauxoffs.set_width_chars(5)
self.w_fauxoffs.set_editable(False)
hbox.pack_start(self.w_fauxoffs,True, True, 0)
pbox.pack_start(hbox, False, True, 0)
self.w_props = gtk.Entry()
self.w_props.set_width_chars(80)
self.w_props.set_editable(False)
pbox.pack_start(self.w_props, False, True, 0)
self.add(pbox)
def __init__(self, widget, languages):
NoModal.__init__(self)
self.widget = widget
self.win = gtk.Dialog(_('Translation'), self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
self.win.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.win.set_icon(TRYTON_ICON)
self.win.connect('response', self.response)
self.accel_group = gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
self.win.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
self.win.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK).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.5)
table.attach(label, 0, 1, i, i + 1, xoptions=gtk.FILL)
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()
self.widget.translate_widget_set(widget, fuzzy_value)
self.widget.translate_widget_set_readonly(widget, True)
table.attach(widget, 1, 2, i, i + 1)
editing = gtk.CheckButton()
editing.connect('toggled', self.editing_toggled, widget)
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, False, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(vbox)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.add(viewport)
self.win.vbox.pack_start(scrolledwindow, True, True)
sensible_allocation = self.sensible_widget.get_allocation()
self.win.set_default_size(int(sensible_allocation.width * 0.9),
int(sensible_allocation.height * 0.9))
self.register()
self.win.show_all()
common.center_window(self.win, self.parent, self.sensible_widget)
def __init__(
self, hosts=None, patterns_name=None, patterns_owner=None,
comms_timeout=None, interval=None):
gobject.threads_init()
set_exception_hook_dialog("cylc gscan")
setup_icons()
self.window = gtk.Window()
title = "cylc gscan"
for opt, items in [("-n", patterns_name), ("-o", patterns_owner)]:
if items:
for pattern in items:
if pattern is not None:
title += " %s %s" % (opt, pattern)
self.window.set_title(title)
self.window.set_icon(get_icon())
self.vbox = gtk.VBox()
self.vbox.show()
self.warnings = {}
self.theme_name = GcylcConfig.get_inst().get(['use theme'])
self.theme = GcylcConfig.get_inst().get(['themes', self.theme_name])
suite_treemodel = gtk.TreeStore(
str, # group
str, # host
str, # owner
str, # suite
str, # version
bool, # is_stopped
str, # title
int, # update_time
str, # states
str, # states_text
str) # warning_text
self._prev_tooltip_location_id = None
self.treeview = gtk.TreeView(suite_treemodel)
# Visibility of columns
gsfg = GScanConfig.get_inst()
vis_cols = gsfg.get(["columns"])
hide_main_menu_bar = gsfg.get(["hide main menubar"])
# Doesn't make any sense without suite name column
if gsfg.COL_SUITE not in vis_cols:
vis_cols.append(gsfg.COL_SUITE.lower())
# Construct the group, host, owner, suite, title, update time column.
for col_title, col_id, col_cell_text_setter in [
(gsfg.COL_GROUP, self.GROUP_COLUMN, self._set_cell_text_group),
(gsfg.COL_HOST, self.HOST_COLUMN, self._set_cell_text_host),
(gsfg.COL_OWNER, self.OWNER_COLUMN, self._set_cell_text_owner),
(gsfg.COL_SUITE, self.SUITE_COLUMN, self._set_cell_text_name),
(gsfg.COL_VERSION, self.VERSION_COLUMN,
self._set_cell_text_version),
(gsfg.COL_TITLE, self.TITLE_COLUMN, self._set_cell_text_title),
(gsfg.COL_UPDATED, self.UPDATE_TIME_COLUMN,
self._set_cell_text_time),
]:
column = gtk.TreeViewColumn(col_title)
cell_text = gtk.CellRendererText()
column.pack_start(cell_text, expand=False)
column.set_cell_data_func(cell_text, col_cell_text_setter)
column.set_sort_column_id(col_id)
column.set_visible(col_title.lower() in vis_cols)
column.set_resizable(True)
self.treeview.append_column(column)
# Construct the status column.
status_column = gtk.TreeViewColumn(gsfg.COL_STATUS)
status_column.set_sort_column_id(self.STATUS_COLUMN)
status_column.set_visible(gsfg.COL_STATUS.lower() in vis_cols)
status_column.set_resizable(True)
cell_text_cycle = gtk.CellRendererText()
status_column.pack_start(cell_text_cycle, expand=False)
status_column.set_cell_data_func(
cell_text_cycle, self._set_cell_text_cycle, self.CYCLE_COLUMN)
self.treeview.append_column(status_column)
# Warning icon.
warn_icon = gtk.CellRendererPixbuf()
image = gtk.Image()
pixbuf = image.render_icon(
gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.warn_icon_colour = pixbuf.scale_simple( # colour warn icon pixbuf
self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER)
self.warn_icon_grey = pixbuf.scale_simple(
self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER)
self.warn_icon_colour.saturate_and_pixelate(
self.warn_icon_grey, 0, False) # b&w warn icon pixbuf
status_column.pack_start(warn_icon, expand=False)
status_column.set_cell_data_func(warn_icon, self._set_error_icon_state)
self.warn_icon_blank = gtk.gdk.Pixbuf( # Transparent pixbuff.
gtk.gdk.COLORSPACE_RGB, True, 8, self.ICON_SIZE, self.ICON_SIZE
).fill(0x00000000)
# Task status icons.
for i in range(len(TASK_STATUSES_ORDERED)):
cell_pixbuf_state = gtk.CellRendererPixbuf()
status_column.pack_start(cell_pixbuf_state, expand=False)
status_column.set_cell_data_func(
cell_pixbuf_state, self._set_cell_pixbuf_state, i)
self.treeview.show()
if hasattr(self.treeview, "set_has_tooltip"):
self.treeview.set_has_tooltip(True)
try:
self.treeview.connect('query-tooltip',
self._on_query_tooltip)
except TypeError:
# Lower PyGTK version.
pass
self.treeview.connect("button-press-event",
self._on_button_press_event)
cre_owner, cre_name = re_compile_filters(patterns_owner, patterns_name)
self.updater = ScanAppUpdater(
self.window, hosts, suite_treemodel, self.treeview,
comms_timeout, interval, self.GROUP_COLUMN, cre_owner, cre_name)
self.updater.start()
self.dot_size = GcylcConfig.get_inst().get(['dot icon size'])
self.dots = None
self._set_dots()
self.menu_bar = None
self.create_menubar()
accelgroup = gtk.AccelGroup()
self.window.add_accel_group(accelgroup)
key, modifier = gtk.accelerator_parse('<Alt>m')
accelgroup.connect_group(
key, modifier, gtk.ACCEL_VISIBLE, self._toggle_hide_menu_bar)
self.tool_bar = None
self.create_tool_bar()
self.menu_hbox = gtk.HBox()
self.menu_hbox.pack_start(self.menu_bar, expand=True, fill=True)
self.menu_hbox.pack_start(self.tool_bar, expand=True, fill=True)
self.menu_hbox.show_all()
if hide_main_menu_bar:
self.menu_hbox.hide_all()
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.treeview)
scrolled_window.show()
self.vbox.pack_start(self.menu_hbox, expand=False)
self.vbox.pack_start(scrolled_window, expand=True, fill=True)
self.window.add(self.vbox)
self.window.connect("destroy", self._on_destroy_event)
wsize = gsfg.get(['window size'])
self.window.set_default_size(*wsize)
self.treeview.grab_focus()
self.window.show()
self.theme_legend_window = None
self.warning_icon_shown = []
def build_gui():
global cell,days_l,win,accel,title,g_e,h_e,current_l
accel=gtk.AccelGroup()
gtk.window_set_default_icon_name('gnome-calendar')
win = gtk.Window(); win.set_title('التقويم الهجري')
win.add_accel_group(accel)
win.hide_on_delete()
#win.set_size_request(200, 300)
win.connect('delete-event', hide_cb)
build_about()
vb=gtk.VBox(False,0); win.add(vb)
hb=gtk.HBox(False,0)
vb.pack_start(hb,False, False, 0)
title=gtk.Label("...")
title.set_justify(gtk.JUSTIFY_CENTER)
img=gtk.Image(); img.set_from_stock(gtk.STOCK_GOTO_FIRST, gtk.ICON_SIZE_SMALL_TOOLBAR)
btn=gtk.Button(); btn.add(img)
set_tip(btn,"عام سابق")
try: btn.set_focus_on_click(False)
except AttributeError: pass
btn.connect('clicked', prev_year_cb)
hb.pack_start(btn,False, False, 0)
img=gtk.Image(); img.set_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_SMALL_TOOLBAR)
btn=gtk.Button(); btn.add(img)
btn.connect('clicked', prev_month_cb)
set_tip(btn,"شهر سابق")
try: btn.set_focus_on_click(False)
except AttributeError: pass
hb.pack_start(btn,False, False, 0)
hb.pack_start(title,True, True, 0)
img=gtk.Image(); img.set_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
btn=gtk.Button(); btn.add(img)
btn.connect('clicked', next_month_cb)
set_tip(btn,"شهر لاحق")
try: btn.set_focus_on_click(False)
except AttributeError: pass
hb.pack_start(btn,False, False, 0)
img=gtk.Image(); img.set_from_stock(gtk.STOCK_GOTO_LAST, gtk.ICON_SIZE_SMALL_TOOLBAR)
btn=gtk.Button(); btn.add(img)
btn.connect('clicked', next_year_cb)
set_tip(btn,"عام لاحق")
try: btn.set_focus_on_click(False)
except AttributeError: pass
hb.pack_start(btn,False, False, 0)
table = gtk.Table(7,6,True)
vb.pack_start(table,True, True, 0)
for i in xrange(7):
days_l[i]=gtk.Label('...')
e=gtk.EventBox(); e.add(days_l[i])
table.attach(e,i,i+1,0,1,gtk.FILL | gtk.EXPAND,gtk.FILL | gtk.EXPAND,0,0)
for n in xrange(42):
i=n%7; j=n/7;
cell[j][i]=gtk.Label("-")
cell[j][i].set_alignment(0.5,0.5)
cell[j][i].set_justify(gtk.JUSTIFY_CENTER)
set_tip(cell[j][i],None)
e=gtk.EventBox(); e.add(cell[j][i])
#e.modify_bg(gtk.STATE_NORMAL,color_h2_bg);
table.attach(e, i,i+1,j+1,j+2,gtk.FILL | gtk.EXPAND,gtk.FILL | gtk.EXPAND,0,0)
hb = gtk.HBox(False,0)
vb.pack_start(hb,False, False, 0)
#img=gtk.Image(); img.set_from_stock(gtk.STOCK_JUSTIFY_LEFT, gtk.ICON_SIZE_MENU)
#btn=gtk.ToggleButton(); btn.add(img)
#hb.pack_start(btn,False, False, 0)
#btn.set_active((cal.get_direction()+1)/2)
#btn.connect("toggled", direction_cb)
#try: btn.set_focus_on_click(False)
#except: pass
g_e=gtk.Entry(); g_e.set_width_chars(6); hb.pack_start(g_e,False, False, 0)
set_tip(g_e,"العام الجريجوري")
img=gtk.Image(); img.set_from_stock(gtk.STOCK_CONVERT, gtk.ICON_SIZE_MENU)
hb.pack_start(img,False, False, 0)
#btn.connect("clicked", convert_cb)
g_e.connect("activate", convert_cb)
try: btn.set_focus_on_click(False)
except AttributeError: pass
h_e=gtk.Entry(); h_e.set_width_chars(6); hb.pack_start(h_e,False, False, 0)
set_tip(h_e,"العام الهجري")
img=gtk.Image(); img.set_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)
hb.pack_start(img,False, False, 0)
#btn.connect("clicked", jump_cb)
h_e.connect("activate", jump_cb)
try: btn.set_focus_on_click(False)
except AttributeError: pass
img=gtk.Image(); img.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)
btn=gtk.Button(); btn.add(img)
hb.pack_start(btn,False, False, 0)
btn.connect("clicked", today_cb)
set_tip(btn,"اليوم")
try: btn.set_focus_on_click(False)
except AttributeError: pass
img=gtk.Image(); img.set_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU)
btn=gtk.Button(); btn.add(img)
hb.pack_start(btn,False, False, 0)
btn.connect("clicked", lambda *args: about_dlg.run())
set_tip(btn,"حول")
try: btn.set_focus_on_click(False)
except AttributeError: pass
#g_e.set_text(str(cal.gy))
#h_e.set_text(str(cal.Y))
hb = gtk.HBox(False,0)
vb.pack_start(hb,False, False, 0)
#current_l=gtk.Label()
#current_l.set_justify(gtk.JUSTIFY_CENTER)
#h_str="%d من %s لعام %d هـ" % (cal.D, months[cal.M-1], cal.Y)
#g_str="%d من %s لعام %d م" % (cal.gd, gmonths[cal.gm-1], cal.gy)
#current_l.set_markup('<span weight="bold" foreground="#ffffff" background="#000000">%s</span>\n<span weight="bold" foreground="#000000" background="#ffffff">%s</span>' % (h_str,g_str))
#hb.pack_start(current_l,True, False, 0)
if not '--hidden' in sys.argv: win.show_all(); update_gui()
def __init__(self, buffer=None):
menus = [
("/_Fichier", None, None, 0, "<Branch>"),
("/Fichier/_Nouveau", "<control>N", self.nouveau, 0, None),
("/Fichier/Nou_velle fenetre", None, self.nouvelle_fenetre, 0,
None),
("/Fichier/_Ouvrir", "<control>O", self.ouvrir, 0, None),
("/Fichier/_Enregistrer", "<control>S", self.enregistrer, 0, None),
("/Fichier/Enregistrer _sous...", None, self.enregistrer_sous, 0,
None),
("/Fichier/sep1", None, None, 0, "<Separator>"),
("/Fichier/_Fermer", "<control>W", self.fermer, 0, None),
("/Fichier/_Quitter", "<control>Q", self.quitter, 0, None),
("/_Edition", None, None, 0, "<Branch>"),
("/Edition/Rechercher...", None, self.rechercher, 0, None),
("/_Options", None, None, 0, "<Branch>"),
("/Options/Pas de retour a la ligne auto", None,
self.change_retour, gtk.WRAP_NONE, "<RadioItem>"),
("/Options/Retour a la ligne apres mot", None, self.change_retour,
gtk.WRAP_WORD, "/Options/Pas de retour a la ligne auto"),
("/Options/Retour a la ligne apres caractere", None,
self.change_retour, gtk.WRAP_CHAR,
"/Options/Pas de retour a la ligne auto"),
("/Options/sep1", None, None, 0, "<Separator>"),
("/Options/Editable", None, self.change_opt_editable, True,
"<RadioItem>"),
("/Options/Non editable", None, self.change_opt_editable, False,
"/Options/Editable"),
("/Options/sep1", None, None, 0, "<Separator>"),
("/Options/Afficher curseur", None, self.change_curseur_visible,
True, "<RadioItem>"),
("/Options/Masquer curseur", None, self.change_curseur_visible,
False, "/Options/Afficher curseur"),
("/Options/sep1", None, None, 0, "<Separator>"),
("/Options/De gauche a droite", None, self.change_direction,
gtk.TEXT_DIR_LTR, "<RadioItem>"),
("/Options/De droite a gauche", None, self.change_direction,
gtk.TEXT_DIR_RTL, "/Options/De gauche a droite"),
("/Options/sep1", None, None, 0, "<Separator>"),
("/Options/Espacement normal", None, self.change_espacement, False,
"<RadioItem>"),
("/Options/Espacement funky", None, self.change_espacement, True,
"/Options/Espacement normal"),
("/Options/sep1", None, None, 0, "<Separator>"),
("/Options/Ne pas alterner les couleurs", None,
self.change_alterner_couleurs, False, "<RadioItem>"),
("/Options/Alterner les balises de couleur", None,
self.change_alterner_couleurs, True,
"/Options/Ne pas alterner les couleurs"),
("/_Attributs", None, None, 0, "<Branch>"),
("/Attributs/Editable", None, self.change_attr_editable, True,
None),
("/Attributs/Non editable", None, self.change_attr_editable, False,
None),
("/Attributs/Invisible", None, self.change_visible, False, None),
("/Attributs/Visible", None, self.change_visible, True, None),
("/Attributs/Tabulations personnalisees", None,
self.change_tabulations, False, None),
("/Attributs/Tabulations par defaut", None,
self.change_tabulations, True, None),
("/Attributs/Alternance de couleurs", None,
self.change_appliquer_couleurs, True, None),
("/Attributs/Pas de couleurs", None,
self.change_appliquer_couleurs, False, None),
("/Attributs/Retirer toutes les balises", None,
self.retirer_balises, 0, None),
("/Attributs/Proprietes", None, self.proprietes, 0, None),
("/_Test", None, None, 0, "<Branch>"),
("/Test/_Exemple", None, self.exemple, 0, None),
("/Test/_Inserer et defiler", None, self.inserer_defiler, 0, None),
("/Test/_Ajouter objets enfants a deplacer", None,
self.ajouter_enfants, 0, None),
("/Test/A_jouter objets enfants avec focus", None,
self.ajouter_enfants_focus, 0, None),
]
if not buffer:
buffer = Buffer()
gtk.Window.__init__(self)
TestTexte.fenetres.empiler(self)
buffer.incr_comptref()
if not TestTexte.tabledescouleurs:
TestTexte.tabledescouleurs = self.get_colormap()
self.connect("delete_event", self.evnmt_delete)
self.raccourcis_clavier = gtk.AccelGroup()
self.barremenus = gtk.ItemFactory(gtk.MenuBar, "<main>",
self.raccourcis_clavier)
self.barremenus.set_data("fenetre", self)
self.barremenus.create_items(menus)
self.add_accel_group(self.raccourcis_clavier)
boitev = gtk.VBox(False, 0)
self.add(boitev)
boitev.pack_start(self.barremenus.get_widget("<main>"), False, False,
0)
fen_deroulante = gtk.ScrolledWindow()
fen_deroulante.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.zonetexte = gtk.TextView(buffer)
self.zonetexte.set_wrap_mode(gtk.WRAP_WORD)
# On s'assure que l'on peut bien regler la largeur des bordures
# Pas de veritable raison pour ceci, si ce n'est de tester.
self.zonetexte.set_border_width(10)
# Affichage des tabulations dans les fenetres superieure et inferieure
self.zonetexte.set_border_window_size(gtk.TEXT_WINDOW_TOP, 15)
self.zonetexte.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 15)
self.zonetexte.connect("expose_event", self.reaffichage_tabs)
self.bhid = buffer.connect("mark_set", self.rappel_mvt_curseur)
# Affichage des numeros des lignes dans les fenetres laterales; on devrait
# quand meme fixer leur largeur de maniere un peu plus "scientifique".
self.zonetexte.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 30)
self.zonetexte.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 30)
self.zonetexte.connect("expose_event", self.affichage_num_lignes)
boitev.pack_start(fen_deroulante, True, True, 0)
fen_deroulante.add(self.zonetexte)
self.set_default_size(500, 500)
self.zonetexte.grab_focus()
self.titre_fenetre()
self.init_menus()
self.ajouter_widgets_exemples()
self.show_all()
