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