def finish_initializing(self, builder): # pylint: disable=E1002 """Set up the main window""" super(UberwriterWindow, self).finish_initializing(builder) self.AboutDialog = AboutUberwriterDialog self.UberwriterAdvancedExportDialog = UberwriterAdvancedExportDialog self.builder = builder # Code for other initialization actions should be added here. # Texlive checker self.texlive_installed = False self.set_name('UberwriterWindow') self.title_end = " – UberWriter" self.set_title("New File" + self.title_end) # Drag and drop self.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY) self.target_list = Gtk.TargetList.new([]) self.target_list.add_uri_targets(1) self.target_list.add_text_targets(2) self.drag_dest_set_target_list(self.target_list) self.focusmode = False self.word_count = builder.get_object('word_count') self.char_count = builder.get_object('char_count') self.menubar = builder.get_object('menubar1') # Wire up buttons self.fullscreen_button = builder.get_object('fullscreen_toggle') self.focusmode_button = builder.get_object('focus_toggle') self.preview_button = builder.get_object('preview_toggle') self.fullscreen_button.set_name('fullscreen_toggle') self.focusmode_button.set_name('focus_toggle') self.preview_button.set_name('preview_toggle') # Setup status bar hide after 3 seconds self.status_bar = builder.get_object('status_bar_box') self.status_bar.set_name('status_bar_box') self.status_bar_visible = True self.was_motion = True self.buffer_modified_for_status_bar = False self.connect("motion-notify-event", self.on_motion_notify) GObject.timeout_add(3000, self.poll_for_motion) self.accel_group = Gtk.AccelGroup() self.add_accel_group(self.accel_group) # Setup light background self.TextEditor = TextEditor() base_leftmargin = 100 self.TextEditor.set_left_margin(base_leftmargin) self.TextEditor.set_left_margin(40) self.TextEditor.set_wrap_mode(Gtk.WrapMode.WORD) self.TextEditor.show() self.ScrolledWindow = builder.get_object('editor_scrolledwindow') self.ScrolledWindow.add(self.TextEditor) # Draw background self.background_image = helpers.get_media_path('bg_light.png') self.ScrolledWindow.connect('draw', self.draw_bg) surface = cairo.ImageSurface.create_from_png(self.background_image) self.background_pattern = cairo.SurfacePattern(surface) self.background_pattern.set_extend(cairo.EXTEND_REPEAT) self.PreviewPane = builder.get_object('preview_scrolledwindow') pangoFont = Pango.FontDescription("Ubuntu Mono 15px") # self.scw = builder.get_object('scrolledwindow1') # self.scw.add(self.sidebar.get_treeview()) # http://nullege.com/codes/show/src%40c%40o%40comix-HEAD%40trunk%40src%40labels.py/31/gtk.Label.set_attributes/python # ## TODO # attr_list = Pango.AttrList.new() # attr_list.insert(Pango.Attribute.LetterSpacing.new(100)) # self.TextEditor.set_attributes(attr_list) self.TextEditor.modify_font(pangoFont) self.TextEditor.set_margin_top(38) self.TextEditor.set_margin_bottom(16) self.TextEditor.set_pixels_above_lines(4) self.TextEditor.set_pixels_below_lines(4) self.TextEditor.set_pixels_inside_wrap(8) tab_array = Pango.TabArray.new(1, True) tab_array.set_tab(0, Pango.TabAlign.LEFT, 20) self.TextEditor.set_tabs(tab_array) self.TextBuffer = self.TextEditor.get_buffer() self.TextBuffer.set_text('') # Init Window height for top/bottom padding self.window_height = self.get_size()[1] self.text_change_event = self.TextBuffer.connect('changed', self.text_changed) self.TextEditor.connect('move-cursor', self.cursor_moved) # Init file name with None self.filename = None self.generate_recent_files_menu(self.builder.get_object('recent')) self.style_provider = Gtk.CssProvider() css = open(helpers.get_media_path('style.css'), 'rb') css_data = css.read() css.close() self.style_provider.load_from_data(css_data) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) # Still needed. self.fflines = 0 # Markup and Shortcuts for the TextBuffer self.MarkupBuffer = MarkupBuffer(self, self.TextBuffer, base_leftmargin) self.MarkupBuffer.markup_buffer() self.FormatShortcuts = FormatShortcuts(self.TextBuffer, self.TextEditor) # Scrolling -> Dark or not? self.textchange = False self.scroll_count = 0 self.TextBuffer.connect('mark-set', self.mark_set) self.TextEditor.drag_dest_unset() # Events to preserve margin. (To be deleted.) self.TextEditor.connect('delete-from-cursor', self.delete_from_cursor) self.TextEditor.connect('backspace', self.backspace) self.TextBuffer.connect('paste-done', self.paste_done) # self.connect('key-press-event', self.alt_mod) # Events for Typewriter mode self.TextBuffer.connect_after('mark-set', self.after_mark_set) self.TextBuffer.connect_after('changed', self.after_modify_text) self.TextEditor.connect_after('move-cursor', self.after_cursor_moved) self.TextEditor.connect_after('insert-at-cursor', self.after_insert_at_cursor) # Setting up inline preview self.InlinePreview = UberwriterInlinePreview(self.TextEditor, self.TextBuffer) # Vertical scrolling self.vadjustment = self.TextEditor.get_vadjustment() self.vadjustment.connect('value-changed', self.scrolled) # Setting up spellcheck try: self.SpellChecker = SpellChecker(self.TextEditor, locale.getdefaultlocale()[0], collapse=False) self.spellcheck = True except: self.SpellChecker = None self.spellcheck = False builder.get_object("disable_spellcheck").set_active(False) if self.spellcheck: self.SpellChecker.append_filter('[#*]+', SpellChecker.FILTER_WORD) self.did_change = False ### # Sidebar initialization test ### self.paned_window = builder.get_object("main_pained") self.sidebar_box = builder.get_object("sidebar_box") self.sidebar = UberwriterSidebar(self) ### # Search and replace initialization # Same interface as Sidebar ;) ### self.searchreplace = UberwriterSearchAndReplace(self) # Window resize self.connect("configure-event", self.window_resize) self.connect("delete-event", self.on_delete_called) self.load_settings(builder)
def finish_initializing(self, builder): # pylint: disable=E1002 """Set up the main window""" super(UberwriterWindow, self).finish_initializing(builder) self.UberwriterAdvancedExportDialog = UberwriterAdvancedExportDialog self.builder = builder self.connect('save-file', self.save_document) self.connect('save-file-as', self.save_document_as) self.connect('new-file', self.new_document) self.connect('open-file', self.open_document) self.connect('toggle-fullscreen', self.menu_activate_fullscreen) self.connect('toggle-focusmode', self.menu_activate_focusmode) #self.connect('toggle-preview', self.menu_activate_preview) self.connect('toggle-spellcheck', self.toggle_spellcheck) self.connect('close-window', self.on_mnu_close_activate) self.connect('toggle-search', self.open_search_and_replace) self.scroll_adjusted = False # Code for other initialization actions should be added here. # Texlive checker self.texlive_installed = False self.set_name('UberwriterWindow') self.use_headerbar = True if self.use_headerbar == True: self.hb_container = Gtk.Frame(name='titlebar_container') self.hb_container.set_shadow_type(Gtk.ShadowType.NONE) self.hb_revealer = Gtk.Revealer(name='titlebar_revealer') self.hb = Gtk.HeaderBar() self.hb_revealer.add(self.hb) self.hb_revealer.props.transition_duration = 1000 self.hb_revealer.props.transition_type = Gtk.RevealerTransitionType.CROSSFADE self.hb.props.show_close_button = True self.hb.get_style_context().add_class("titlebar") self.hb_container.add(self.hb_revealer) self.hb_container.show() self.set_titlebar(self.hb_container) self.hb_revealer.show() self.hb_revealer.set_reveal_child(True) self.hb.show() bbtn = Gtk.MenuButton() btn_settings = Gtk.MenuButton() btn_settings.props.image = Gtk.Image.new_from_icon_name('emblem-system-symbolic', Gtk.IconSize.BUTTON) self.builder.get_object("menu4").detach() btn_settings.set_popup(self.builder.get_object("menu4")) self.builder.get_object("menu1").detach() bbtn.set_popup(self.builder.get_object("menu1")) self.hb.pack_start(bbtn) self.hb.pack_end(btn_settings) self.hb.show_all() self.testbits = Gdk.WindowState.MAXIMIZED #self.connect('draw', self.override_headerbar_background) self.title_end = " – UberWriter" self.set_headerbar_title("New File" + self.title_end) self.focusmode = False self.word_count = builder.get_object('word_count') self.char_count = builder.get_object('char_count') self.menubar = builder.get_object('menubar1') self.menubar.hide() # Wire up buttons self.fullscreen_button = builder.get_object('fullscreen_toggle') self.fullscreen_menu_button = builder.get_object('mnu_fullscreen') self.focusmode_button = builder.get_object('focus_toggle') self.focusmode_menu_button = builder.get_object('mnu_focusmode') self.preview_button = builder.get_object('preview_toggle') self.preview_mnu_button = builder.get_object('mnu_preview') self.fullscreen_button.set_name('fullscreen_toggle') self.focusmode_button.set_name('focus_toggle') self.preview_button.set_name('preview_toggle') # Setup status bar hide after 3 seconds self.status_bar = builder.get_object('status_bar_box') self.statusbar_revealer = builder.get_object('status_bar_revealer') self.status_bar.get_style_context().add_class('status_bar_box') self.status_bar_visible = True self.was_motion = True self.buffer_modified_for_status_bar = False self.connect("motion-notify-event", self.on_motion_notify) GObject.timeout_add(3000, self.poll_for_motion) self.accel_group = Gtk.AccelGroup() self.add_accel_group(self.accel_group) # Setup light background self.TextEditor = TextEditor() self.TextEditor.set_name('UberwriterEditor') self.get_style_context().add_class('uberwriter_window') base_leftmargin = 100 self.TextEditor.set_left_margin(base_leftmargin) self.TextEditor.set_left_margin(40) self.TextEditor.set_top_margin(80) self.TextEditor.props.width_request = 600 self.TextEditor.props.halign = Gtk.Align.CENTER self.TextEditor.set_vadjustment(builder.get_object('vadjustment1')) self.TextEditor.set_wrap_mode(Gtk.WrapMode.WORD_CHAR) self.TextEditor.connect('focus-out-event', self.focus_out) self.TextEditor.get_style_context().connect('changed', self.style_changed) # self.TextEditor.install_style_property_parser self.TextEditor.show() self.TextEditor.grab_focus() self.EditorAlignment = builder.get_object('editor_alignment') self.ScrolledWindow = builder.get_object('editor_scrolledwindow') self.ScrolledWindow.props.width_request = 600 self.ScrolledWindow.add(self.TextEditor) self.alignment_padding = 40 self.EditorViewport = builder.get_object('editor_viewport') self.ScrolledWindow.connect_after("draw", self.draw_gradient) self.smooth_scroll_starttime = 0 self.smooth_scroll_endtime = 0 self.smooth_scroll_acttarget = 0 self.smooth_scroll_data = { 'target_pos': -1, 'source_pos': -1, 'duration': 0 } self.smooth_scroll_tickid = -1 self.PreviewPane = builder.get_object('preview_scrolledwindow') self.TextEditor.set_top_margin(80) self.TextEditor.set_bottom_margin(16) self.TextEditor.set_pixels_above_lines(4) self.TextEditor.set_pixels_below_lines(4) self.TextEditor.set_pixels_inside_wrap(8) tab_array = Pango.TabArray.new(1, True) tab_array.set_tab(0, Pango.TabAlign.LEFT, 20) self.TextEditor.set_tabs(tab_array) self.TextBuffer = self.TextEditor.get_buffer() self.TextBuffer.set_text('') # Init Window height for top/bottom padding self.window_height = self.get_size()[1] self.text_change_event = self.TextBuffer.connect('changed', self.text_changed) # Init file name with None self.filename = None self.generate_recent_files_menu(self.builder.get_object('recent')) self.style_provider = Gtk.CssProvider() self.style_provider.load_from_path(helpers.get_media_path('style.css')) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) # Markup and Shortcuts for the TextBuffer self.MarkupBuffer = MarkupBuffer(self, self.TextBuffer, base_leftmargin) self.MarkupBuffer.markup_buffer() # Scrolling -> Dark or not? self.textchange = False self.scroll_count = 0 self.timestamp_last_mouse_motion = 0 self.TextBuffer.connect_after('mark-set', self.mark_set) # Drag and drop # self.TextEditor.drag_dest_unset() # self.TextEditor.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY) self.target_list = Gtk.TargetList.new([]) self.target_list.add_uri_targets(1) self.target_list.add_text_targets(2) self.TextEditor.drag_dest_set_target_list(self.target_list) self.TextEditor.connect_after('drag-data-received', self.on_drag_data_received) def on_drop(widget, *args): print("drop") self.TextEditor.connect('drag-drop', on_drop) self.TextBuffer.connect('paste-done', self.paste_done) # self.connect('key-press-event', self.alt_mod) # Events for Typewriter mode # Setting up inline preview self.InlinePreview = UberwriterInlinePreview(self.TextEditor, self.TextBuffer) # Vertical scrolling self.vadjustment = self.ScrolledWindow.get_vadjustment() self.vadjustment.connect('value-changed', self.scrolled) self.spellcheck_button = builder.get_object("disable_spellcheck") # Setting up spellcheck self.auto_correct = None try: self.SpellChecker = SpellChecker(self.TextEditor, locale.getdefaultlocale()[0], collapse=False) if self.auto_correct: self.auto_correct.set_language(self.SpellChecker.language) self.SpellChecker.connect_language_change(self.auto_correct.set_language) self.spellcheck = True except: self.SpellChecker = None self.spellcheck = False builder.get_object("disable_spellcheck").set_active(False) if self.spellcheck: self.SpellChecker.append_filter('[#*]+', SpellChecker.FILTER_WORD) self.did_change = False ### # Sidebar initialization test ### self.paned_window = builder.get_object("main_pained") self.sidebar_box = builder.get_object("sidebar_box") self.sidebar = UberwriterSidebar(self) self.sidebar_box.hide() ### # Search and replace initialization # Same interface as Sidebar ;) ### self.searchreplace = UberwriterSearchAndReplace(self) # Window resize self.window_resize(self) self.connect("configure-event", self.window_resize) self.connect("delete-event", self.on_delete_called) self.gtk_settings = Gtk.Settings.get_default() self.load_settings(builder)
def do_activate(self): if self.window: self.window.present() return self.window = Gtk.ApplicationWindow(application=self, title="Tryton") self.window.set_default_size(960, 720) self.window.maximize() self.window.set_position(Gtk.WIN_POS_CENTER) self.window.set_resizable(True) self.window.set_icon(TRYTON_ICON) self.window.connect("destroy", self.on_quit) self.window.connect("delete_event", self.on_quit) self.header = Gtk.HeaderBar.new() self.header.set_show_close_button(True) self.window.set_titlebar(self.header) self.set_title() menu = Gtk.Button.new() menu.set_relief(Gtk.ReliefStyle.NONE) menu.set_image( common.IconFactory.get_image('tryton-menu', Gtk.IconSize.BUTTON)) menu.connect('clicked', self.menu_toggle) self.header.pack_start(menu) favorite = Gtk.MenuButton.new() favorite.set_relief(Gtk.ReliefStyle.NONE) favorite.set_image( common.IconFactory.get_image('tryton-bookmarks', Gtk.IconSize.BUTTON)) self.menu_favorite = Gtk.Menu.new() favorite.set_popup(self.menu_favorite) favorite.connect('clicked', self.favorite_set) self.header.pack_start(favorite) self.set_global_search() self.header.pack_start(self.global_search_entry) self.accel_group = Gtk.AccelGroup() self.window.add_accel_group(self.accel_group) gtk.accel_map_add_entry('<tryton>/Form/New', gtk.keysyms.N, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Save', gtk.keysyms.S, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Duplicate', gtk.keysyms.D, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK) gtk.accel_map_add_entry('<tryton>/Form/Delete', gtk.keysyms.D, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Next', gtk.keysyms.Page_Down, 0) gtk.accel_map_add_entry('<tryton>/Form/Previous', gtk.keysyms.Page_Up, 0) gtk.accel_map_add_entry('<tryton>/Form/Switch View', gtk.keysyms.L, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Close', gtk.keysyms.W, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Reload', gtk.keysyms.R, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Attachments', gtk.keysyms.T, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK) gtk.accel_map_add_entry('<tryton>/Form/Notes', gtk.keysyms.O, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK) gtk.accel_map_add_entry('<tryton>/Form/Relate', gtk.keysyms.R, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK) gtk.accel_map_add_entry('<tryton>/Form/Actions', gtk.keysyms.E, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Report', gtk.keysyms.P, gtk.gdk.CONTROL_MASK) gtk.accel_map_add_entry('<tryton>/Form/Search', gtk.keysyms.F, gtk.gdk.CONTROL_MASK) gtk.accel_map_load(os.path.join(get_config_dir(), 'accel.map')) self.tooltips = common.Tooltips() self.vbox = gtk.VBox() self.window.add(self.vbox) self.buttons = {} self.info = gtk.VBox() self.vbox.pack_start(self.info, expand=False) if CONFIG['client.check_version']: common.check_version(self.info) GLib.timeout_add_seconds(int(CONFIG['download.frequency']), common.check_version, self.info) self.pane = gtk.HPaned() self.vbox.pack_start(self.pane, True, True) self.pane.set_position(int(CONFIG['menu.pane'])) self.menu_screen = None self.menu = gtk.VBox() self.menu.set_vexpand(True) self.pane.add1(self.menu) self.notebook = gtk.Notebook() self.notebook.popup_enable() self.notebook.set_scrollable(True) self.notebook.connect_after('switch-page', self._sig_page_changt) self.pane.add2(self.notebook) self.window.show_all() self.pages = [] self.previous_pages = {} self.current_page = 0 self.last_page = 0 self.dialogs = [] self._global_run = False self._global_check_timeout_id = None self._global_update_timeout_id = None # Register plugins tryton.plugins.register() self.set_title() # Adds username/profile while password is asked try: common.Login() except Exception as exception: if (not isinstance(exception, TrytonError) or exception.faultCode != 'QueryCanceled'): common.error(str(exception), traceback.format_exc()) return self.quit() self.get_preferences()
def __init__(self, filename, ui='transcribe.ui', *args): builder = Gtk.Builder() builder.add_from_file(os.path.join(os.path.dirname(__file__), ui)) self.accelerators = Gtk.AccelGroup() self.window = builder.get_object('window') self.window.add_accel_group(self.accelerators) sw = builder.get_object('scrolledwindow') self.textbuffer = GtkSource.Buffer() self.lm = GtkSource.LanguageManager() path = self.lm.get_search_path() path.insert(0, os.path.join(os.path.dirname(__file__))) self.lm.set_search_path(path) self.textbuffer.set_language(self.lm.get_language('transcribe')) self.sourceview = GtkSource.View.new_with_buffer(self.textbuffer) self.sourceview.set_wrap_mode(Gtk.WrapMode.WORD_CHAR) self.sourceview.set_show_line_marks(True) self.sourceview.set_pixels_below_lines(self.SPACE_BELOW_LINES) sw.add(self.sourceview) self.play_button = builder.get_object('play_button') self.label_time = builder.get_object('label_time') self.label_duration = builder.get_object('label_duration') self.audio_slider = builder.get_object('audio_slider') #self.audio_slider.set_range(0, 100) self.audio_slider.set_increments(self.AUDIO_STEP, self.AUDIO_PAGE) box_speed = builder.get_object('box_speed') self.speed_slider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL) # self.speed_slider = builder.get_object('speed_slider') self.speed_slider.set_digits(2) self.speed_slider.set_range(0.10, 3) self.speed_slider.set_increments(self.SPEED_STEP, self.SPEED_PAGE) self.speed_slider.set_value(1.00) self.speed_slider.add_mark(1.00, Gtk.PositionType.BOTTOM, None) self.speed_slider.connect('value-changed', self.on_speed_slider_change) self.speed_slider.connect('grab-focus', self.on_speed_slider_grab_focus) box_speed.pack_start(self.speed_slider, True, True, 0) self.sourceview.connect("event-after", self.on_view_event_after) self.window.add_events(Gdk.EventType.KEY_PRESS | Gdk.EventType.KEY_RELEASE) self.window.connect('key-press-event', self.on_window_key_press) self.add_accelerator(self.play_button, '<ctrl>p', 'clicked') self.add_accelerator(self.play_button, '<ctrl>space', 'clicked') self.add_accelerator(self.play_button, 'F5', 'clicked') self.add_accelerator(self.speed_slider, '<alt>s', 'grab-focus') self.add_accelerator(self.audio_slider, '<alt>a', 'grab-focus') self.add_accelerator(self.sourceview, '<alt>t', 'grab-focus') builder.connect_signals(self) title = '%s - %s' % (self.APP_NAME, os.path.basename(filename)) self.window.set_title(title) self.audio = pipeline.Audio(filename) self.audio.connect('update-duration', self.on_audio_duration) self.audio.connect('finished', self.on_audio_finished)
def __init__(self, application): self.application = application self.settings = Gio.Settings("com.linuxmint.report") os.system("mkdir -p %s" % TMP_DIR) os.system("rm -rf %s/*" % TMP_DIR) os.system("mkdir -p %s" % UNPACK_DIR) os.system("cp -R %s/* %s/" % (DATA_DIR, TMP_DIR)) self.cache = apt.Cache() # Set the Glade file gladefile = "/usr/share/linuxmint/mintreport/mintreport.ui" self.builder = Gtk.Builder() self.builder.set_translation_domain(APP) self.builder.add_from_file(gladefile) self.window = self.builder.get_object("main_window") self.window.set_title(_("System Reports")) self.window.set_icon_name("mintreport") self.stack = self.builder.get_object("crash_stack") self.spinner = self.builder.get_object("crash_spinner") # Fill in the sysinfo pane self.load_sysinfo() self.builder.get_object("button_sysinfo_copy").connect("clicked", self.copy_sysinfo) self.builder.get_object("button_sysinfo_upload").connect("clicked", self.upload_sysinfo) # the crashes treeview self.treeview_crashes = self.builder.get_object("treeview_crashes") def render_date(column, cell, model, i, *args): cell.props.text = " ".join([model[i][COL_CRASH_DAY], model[i][COL_CRASH_DATE], model[i][COL_CRASH_TIME], model[i][COL_CRASH_TIMEZONE]]) def sort_by_date(model, a, b, *args): date_a = datetime.date.from_iso_format(model[a][COL_CRASH_DATE]) date_b = datetime.date.from_iso_format(model[b][COL_CRASH_DATE]) if date_a < date_b: return -1 elif date_a > date_b: return 1 time_a = datetime.time.fromisoformat(model[a][COL_CRASH_TIME]) time_b = datetime.time.fromisoformat(model[b][COL_CRASH_TIME]) if time_a < time_b: return -1 elif time_a > time_b: return 1 return 0 cell_renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn('', cell_renderer) column.set_cell_data_func(cell_renderer, render_date) column.set_resizable(True) self.treeview_crashes.append_column(column) column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_CRASH_PID) column.set_sort_column_id(COL_CRASH_PID) column.set_resizable(True) self.treeview_crashes.append_column(column) column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_CRASH_EXE) column.set_sort_column_id(COL_CRASH_EXE) column.set_resizable(True) self.treeview_crashes.append_column(column) self.treeview_crashes.show() self.model_crashes = Gtk.ListStore(str, str, str, str, str, str, object) # timestamp, pid, exe, object self.model_sort = self.model_crashes.sort_new_with_model() self.model_sort.set_sort_func(COL_CRASH_DATE, sort_by_date) self.treeview_crashes.set_model(self.model_crashes) self.buffer = GtkSource.Buffer() self.language_manager = GtkSource.LanguageManager() style_manager = GtkSource.StyleSchemeManager() self.buffer.set_style_scheme(style_manager.get_scheme("oblivion")) self.sourceview = GtkSource.View.new_with_buffer(self.buffer) self.builder.get_object("scrolledwindow_crash").add(self.sourceview) self.sourceview.show() self.treeview_crashes.get_selection().connect("changed", self.on_crash_selected) self.bugtracker = "https://bugs.launchpad.net/" self.localfiles_button = self.builder.get_object("button_browse_crash_report") self.bugtracker_button = self.builder.get_object("button_open_bugtracker") self.pastebin_button = self.builder.get_object("button_pastebin") self.localfiles_button.connect("clicked", self.on_button_browse_crash_report_clicked) self.bugtracker_button.connect("clicked", self.on_button_open_bugtracker_clicked) self.pastebin_button.connect("clicked", self.on_button_pastebin_clicked) # the info treeview self.info_button_box = self.builder.get_object("info_button_box") self.info_descriptions_box = self.builder.get_object("info_descriptions_box") self.treeview_info = self.builder.get_object("treeview_info") renderer = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn("", renderer, icon_name=COL_INFO_ICON) self.treeview_info.append_column(column) column = Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=COL_INFO_TITLE) column.set_sort_column_id(COL_INFO_TITLE) column.set_resizable(True) self.treeview_info.append_column(column) self.treeview_info.show() self.model_info = Gtk.TreeStore(str, str, object) # icon, name, report self.model_info.set_sort_column_id(COL_INFO_TITLE, Gtk.SortType.ASCENDING) self.treeview_info.set_model(self.model_info) self.treeview_info.get_selection().connect("changed", self.on_info_selected) if os.path.exists("/usr/bin/coredumpctl"): self.builder.get_object("crash_internal_stack").set_visible_child_name("page_reports") self.load_crashes() else: self.builder.get_object("crash_internal_stack").set_visible_child_name("page_error") self.load_info() accel_group = Gtk.AccelGroup() self.window.add_accel_group(accel_group) # Menubar menubar = self.builder.get_object("menubar") menu = Gtk.MenuItem.new_with_mnemonic(_("_File")) menubar.append(menu) submenu = Gtk.Menu() menu.set_submenu(submenu) item = Gtk.ImageMenuItem.new_with_label(_("Refresh")) image = Gtk.Image.new_from_icon_name("view-refresh-symbolic", Gtk.IconSize.MENU) item.set_image(image) item.connect('activate', self.on_menu_refresh) key, mod = Gtk.accelerator_parse("<Control>R") item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE) submenu.append(item) item = Gtk.ImageMenuItem.new_with_label(_("Restore ignored reports")) item.connect('activate', self.on_menu_restore) submenu.append(item) submenu.append(Gtk.SeparatorMenuItem()) item = Gtk.ImageMenuItem.new_with_label(_("Quit")) image = Gtk.Image.new_from_icon_name("application-exit-symbolic", Gtk.IconSize.MENU) item.set_image(image) item.connect('activate', self.on_menu_quit) key, mod = Gtk.accelerator_parse("<Control>Q") item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE) key, mod = Gtk.accelerator_parse("<Control>W") item.add_accelerator("activate", accel_group, key, mod, Gtk.AccelFlags.VISIBLE) submenu.append(item) menubar.show_all() menu = Gtk.MenuItem.new_with_mnemonic(_("_Help")) menubar.append(menu) submenu = Gtk.Menu() menu.set_submenu(submenu) item = Gtk.ImageMenuItem() item.set_image(Gtk.Image.new_from_icon_name("help-about-symbolic", Gtk.IconSize.MENU)) item.set_label(_("About")) item.connect("activate", self.open_about) submenu.append(item)
def __init__(self, library): super(CollectionBrowser, self).__init__(spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self._register_instance() if self.__model is None: self._init_model(library) sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) self.view = view = CollectionView() view.set_headers_visible(False) model_sort = CollectionSortModel(model=self.__model) model_filter = CollectionFilterModel(child_model=model_sort) self.__filter = None self.__bg_filter = background_filter() model_filter.set_visible_func(self.__parse_query) view.set_model(model_filter) def cmpa(a, b): """Like cmp but treats values that evaluate to false as inf""" if not a and b: return 1 if not b and a: return -1 return cmp(a, b) def cmp_rows(model, i1, i2, data): t1, t2 = model[i1][0], model[i2][0] pos1 = _ORDERING.get(t1, 0) pos2 = _ORDERING.get(t2, 0) if pos1 or pos2: return cmp(pos1, pos2) if not isinstance(t1, AlbumNode): return cmp(util.human_sort_key(t1), util.human_sort_key(t2)) a1, a2 = t1.album, t2.album return (cmpa(a1.peoplesort, a2.peoplesort) or cmpa(a1.date, a2.date) or cmpa(a1.sort, a2.sort) or cmp(a1.key, a2.key)) model_sort.set_sort_func(0, cmp_rows) model_sort.set_sort_column_id(0, Gtk.SortType.ASCENDING) column = Gtk.TreeViewColumn("albums") def cell_data(column, cell, model, iter_, data): markup = model.get_markup(self.__model.tags, iter_) cell.markup = markup cell.set_property('markup', markup) def get_scaled_cover(item): if item.scanned: return item.cover scale_factor = self.get_scale_factor() item.scan_cover(scale_factor=scale_factor) return item.cover def cell_data_pb(column, cell, model, iter_, data): album = model.get_album(iter_) if album is None: cell.set_property('icon-name', Icons.FOLDER) else: item = model.get_value(iter_) cover = get_scaled_cover(item) if cover: cover = add_border_widget(cover, view) surface = get_surface_for_pixbuf(self, cover) cell.set_property("surface", surface) else: cell.set_property('icon-name', Icons.MEDIA_OPTICAL) imgrender = Gtk.CellRendererPixbuf() render = Gtk.CellRendererText() if view.supports_hints(): render.set_property('ellipsize', Pango.EllipsizeMode.END) column.pack_start(imgrender, False) column.pack_start(render, True) column.set_cell_data_func(render, cell_data) column.set_cell_data_func(imgrender, cell_data_pb) view.append_column(column) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.add(view) hbox = Gtk.HBox(spacing=6) prefs = Gtk.Button() prefs.add(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU)) prefs.connect('clicked', lambda *x: Preferences(self)) self.accelerators = Gtk.AccelGroup() tags = self.__model.tags + ["album"] search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators, star=tags) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search hbox.pack_start(search, True, True, 0) hbox.pack_start(prefs, False, True, 0) self.pack_start(Align(hbox, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) self.__sig = view.get_selection().connect('changed', self.__selection_changed) view.connect('row-activated', self.__play) connect_obj(view, 'popup-menu', self.__popup, view, library) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) view.connect("drag-data-get", self.__drag_data_get) self.connect("destroy", self.__destroy) self.show_all()
# The developers of the Exaile media player hereby grant permission # for non-GPL compatible GStreamer and Exaile plugins to be used and # distributed together with GStreamer and Exaile. This permission is # above and beyond the permissions granted by the GPL license by which # Exaile is covered. If you modify this code, you may extend this # exception to your version of the code, but you are not obligated to # do so. If you do not wish to do so, delete this exception statement # from your version. from gi.repository import Gtk from xl import common, providers # Fake accel group so that menuitems can trick GTK into # showing accelerators in the menus. FAKEACCELGROUP = Gtk.AccelGroup() def simple_separator(name, after): def factory(menu, parent, context): item = Gtk.SeparatorMenuItem() return item item = MenuItem(name, factory, after=after) item._pos = 'last' return item def _get_accel(callback, display_name): # utility function to get menu information from an xlgui.Accelerator accelerator = None
def __init__(self): self.progressbar = get_obj('progressbar') self.error = Struct({ 'message': get_obj('error_message'), 'icon': get_obj('error_icon'), 'bar': get_obj('error_bar') }) self.error.bar.connect('response', lambda widget, signal: widget.hide()) self.strings = Struct({ 'quit': get_obj('quit').get_property('secondary-text'), 'preview': get_obj('preview_label').get_text() }) self.liststore = get_obj('loaded_photos') self.liststore.set_sort_column_id(TIMESTAMP, Gtk.SortType.ASCENDING) cell_string = Gtk.CellRendererText() cell_thumb = Gtk.CellRendererPixbuf() cell_thumb.set_property('stock-id', Gtk.STOCK_MISSING_IMAGE) cell_thumb.set_property('ypad', 6) cell_thumb.set_property('xpad', 12) column = Gtk.TreeViewColumn('Photos') column.pack_start(cell_thumb, False) column.add_attribute(cell_thumb, 'pixbuf', THUMB) column.pack_start(cell_string, False) column.add_attribute(cell_string, 'markup', SUMMARY) column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE) get_obj('photos_view').append_column(column) self.drag = DragController(self.open_files) self.navigator = NavigationController() self.search = SearchController() self.prefs = PreferencesController() self.labels = LabelController() self.actors = ActorController() about = get_obj('about') about.set_version(REVISION) about.set_program_name(APPNAME) about.set_logo( GdkPixbuf.Pixbuf.new_from_file_at_size( join(PKG_DATA_DIR, PACKAGE + '.svg'), 192, 192)) click_handlers = { 'open_button': [self.add_files_dialog, get_obj('open')], 'save_button': [self.save_all_files], 'clear_button': [clear_all_gpx], 'close_button': [self.close_selected_photos], 'revert_button': [self.revert_selected_photos], 'about_button': [lambda b, d: d.run() and d.hide(), about], 'apply_button': [self.apply_selected_photos, map_view], 'select_all_button': [toggle_selected_photos, self.labels.selection] } for button, handler in click_handlers.items(): get_obj(button).connect('clicked', *handler) accel = Gtk.AccelGroup() window = get_obj('main') window.resize(*gst.get('window-size')) window.connect('delete_event', self.confirm_quit_dialog) window.add_accel_group(accel) window.show_all() # Hide the unused button that appears beside the map source menu. get_obj('map_source_menu_button').get_child().get_children( )[0].set_visible(False) save_size = lambda v, s, size: gst.set_window_size(size()) for prop in ['width', 'height']: map_view.connect('notify::' + prop, save_size, window.get_size) accel.connect(Gdk.keyval_from_name('q'), Gdk.ModifierType.CONTROL_MASK, 0, self.confirm_quit_dialog) self.labels.selection.emit('changed') clear_all_gpx() metadata.delta = 0 self.secbutton, self.minbutton = get_obj('seconds'), get_obj('minutes') for spinbutton in [self.secbutton, self.minbutton]: spinbutton.connect('value-changed', self.time_offset_changed) gst.bind('offset-minutes', self.minbutton, 'value') gst.bind('offset-seconds', self.secbutton, 'value') gst.bind('left-pane-page', get_obj('photo_camera_gps'), 'page') get_obj('open').connect('update-preview', self.update_preview, get_obj('preview_label'), get_obj('preview_image'))
def __init_window(self): """ Add fields for all ui objects we need to access from code. Initialize everything we can't do from glade like events and other stuff. """ log.info("Initialize main window") self.window = self.window_builder.get_object("app_window") self.window.set_default_size(1100, 700) self.window.set_application(self.app) self.window.show_all() self.window.present() self.window.connect("delete-event", self.on_close) self.window.connect("drag_data_received", self.__on_drag_data_received) self.window.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY) # resizing the progress bar for older gtk versions if not Gtk.get_minor_version() > 18: self.window.connect("check-resize", self.__window_resized) self.author_box = self.window_builder.get_object("author_box") self.reader_box = self.window_builder.get_object("reader_box") self.book_box = self.window_builder.get_object("book_box") self.book_scroller = self.window_builder.get_object("book_scroller") self.sort_stack = self.window_builder.get_object("sort_stack") self.sort_stack.connect("notify::visible-child", self.__on_sort_stack_changed) self.sort_box = self.window_builder.get_object("sort_box") self.import_box = self.window_builder.get_object("import_box") self.position_box = self.window_builder.get_object("position_box") self.main_stack = self.window_builder.get_object("main_stack") self.toolbar_revealer = self.window_builder.get_object( "toolbar_revealer") self.back_button = self.window_builder.get_object("back_button") self.back_button.connect("clicked", self.__on_back_clicked) self.category_toolbar = self.window_builder.get_object( "category_toolbar") self.sort_stack_revealer = self.window_builder.get_object( "sort_stack_revealer") # This fixes a bug where otherwise expand is # somehow set to true internally # but is still showing false in the inspector self.sort_stack_revealer.props.expand = True self.sort_stack_revealer.props.expand = False self.sort_stack_switcher = self.window_builder.get_object( "sort_stack_switcher") self.no_media_file_chooser = self.window_builder.get_object( "no_media_file_chooser") self.no_media_file_chooser.connect("file-set", self.__on_no_media_folder_changed) self.external_switch = self.window_builder.get_object( "external_switch") self.auto_scan_switch = self.window_builder.get_object( "auto_scan_switch") # some visual stuff self.category_toolbar_separator = self.window_builder.get_object( "category_toolbar_separator") if tools.is_elementary(): self.category_toolbar.set_visible(False) # get about dialog self.about_dialog = self.about_builder.get_object("about_dialog") self.about_dialog.set_transient_for(self.window) self.about_dialog.connect("delete-event", self.hide_window) self.about_dialog.set_version(self.version) # shortcuts self.accel = Gtk.AccelGroup() # sorting and filtering self.author_box.connect("row-selected", self.__on_listbox_changed) self.reader_box.connect("row-selected", self.__on_listbox_changed) self.book_box.set_sort_func(self.__sort_books, None, False) self.book_box.set_filter_func(self.__filter_books, None, False) try: about_close_button = self.about_builder.get_object( "button_box").get_children()[2] if about_close_button: about_close_button.connect("clicked", self.__about_close_clicked) except Exception as e: log.info("Not connecting about close button.") player.add_player_listener(self.__player_changed)
def make_accel(self): accels = Gtk.AccelGroup() #accels.connect_by_path("e",self.on_run_clicked) key, mod = Gtk.accelerator_parse("Return") accels.connect(key, mod, 0, self.on_accel_return)
def __init__(self, app): """Set up the main window""" super().__init__(application=Gio.Application.get_default(), title="Uberwriter") self.get_style_context().add_class('uberwriter-window') # Set UI builder = Gtk.Builder() builder.add_from_resource( "/de/wolfvollprecht/UberWriter/ui/Window.ui") root = builder.get_object("FullscreenOverlay") self.connect("delete-event", self.on_delete_called) self.add(root) self.set_default_size(1000, 600) # Preferences self.settings = Settings.new() # Headerbars self.headerbar = headerbars.MainHeaderbar(app) self.set_titlebar(self.headerbar.hb_container) self.fs_headerbar = headerbars.FullscreenHeaderbar(builder, app) self.title_end = " – UberWriter" self.set_headerbar_title("New File" + self.title_end) self.timestamp_last_mouse_motion = 0 if self.settings.get_value("poll-motion"): self.connect("motion-notify-event", self.on_motion_notify) GObject.timeout_add(3000, self.poll_for_motion) self.accel_group = Gtk.AccelGroup() self.add_accel_group(self.accel_group) self.scrolled_window = builder.get_object('editor_scrolledwindow') # Setup text editor self.text_view = TextView(self.settings.get_int("characters-per-line")) self.text_view.connect('focus-out-event', self.focus_out) self.text_view.get_buffer().connect('changed', self.on_text_changed) self.text_view.show() self.text_view.grab_focus() self.scrolled_window.add(self.text_view) # Setup stats counter self.stats_revealer = builder.get_object('editor_stats_revealer') self.stats_button = builder.get_object('editor_stats_button') self.stats_handler = StatsHandler(self.stats_button, self.text_view) # Setup preview content = builder.get_object('content') editor = builder.get_object('editor') self.preview_handler = PreviewHandler(self, content, editor, self.text_view) # Setup header/stats bar hide after 3 seconds self.top_bottom_bars_visible = True self.was_motion = True self.buffer_modified_for_status_bar = False # some people seems to have performance problems with the overlay. # Let them disable it self.overlay_id = None self.toggle_gradient_overlay(self.settings.get_value("gradient-overlay")) # Init file name with None self.set_filename() # Setting up spellcheck self.auto_correct = None self.toggle_spellcheck(self.settings.get_value("spellcheck")) self.did_change = False ### # Sidebar initialization test ### self.paned_window = builder.get_object("main_paned") self.sidebar_box = builder.get_object("sidebar_box") self.sidebar = Sidebar(self) self.sidebar_box.hide() ### # Search and replace initialization # Same interface as Sidebar ;) ### self.searchreplace = SearchAndReplace(self, self.text_view, builder)
def __init__(self): Gtk.ToggleButton.__init__(self) BaseControl.__init__(self) QueueAdapter.__init__(self, player.QUEUE) self.set_focus_on_click(False) self.set_size_request(200, -1) box = Gtk.Box() self.arrow = Gtk.Arrow(Gtk.ArrowType.RIGHT, Gtk.ShadowType.OUT) box.pack_start(self.arrow, False, True, 0) self.label = Gtk.Label(label='') self.label.props.ellipsize = Pango.EllipsizeMode.END box.pack_start(self.label, True, True, 0) self.add(box) self.formatter = TrackFormatter( settings.get_option('plugin/minimode/track_title_format', '$tracknumber - $title')) self.view = PlaylistView(player.QUEUE.current_playlist, player.PLAYER) self.popup = AttachedWindow(self) self.popup.set_default_size( settings.get_option( 'plugin/minimode/' 'playlist_button_popup_width', 350), settings.get_option( 'plugin/minimode/' 'playlist_button_popup_height', 400), ) scrollwindow = Gtk.ScrolledWindow() scrollwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrollwindow.set_shadow_type(Gtk.ShadowType.IN) scrollwindow.add(self.view) self.popup.add(scrollwindow) self.popup.connect('show', self.on_popup_show) self.popup.connect('hide', self.on_popup_hide) self.popup.connect('configure-event', self.on_popup_configure_event) accel_group = Gtk.AccelGroup() key, modifier = Gtk.accelerator_parse('<Primary>J') accel_group.connect(key, modifier, Gtk.AccelFlags.VISIBLE, self.on_accelerator_activate) self.popup.add_accel_group(accel_group) self.tooltip = TrackToolTip(self, player.PLAYER) self.tooltip.set_auto_update(True) if player.PLAYER.current is not None: self.label.set_text(self.formatter.format(player.PLAYER.current)) self._drag_motion_timeout_id = None self._drag_leave_timeout_id = None self.drag_dest_set( Gtk.DestDefaults.ALL, self.view.targets, Gdk.DragAction.COPY | Gdk.DragAction.DEFAULT | Gdk.DragAction.MOVE, ) self.connect('drag-motion', self.on_drag_motion) self.connect('drag-leave', self.on_drag_leave) self.connect('drag-data-received', self.on_drag_data_received) self.view.connect('drag-motion', self.on_drag_motion) self.view.connect('drag-leave', self.on_drag_leave) event.add_ui_callback(self.on_track_tags_changed, 'track_tags_changed') event.add_ui_callback(self.on_option_set, 'plugin_minimode_option_set') self.on_option_set('plugin_minimode_option_set', settings, 'plugin/minimode/track_title_format')
def __init__(self, opts): self.serverIp = opts.serverIp self.serverPort = opts.serverPort self.connected = False self.sock = None self.done = False self.useGtk = useGtk if hasattr(opts, 'userName') and opts.userName is not None: self.userName = userName else: self.userName = os.getenv('USER') self.recolorDict = { self.userName: '******', 'WARNING': '#d0a000', 'ERROR': '#e00000' } if self.useGtk: self.window = gtk.Window(type=gtk.WindowType.TOPLEVEL) self.window.get_settings().set_property('gtk-font-name', 'monospace bold 10') self.window.set_title("PyChat") self.window.set_default_size(750, 450) self.window.connect('destroy', self.doQuit) # Text Box for viewing self.textBox = gtk.TextView() self.textBox.set_wrap_mode(gtk.WrapMode.WORD) self.textBox.set_editable(False) self.textBox.set_cursor_visible(False) self.textBox.set_border_window_size(gtk.TextWindowType.LEFT, 1) self.textBox.set_border_window_size(gtk.TextWindowType.RIGHT, 1) self.textBox.set_border_window_size(gtk.TextWindowType.TOP, 1) self.textBox.set_border_window_size(gtk.TextWindowType.BOTTOM, 1) # Plot Window for fun self.doPlotPart = False if self.doPlotPart: f = plt.figure() a = f.add_subplot('111') a.plot([0, 1, 2, 3], [0, 1, 4, 9], 'bo') # Widgets must be removed from their parent before they can be added to another container, # which is done below. f.canvas.manager.vbox.remove(f.canvas) self.canvas = f.canvas print('PA:', self.canvas) # Text Entry self.textEntry = gtk.TextView() self.textEntry.set_wrap_mode(gtk.WrapMode.NONE) self.textEntry.set_editable(True) self.textEntry.set_cursor_visible(False) self.textEntry.set_border_window_size(gtk.TextWindowType.LEFT, 1) self.textEntry.set_border_window_size(gtk.TextWindowType.RIGHT, 1) self.textEntry.set_border_window_size(gtk.TextWindowType.TOP, 1) self.textEntry.set_border_window_size(gtk.TextWindowType.BOTTOM, 1) self.textEntry.set_tooltip_text( 'Type message here. CTRL+S to submit.') # Scroll windows to encapsulate text areas self.scrollWinForTextBox = gtk.ScrolledWindow(expand=True) self.scrollWinForTextBox.set_policy(gtk.ScrollablePolicy.NATURAL, gtk.ScrollablePolicy.NATURAL) self.scrollWinForTextBox.add(self.textBox) self.scrollWinForTextBox.set_size_request(400, 220) self.scrollWinForTextEntry = gtk.ScrolledWindow(expand=True) self.scrollWinForTextEntry.set_policy(gtk.ScrollablePolicy.NATURAL, gtk.ScrollablePolicy.NATURAL) self.scrollWinForTextEntry.add(self.textEntry) self.scrollWinForTextEntry.set_size_request(300, 40) # Submit button self.submitButton = gtk.Button(label='submit', expand=False) self.submitButton.set_size_request(60, 40) self.submitButton.connect('clicked', self.submitHandler) accelGroup = gtk.AccelGroup() key, mod = gtk.accelerator_parse('<Control>s') self.submitButton.add_accelerator('clicked', accelGroup, key, mod, gtk.AccelFlags.VISIBLE) self.submitButton.set_tooltip_text('CTRL+S') self.howToFormat = 'PANED' # GRID or BOX or PANED if self.howToFormat == 'GRID': grid = gtk.Grid(expand=True) grid.set_row_spacing(2) grid.set_column_spacing(2) grid.attach(self.scrollWinForTextBox, 0, 0, 4, 4) grid.attach(self.scrollWinForTextEntry, 0, 4, 3, 1) grid.attach(self.submitButton, 3, 4, 1, 1) self.window.add(grid) elif self.howToFormat == 'BOX': vbox = gtk.VBox(homogeneous=False, spacing=5) if self.doPlotPart: hbox = gtk.HBox(homogeneous=False, spacing=6) hbox.pack_start(self.scrollWinForTextBox, expand=True, fill=True, padding=1) hbox.pack_end(self.canvas, expand=True, fill=True, padding=1) vbox.pack_start(hbox, expand=True, fill=True, padding=0) vbox.set_tooltip_text( 'Include "plot: <x sequence> : <y sequence> :" to plot some data.' ) else: vbox.pack_start(self.scrollWinForTextBox, expand=True, fill=True, padding=0) hbox = gtk.HBox(homogeneous=False, spacing=6) hbox.set_size_request(400, 60) hbox.pack_start(self.scrollWinForTextEntry, expand=True, fill=True, padding=0) hbox.pack_end(self.submitButton, expand=False, fill=True, padding=0) vbox.pack_end(hbox, expand=False, fill=True, padding=0) self.window.add(vbox) elif self.howToFormat == 'PANED': self.vPaned = gtk.Paned(orientation=gtk.Orientation.VERTICAL) if self.doPlotPart: hPaned = gtk.Paned() hPaned.add1(self.scrollWinForTextBox) hPaned.add2(self.canvas) self.vPaned.add1(hPaned) else: self.vPaned.add1(self.scrollWinForTextBox) self.hPaned = gtk.Paned() self.hPaned.add1(self.scrollWinForTextEntry) self.hPaned.add2(self.submitButton) self.hPaned.set_position(int(self.window.get_size()[0] * 0.8)) self.vPaned.add2(self.hPaned) self.vPaned.set_position(int(self.window.get_size()[1] * 0.9)) self.window.add(self.vPaned) self.window.connect('check-resize', self.resizeCheck) else: print('Oops! Wrong howToFormat.', howToFormat) self.window.add_accel_group(accelGroup) self.start() self.window.show_all() else: self.root = tk.Tk() self.root.protocol('WM_DELETE_WINDOW', self.doQuit) #contentFrame = tk.Frame() frame = tk.Frame(self.root) #, width=60, height=400) frame.grid(column=0, row=0, sticky=(tk.N + tk.E + tk.W + tk.S)) frame.rowconfigure(0, weight=5) frame.rowconfigure(1, weight=1) frame.columnconfigure(0, weight=10) frame.columnconfigure(1, weight=1) frame.columnconfigure(2, weight=2) frame.columnconfigure(3, weight=1) tbScrollbar = tk.Scrollbar(frame) tbScrollbar.grid(column=3, row=0, columnspan=1, rowspan=1, sticky=(tk.N + tk.W + tk.S)) self.textBox = tk.Text(frame, width=60, height=30, wrap=tk.WORD, state=tk.DISABLED) self.textBox.grid(column=0, row=0, columnspan=3, rowspan=1, sticky=(tk.N + tk.E + tk.W)) self.textBox.config(yscrollcommand=tbScrollbar.set) tbScrollbar.config(command=self.textBox.yview) teScrollbar = tk.Scrollbar(frame) teScrollbar.grid(column=1, row=1, columnspan=1, rowspan=1, sticky=(tk.N + tk.S + tk.W)) self.textEntry = tk.Text(frame, width=60, height=5, wrap=tk.WORD, state=tk.NORMAL) self.textEntry.grid(column=0, row=1, columnspan=1, rowspan=1, sticky=(tk.E + tk.W)) self.textEntry.config(yscrollcommand=teScrollbar.set) teScrollbar.config(command=self.textEntry.yview) self.textEntry.focus() self.submitButton = tk.Button(frame, text="submit", command=self.submitHandler) self.submitButton.grid(column=2, row=1, columnspan=2, rowspan=1, sticky=(tk.S + tk.E)) for keyWord, color in self.recolorDict.items(): self.textBox.tag_configure(keyWord, foreground=color, background='#dddddd', lmargin1=50, lmargin2=50) frame.pack() self.start()
def __init__(self, library): super(AlbumList, self).__init__(spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self._register_instance() if self.__model is None: self._init_model(library) self._cover_cancel = Gio.Cancellable.new() sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.set_headers_visible(False) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) render = Gtk.CellRendererPixbuf() self.__cover_column = column = Gtk.TreeViewColumn("covers", render) column.set_visible(config.getboolean("browsers", "album_covers")) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) column.set_fixed_width(Album.COVER_SIZE + 12) render.set_property('height', Album.COVER_SIZE + 8) render.set_property('width', Album.COVER_SIZE + 8) def cell_data_pb(column, cell, model, iter_, no_cover): album = model.get_album(iter_) if album is None: surface = None elif album.cover: pixbuf = album.cover pixbuf = add_border_widget(pixbuf, self.view) surface = get_surface_for_pixbuf(self, pixbuf) # don't cache, too much state has an effect on the result self.__last_render_surface = None else: surface = no_cover if self.__last_render_surface == surface: return self.__last_render_surface = surface cell.set_property("surface", surface) column.set_cell_data_func(render, cell_data_pb, self._no_cover) view.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn("albums", render) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) if view.supports_hints(): render.set_property('ellipsize', Pango.EllipsizeMode.END) def cell_data(column, cell, model, iter_, data): album = model.get_album(iter_) if album is None: text = "<b>%s</b>" % _("All Albums") text += "\n" + ngettext("%d album", "%d albums", len(model) - 1) % (len(model) - 1) markup = text else: markup = self.display_pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) column.set_cell_data_func(render, cell_data) view.append_column(column) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) view.set_rules_hint(True) view.set_search_equal_func(self.__search_func, None) view.set_search_column(0) view.set_model(model_filter) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.add(view) view.connect('row-activated', self.__play_selection) self.__sig = view.connect( 'selection-changed', util.DeferredSignal(self.__update_songs, owner=view)) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) view.connect("drag-data-get", self.__drag_data_get) connect_obj(view, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) self.pack_start(Align(search, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.__cover_column) self.connect('key-press-event', self.__key_pressed, library.librarian) self.show_all()
def __init_window(self): """ Add fields for all ui objects we need to access from code. Initialize everything we can't do from glade like events and other stuff. """ log.info("Initialize main window") self.window = self.window_builder.get_object("app_window") self.window.set_default_size(1100, 700) self.window.set_application(self.app) self.window.show_all() self.window.present() self.window.connect("delete-event", self.on_close) self.window.connect("drag_data_received", self.__on_drag_data_received) self.window.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY) if not Gtk.get_minor_version() > 18: self.window.connect("check-resize", self.__window_resized) # hide wip stuff self.volume_button = self.window_builder.get_object("volume_button") self.volume_button.set_visible(False) self.search_button = self.window_builder.get_object("search_button") self.search_button.set_visible(False) self.timer_button = self.window_builder.get_object("timer_button") search_button = self.window_builder.get_object("search_button") search_popover = self.search_builder.get_object("search_popover") timer_popover = self.timer_builder.get_object("timer_popover") self.timer_switch = self.timer_builder.get_object("timer_switch") self.timer_scale = self.timer_builder.get_object("timer_scale") self.timer_spinner = self.timer_builder.get_object("timer_spinner") self.timer_buffer = self.timer_builder.get_object("timer_buffer") self.cover_img = self.window_builder.get_object("cover_img") self.throbber = self.window_builder.get_object("spinner") self.author_box = self.window_builder.get_object("author_box") self.reader_box = self.window_builder.get_object("reader_box") self.book_box = self.window_builder.get_object("book_box") self.book_scroller = self.window_builder.get_object("book_scroller") self.sort_stack = self.window_builder.get_object("sort_stack") self.sort_box = self.window_builder.get_object("sort_box") self.progress_bar = self.window_builder.get_object("progress_bar") self.update_progress_bar = self.window_builder.get_object("update_progress_bar") self.import_box = self.window_builder.get_object("import_box") self.position_box = self.window_builder.get_object("position_box") self.location_chooser = self.settings_builder.get_object("location_chooser") self.status_stack = self.window_builder.get_object("status_stack") self.status_label = self.window_builder.get_object("status_label") self.play_button = self.window_builder.get_object("play_button") self.prev_button = self.window_builder.get_object("prev_button") self.main_stack = self.window_builder.get_object("main_stack") self.play_img = self.window_builder.get_object("play_img") self.pause_img = self.window_builder.get_object("pause_img") self.title_label = self.window_builder.get_object("title_label") self.subtitle_label = self.window_builder.get_object("subtitle_label") self.progress_scale = self.window_builder.get_object("progress_scale") self.current_label = self.window_builder.get_object("current_label") self.remaining_label = self.window_builder.get_object("remaining_label") self.author_toggle_button = self.window_builder.get_object("author_toggle_button") self.reader_toggle_button = self.window_builder.get_object("reader_toggle_button") self.no_media_file_chooser = self.window_builder.get_object("no_media_file_chooser") self.timer_image = self.window_builder.get_object("timer_image") # get settings window self.settings_window = self.settings_builder.get_object("settings_window") self.settings_window.set_transient_for(self.window) self.settings_window.connect("delete-event", self.hide_window) self.init_db_settings() # get about dialog self.about_dialog = self.about_builder.get_object("about_dialog") self.about_dialog.set_transient_for(self.window) self.about_dialog.connect("delete-event", self.hide_window) self.about_dialog.set_version(self.version) # we need to update the database when the audio book location was changed folder_chooser = self.settings_builder.get_object("location_chooser") folder_chooser.connect("file-set", self.__on_folder_changed) self.no_media_file_chooser.connect("file-set", self.__on_no_media_folder_changed) # init popovers search_button.set_popover(search_popover) self.timer_button.set_popover(timer_popover) self.timer_switch.connect("notify::active", self.__timer_switch_changed) # add marks to timer scale for i in range(0, 181, 15): self.timer_scale.add_mark(i, Gtk.PositionType.RIGHT, None) # this is required otherwise the timer will not show "min" on start self.__init_timer_buffer() # timer SpinButton text format self.timer_spinner.connect("value-changed", self.__on_timer_changed) self.timer_spinner.connect("focus-out-event", self.__on_timer_focus_out) # init progress scale self.progress_scale.connect("button-release-event", self.__on_progress_clicked) self.progress_scale.connect("button-press-event", self.__on_progress_press) self.progress_scale.connect("value-changed", self.__update_ui_time) # shortcuts self.accel = Gtk.AccelGroup() # sorting and filtering self.author_box.connect("row-activated", self.__on_listbox_changed) self.reader_box.connect("row-activated", self.__on_listbox_changed) self.book_box.set_sort_func(self.__sort_books, None, False) self.book_box.set_filter_func(self.__filter_books, None, False) self.book_box.connect("selected-children-changed", self.__on_book_selec_changed) # button actions self.play_button.connect("clicked", self.__on_play_pause_clicked) self.prev_button.connect("clicked", self.__on_rewind_clicked) self.author_toggle_button.connect("toggled", self.__toggle_author) self.reader_toggle_button.connect("toggled", self.__toggle_reader) # menu menu = self.menu_builder.get_object("app_menu") self.menu_button = self.window_builder.get_object("menu_button") # for elementary we add a menu button, else we just set the app menu if self.is_elementary: self.menu_button.set_visible(True) self.menu_button.set_menu_model(menu) else: self.menu_button.set_visible(False) if self.is_elementary: about_close_button = self.about_builder.get_object("button_box").get_children()[2] about_close_button.connect("clicked", self.__about_close_clicked) add_player_listener(self.__player_changed)
def __init__(self, main): super(MenuBar, self).__init__() self.main = main self.uicore = self.main.uicore agr = Gtk.AccelGroup() self.main.window.add_accel_group(agr) actiongroup = Gtk.ActionGroup('MainButton') # File menu items newmenu = Gtk.Action('New', None, None, Gtk.STOCK_NEW) newmenu.connect("activate", self.new_file) actiongroup.add_action_with_accel(newmenu, '<Control>N') newmenu.set_accel_group(agr) newmenu.connect_accelerator() newmenuitem = newmenu.create_menu_item() self.append(newmenuitem) self.manager = Gtk.RecentManager.get_default() self.recent_menu = Gtk.RecentChooserMenu.new_for_manager(self.manager) self.recentm = Gtk.MenuItem('Recent targets') self.recentm.set_submenu(self.recent_menu) self.recent_menu.connect('item-activated', self.recent_kb) self.append(self.recentm) smenu = Gtk.Menu() savem = Gtk.ImageMenuItem(Gtk.STOCK_SAVE) savem.get_children()[0].set_label('Save') savem.set_submenu(smenu) saves = [ ['All', Gtk.STOCK_SAVE_AS, 'all'], ['Disassembly', Gtk.STOCK_SORT_DESCENDING, 'asm'], ['Hexdump', Gtk.STOCK_INDEX, 'hex'], ['Strings', Gtk.STOCK_JUSTIFY_CENTER, 'str'], ] for save in saves: savei = Gtk.ImageMenuItem(save[1]) savei.get_children()[0].set_label(save[0]) savei.connect("activate", self._save, save[2]) smenu.append(savei) self.append(savem) sep = Gtk.SeparatorMenuItem() self.append(sep) tmenu = Gtk.Menu() themem = Gtk.ImageMenuItem(Gtk.STOCK_SELECT_COLOR) themem.get_children()[0].set_label('Themes') themem.set_submenu(tmenu) themes = ['Classic', 'Cobalt', 'kate', 'Oblivion', 'Tango'] for theme in themes: themei = Gtk.MenuItem(theme) themei.connect("activate", self._on_theme_change) tmenu.append(themei) self.append(themem) # View Menu self.vmenu = Gtk.Menu() tabsm = Gtk.ImageMenuItem(Gtk.STOCK_PREFERENCES) tabsm.get_children()[0].set_label('Show tabs') tabsm.set_submenu(self.vmenu) self.append(tabsm) sep = Gtk.SeparatorMenuItem() self.append(sep) # Cheatsheet. cheat = Gtk.Action('Cheat sheet', 'Cheat sheet', None, Gtk.STOCK_JUSTIFY_FILL) cheat.connect("activate", self.create_cheatsheet_dialog) actiongroup.add_action_with_accel(cheat, 'F1') cheat.set_accel_group(agr) cheat.connect_accelerator() cheatitem = cheat.create_menu_item() self.append(cheatitem) # Help menu. helpmenu = Gtk.Action('Help', None, None, Gtk.STOCK_HELP) helpmenu.connect("activate", self.show_wiki) actiongroup.add_action_with_accel(helpmenu, '<Control>H') helpmenu.set_accel_group(agr) helpmenu.connect_accelerator() helpmenuitem = helpmenu.create_menu_item() self.append(helpmenuitem) # About. about = Gtk.Action('About', None, None, Gtk.STOCK_ABOUT) about.connect("activate", self.create_about_dialog) actiongroup.add_action_with_accel(about, '<Control>A') about.set_accel_group(agr) about.connect_accelerator() aboutitem = about.create_menu_item() self.append(aboutitem) sep = Gtk.SeparatorMenuItem() self.append(sep) # Quit. exit = Gtk.Action('Quit', None, None, Gtk.STOCK_QUIT) exit.connect('activate', self.main.quit) actiongroup.add_action_with_accel(exit, '<Control>Q') exit.set_accel_group(agr) exit.connect_accelerator() exititem = exit.create_menu_item() self.append(exititem)
def __init__(self, library, dir=None): super(ExFalsoWindow, self).__init__(dialog=False) self.set_title("Ex Falso") self.set_default_size(750, 475) self.enable_window_tracking("exfalso") self.__library = library hp = ConfigRHPaned("memory", "exfalso_paned_position", 1.0) hp.set_border_width(0) hp.set_position(250) hp.show() self.add(hp) vb = Gtk.VBox() bbox = Gtk.HBox(spacing=6) def prefs_cb(*args): window = PreferencesWindow(self) window.show() def plugin_window_cb(*args): window = PluginWindow(self) window.show() def about_cb(*args): about = AboutDialog(self, app) about.run() about.destroy() def update_cb(*args): d = UpdateDialog(self) d.run() d.destroy() menu = Gtk.Menu() about_item = MenuItem(_("_About"), Icons.HELP_ABOUT) about_item.connect("activate", about_cb) menu.append(about_item) check_item = MenuItem(_("_Check for Updates…"), Icons.NETWORK_SERVER) check_item.connect("activate", update_cb) menu.append(check_item) menu.append(SeparatorMenuItem()) plugin_item = MenuItem(_("_Plugins"), Icons.SYSTEM_RUN) plugin_item.connect("activate", plugin_window_cb) menu.append(plugin_item) pref_item = MenuItem(_("_Preferences"), Icons.PREFERENCES_SYSTEM) pref_item.connect("activate", prefs_cb) menu.append(pref_item) menu.show_all() menu_button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.BUTTON), arrow=True, down=False) menu_button.set_menu(menu) bbox.pack_start(menu_button, False, True, 0) l = Gtk.Label() l.set_alignment(1.0, 0.5) l.set_ellipsize(Pango.EllipsizeMode.END) bbox.pack_start(l, True, True, 0) self._fs = fs = MainFileSelector() vb.pack_start(fs, True, True, 0) vb.pack_start(Align(bbox, border=6), False, True, 0) vb.show_all() hp.pack1(vb, resize=True, shrink=False) nb = qltk.Notebook() nb.props.scrollable = True nb.show() for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]: page = Page(self, self.__library) page.show() nb.append_page(page) hp.pack2(nb, resize=True, shrink=False) fs.connect('changed', self.__changed, l) if dir: fs.go_to(dir) connect_destroy(self.__library, 'changed', self.__library_changed, fs) self.__save = None connect_obj(self, 'changed', self.set_pending, None) for c in fs.get_children(): c.get_child().connect('button-press-event', self.__pre_selection_changed, fs, nb) c.get_child().connect('focus', self.__pre_selection_changed, fs, nb) fs.get_children()[1].get_child().connect('popup-menu', self.__popup_menu, fs) self.emit('changed', []) self.get_child().show() self.__ag = Gtk.AccelGroup() key, mod = Gtk.accelerator_parse("<Primary>Q") self.__ag.connect(key, mod, 0, lambda *x: self.destroy()) self.add_accel_group(self.__ag) # GtkosxApplication assumes the menu bar is mapped, so add # it but don't show it. self._dummy_osx_menu_bar = Gtk.MenuBar() vb.pack_start(self._dummy_osx_menu_bar, False, False, 0)
def __init__(self, Prototype, values, filename, title): if self.is_not_unique(): return super().__init__() self.Prototype = Prototype self.current = None self.filename = filename self.name = Prototype.NAME or Prototype.__name__ self.input_entries = {} self.set_border_width(12) self.set_title(title) self.set_default_size(self._WIDTH, self._HEIGHT) self.add(Gtk.HBox(spacing=6)) self.get_child().set_homogeneous(True) self.accels = Gtk.AccelGroup() # Set up the model for this widget self.model = Gtk.ListStore(object) self._fill_values(values) # The browser for existing data self.view = view = RCMHintedTreeView(model=self.model) view.set_headers_visible(False) view.set_reorderable(True) view.set_rules_hint(True) render = Gtk.CellRendererText() render.set_padding(3, 6) render.props.ellipsize = Pango.EllipsizeMode.END column = Gtk.TreeViewColumn("", render) column.set_cell_data_func(render, self.__cdf) view.append_column(column) sw = Gtk.ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.add(view) self.get_child().pack_start(sw, True, True, 0) vbox = Gtk.VBox(spacing=6) # Input for new ones. frame = self.__build_input_frame() vbox.pack_start(frame, False, True, 0) # Add context menu menu = Gtk.Menu() rem = MenuItem(_("_Remove"), Icons.LIST_REMOVE) keyval, mod = Gtk.accelerator_parse("Delete") rem.add_accelerator('activate', self.accels, keyval, mod, Gtk.AccelFlags.VISIBLE) connect_obj(rem, 'activate', self.__remove, view) menu.append(rem) menu.show_all() view.connect('popup-menu', self.__popup, menu) view.connect('key-press-event', self.__view_key_press) connect_obj(self, 'destroy', Gtk.Menu.destroy, menu) # New and Close buttons bbox = Gtk.HButtonBox() self.remove_but = Button(_("_Remove"), Icons.LIST_REMOVE) self.remove_but.set_sensitive(False) self.new_but = Button(_("_New"), Icons.DOCUMENT_NEW) self.new_but.connect('clicked', self._new_item) bbox.pack_start(self.new_but, True, True, 0) close = Button(_("_Close"), Icons.WINDOW_CLOSE) connect_obj(close, 'clicked', qltk.Window.destroy, self) bbox.pack_start(close, True, True, 0) vbox.pack_end(bbox, False, True, 0) self.get_child().pack_start(vbox, True, True, 0) # Initialise self.selection = view.get_selection() self.selection.connect('changed', self.__select) self.connect('destroy', self.__finish) self.get_child().show_all()
def __init__(self, builder, settings: "GreeterSettingsCollection"): Gtk.Dialog.__init__(self, use_header_bar=True) TranslatableWindow.__init__(self, self) self.settings = settings self.listbox = builder.get_object('listbox_add_setting') for setting in self.settings.additional_settings: logging.debug("Adding '%s' to additional settings listbox", setting.id) self.listbox.add(setting.listboxrow) self.set_transient_for(self) self.set_title(_("Additional Settings")) self.set_default_size(-1, PREFERRED_WIDTH) sizegroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL) accelgroup = Gtk.AccelGroup() self.add_accel_group(accelgroup) self.button_cancel = self.add_button(_("Cancel"), Gtk.ResponseType.CANCEL) accelgroup.connect(Gdk.KEY_Escape, 0, 0, self.cb_accelgroup_cancel_activated) sizegroup.add_widget(self.button_cancel) self.button_add = self.add_button(_("Add"), Gtk.ResponseType.YES) Gtk.StyleContext.add_class(self.button_add.get_style_context(), 'suggested-action') sizegroup.add_widget(self.button_add) accelgroup.connect(Gdk.KEY_Return, 0, 0, self.cb_accelgroup_add_activated) self.button_add.set_visible(False) self.button_back = Gtk.Button.new_with_label(_("Back")) self.button_back.set_visible(False) self.button_back.connect('clicked', self.cb_button_back_clicked, None) sizegroup.add_widget(self.button_back) accelgroup.connect(Gdk.KEY_Back, 0, 0, self.cb_accelgroup_back_activated) # These key bindings are copied from Firefox, and are the same with # right-to-left languages. accelgroup.connect(Gdk.KEY_Left, Gdk.ModifierType.MOD1_MASK, 0, self.cb_accelgroup_back_activated) accelgroup.connect(Gdk.KEY_KP_Left, Gdk.ModifierType.MOD1_MASK, 0, self.cb_accelgroup_back_activated) self.get_header_bar().pack_end(self.button_back) self.stack = Gtk.Stack() self.stack.add_named(self.listbox, "setting-type") self.listbox.set_valign(Gtk.Align.FILL) self.listbox.set_vexpand(True) self.stack.set_visible(True) # XXX: is SLIDE_LEFT_RIGHT automatically inversed in RTL mode? self.stack.set_transition_type( Gtk.StackTransitionType.SLIDE_LEFT_RIGHT) self.get_content_area().add(self.stack) # Store translations self.store_translations(self) for setting in self.settings.additional_settings: self.store_translations(setting.box)
def __init__(self, handle, create_jobject=True): """Initialise the Activity handle -- sugar3.activity.activityhandle.ActivityHandle instance providing the activity id and access to the presence service which *may* provide sharing for this application create_jobject -- boolean define if it should create a journal object if we are not resuming Side effects: Sets the gdk screen DPI setting (resolution) to the Sugar screen resolution. Connects our "destroy" message to our _destroy_cb method. Creates a base Gtk.Window within this window. Creates an ActivityService (self._bus) servicing this application. Usage: If your Activity implements __init__(), it should call the base class __init()__ before doing Activity specific things. """ # Stuff that needs to be done early icons_path = os.path.join(get_bundle_path(), 'icons') Gtk.IconTheme.get_default().append_search_path(icons_path) sugar_theme = 'sugar-72' if 'SUGAR_SCALING' in os.environ: if os.environ['SUGAR_SCALING'] == '100': sugar_theme = 'sugar-100' # This code can be removed when we grow an xsettings daemon (the GTK+ # init routines will then automatically figure out the font settings) settings = Gtk.Settings.get_default() settings.set_property('gtk-theme-name', sugar_theme) settings.set_property('gtk-icon-theme-name', 'sugar') settings.set_property('gtk-font-name', '%s %f' % (style.FONT_FACE, style.FONT_SIZE)) Window.__init__(self) if 'SUGAR_ACTIVITY_ROOT' in os.environ: # If this activity runs inside Sugar, we want it to take all the # screen. Would be better if it was the shell to do this, but we # haven't found yet a good way to do it there. See #1263. self.connect('window-state-event', self.__window_state_event_cb) screen = Gdk.Screen.get_default() screen.connect('size-changed', self.__screen_size_changed_cb) self._adapt_window_to_screen() # process titles will only show 15 characters # but they get truncated anyway so if more characters # are supported in the future we will get a better view # of the processes proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id) util.set_proc_title(proc_title) self.connect('realize', self.__realize_cb) self.connect('delete-event', self.__delete_event_cb) self._active = False self._active_time = None self._spent_time = 0 self._activity_id = handle.activity_id self.shared_activity = None self._join_id = None self._updating_jobject = False self._closing = False self._quit_requested = False self._deleting = False self._max_participants = None self._invites_queue = [] self._jobject = None self._read_file_called = False self._session = _get_session() self._session.register(self) self._session.connect('quit-requested', self.__session_quit_requested_cb) self._session.connect('quit', self.__session_quit_cb) accel_group = Gtk.AccelGroup() self.sugar_accel_group = accel_group self.add_accel_group(accel_group) self._bus = ActivityService(self) self._owns_file = False share_scope = SCOPE_PRIVATE if handle.object_id: self._jobject = datastore.get(handle.object_id) if 'share-scope' in self._jobject.metadata: share_scope = self._jobject.metadata['share-scope'] if 'launch-times' in self._jobject.metadata: self._jobject.metadata['launch-times'] += ', %d' % \ int(time.time()) else: self._jobject.metadata['launch-times'] = \ str(int(time.time())) if 'spent-times' in self._jobject.metadata: self._jobject.metadata['spent-times'] += ', 0' else: self._jobject.metadata['spent-times'] = '0' self.shared_activity = None self._join_id = None if handle.object_id is None and create_jobject: logging.debug('Creating a jobject.') self._jobject = self._initialize_journal_object() if handle.invited: wait_loop = GObject.MainLoop() self._client_handler = _ClientHandler( self.get_bundle_id(), partial(self.__got_channel_cb, wait_loop)) # FIXME: The current API requires that self.shared_activity is set # before exiting from __init__, so we wait until we have got the # shared activity. http://bugs.sugarlabs.org/ticket/2168 wait_loop.run() else: pservice = presenceservice.get_instance() mesh_instance = pservice.get_activity(self._activity_id, warn_if_none=False) self._set_up_sharing(mesh_instance, share_scope) if not create_jobject: self.set_title(get_bundle_name()) return if self.shared_activity is not None: self._jobject.metadata['title'] = self.shared_activity.props.name self._jobject.metadata['icon-color'] = \ self.shared_activity.props.color else: self._jobject.metadata.connect('updated', self.__jobject_updated_cb) self.set_title(self._jobject.metadata['title'])
def get_widget(self, uri, window): """Returns the widgets to display to Caja.""" #Kill old child process try: window.nt_lastpid except AttributeError: #First terminal of the window window.nt_lastpid = -1 else: #Kill old child if window.nt_lastpid > 0: try: os.kill(window.nt_lastpid, signal.SIGKILL) except: pass finally: window.nt_lastpid = -1 #Set some variables for new windows try: window.nt_termheight except AttributeError: window.nt_termheight = -1 try: window.nt_termhidden except AttributeError: window.nt_termhidden = CONF['general_starthidden'] #If it's not a local folder, directory = $HOME if uri[:7] == "file://": path = urllib.url2pathname(uri[7:]) else: path = os.environ.get("HOME") #Disable for desktop folder if uri.startswith("x-caja-desktop://"): return #White list if not CONF['folders_showinall'] and \ not match_path(path, CONF['folders_list']): return #GUI gui = Gtk.Builder() gui.set_translation_domain(__appname__) gui.add_from_file(TERMINAL_GUI_FILE) vboxMain = gui.get_object("vboxMain") #### hboxHidden #### hboxHidden = gui.get_object("hboxHidden") if window.nt_termhidden: hboxHidden.show() else: hboxHidden.hide() btnPref2 = gui.get_object("btnPref2") btnHide = gui.get_object("btnHide") btnShow = gui.get_object("btnShow") #### hboxTerm #### hboxTerm = gui.get_object("hboxTerm") if window.nt_termhidden: hboxTerm.hide() else: hboxTerm.show() btnPref = gui.get_object("btnPref") sclwinTerm = gui.get_object("sclwinTerm") #terminal terminal = Vte.Terminal() terminal.last_size = window.nt_termheight self.fork_cmd(window, terminal, sclwinTerm, path) terminal.show() sclwinTerm.add(terminal) #scrollbar terminal.set_hadjustment(gui.get_object("adjH")) terminal.set_vadjustment(gui.get_object("adjV")) if CONF['general_showscrollbar']: vpolicy = Gtk.PolicyType.ALWAYS else: vpolicy = Gtk.PolicyType.NEVER sclwinTerm.set_policy( Gtk.PolicyType.NEVER, #Horizontal vpolicy, #Vertical ) if window.nt_termheight == -1: window.nt_termheight = terminal.get_char_height( ) * CONF['general_defheight'] sclwinTerm.set_size_request(-1, window.nt_termheight) #Apply config on the terminal self._set_terminal(terminal) #### evResize #### evResize = gui.get_object("evResize") if window.nt_termhidden: evResize.hide() else: evResize.show() #### Signals #### #evResize evResize.connect("enter-notify-event", self.on_evResize_enter_notify_event, sclwinTerm) evResize.connect("leave-notify-event", self.on_evResize_leave_notify_event) evResize.connect("motion-notify-event", self.on_evResize_motion_notify_event, sclwinTerm, terminal, window) #Button preferences btnPref.connect("clicked", self.preferences, terminal) #Button preferences 2 btnPref2.connect("clicked", self.preferences, terminal) #Button Hide btnHide.connect( "clicked", self.hide, window, hboxHidden, hboxTerm, evResize, ) #Button Show btnShow.connect( "clicked", self.show, window, hboxHidden, hboxTerm, terminal, evResize, ) #Terminal terminal.connect("destroy", self.on_terminal_destroy, window) terminal.connect("child-exited", self.on_terminal_child_exited) terminal.connect( "commit", self.on_terminal_commit, window, sclwinTerm, path, ) terminal.connect( "focus", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) if Gtk.check_version(3, 0, 0) is None: terminal.connect( "draw", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) else: terminal.connect( "expose-event", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) terminal.connect( "button-press-event", self.on_terminal_need_child, window, terminal, sclwinTerm, path, ) terminal.connect( "key-press-event", self.on_terminal_key_press_event, window, sclwinTerm, path, ) terminal.connect("key-release-event", self.on_terminal_key_release_event) #DnD try: # Missing from Gtk-2.0 introspection terminal.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new('text/uri-list', 0, 80)], Gdk.DragAction.COPY, ) terminal.connect("drag_motion", self.on_terminal_drag_motion) terminal.connect("drag_drop", self.on_terminal_drag_drop) terminal.connect("drag_data_received", self.on_terminal_drag_data_received) except (AttributeError, TypeError): pass #### Accel #### accel_group = Gtk.AccelGroup() window.add_accel_group(accel_group) terminal.add_accelerator( "paste-clipboard", accel_group, ord('V'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) terminal.add_accelerator( "copy-clipboard", accel_group, ord('C'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) btnShow.add_accelerator( "clicked", accel_group, ord('T'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) btnHide.add_accelerator( "clicked", accel_group, ord('T'), Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK, Gtk.AccelFlags.VISIBLE, ) #### Return the widgets #### vboxMain.unparent() return vboxMain
def do_activate(self): if self.window: self.window.present() return self.window = Gtk.ApplicationWindow(application=self, title="GNU Health") self.window.set_default_size(960, 720) self.window.maximize() self.window.set_position(Gtk.WindowPosition.CENTER) self.window.set_resizable(True) self.window.set_icon(GNUHEALTH_ICON) self.window.connect("destroy", self.on_quit) self.window.connect("delete_event", self.on_quit) self.header = Gtk.HeaderBar.new() self.header.set_show_close_button(True) self.window.set_titlebar(self.header) self.set_title() menu = Gtk.Button.new() menu .set_relief(Gtk.ReliefStyle.NONE) menu.set_image( common.IconFactory.get_image('tryton-menu', Gtk.IconSize.BUTTON)) menu.connect('clicked', self.menu_toggle) self.header.pack_start(menu) favorite = Gtk.MenuButton.new() favorite.set_relief(Gtk.ReliefStyle.NONE) favorite.set_image(common.IconFactory.get_image( 'tryton-bookmarks', Gtk.IconSize.BUTTON)) self.menu_favorite = Gtk.Menu.new() favorite.set_popup(self.menu_favorite) favorite.connect('clicked', self.favorite_set) self.header.pack_start(favorite) self.set_global_search() self.header.pack_start(self.global_search_entry) self.accel_group = Gtk.AccelGroup() self.window.add_accel_group(self.accel_group) Gtk.AccelMap.add_entry( '<tryton>/Form/New', Gdk.KEY_N, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Save', Gdk.KEY_S, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Duplicate', Gdk.KEY_D, Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Delete', Gdk.KEY_D, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Next', Gdk.KEY_Page_Down, 0) Gtk.AccelMap.add_entry( '<tryton>/Form/Previous', Gdk.KEY_Page_Up, 0) Gtk.AccelMap.add_entry( '<tryton>/Form/Switch View', Gdk.KEY_L, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Close', Gdk.KEY_W, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Reload', Gdk.KEY_R, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Attachments', Gdk.KEY_T, Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Notes', Gdk.KEY_O, Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Relate', Gdk.KEY_R, Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Actions', Gdk.KEY_E, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Report', Gdk.KEY_P, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.add_entry( '<tryton>/Form/Search', Gdk.KEY_F, Gdk.ModifierType.CONTROL_MASK) Gtk.AccelMap.load(os.path.join(get_config_dir(), 'accel.map')) self.tooltips = common.Tooltips() self.vbox = Gtk.VBox() self.window.add(self.vbox) self.buttons = {} self.info = Gtk.VBox() self.vbox.pack_start(self.info, expand=False, fill=True, padding=0) self.pane = Gtk.HPaned() self.vbox.pack_start(self.pane, expand=True, fill=True, padding=0) self.pane.set_position(int(CONFIG['menu.pane'])) self.menu_screen = None self.menu = Gtk.VBox() self.menu.set_vexpand(True) self.pane.add1(self.menu) self.notebook = Gtk.Notebook() self.notebook.popup_enable() self.notebook.set_scrollable(True) self.notebook.connect_after('switch-page', self._sig_page_changt) self.pane.add2(self.notebook) self.window.show_all() self.pages = [] self.previous_pages = {} self.current_page = 0 self.last_page = 0 self.dialogs = [] # Register plugins tryton.plugins.register() # GNUHEALTH CLI self.cli = self.statusbar = self.footer_contents = self.footer = None self.cli_position = CONFIG['client.cli_position'] self.set_title() # Adds username/profile while password is asked try: common.Login() except Exception as exception: if (not isinstance(exception, TrytonError) or exception.faultCode != 'QueryCanceled'): common.error(exception, traceback.format_exc()) return self.quit() self.get_preferences() #GNUHealth Block #Add connection successful entry to the Activity log msg = "Connected to GNU Health Server" self.activity_log_entry(msg, 'info') # Set the footer self.init_gnuhealth_env()
def __init__(self, library): Browser.__init__(self, spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self.songcontainer = qltk.paned.ConfigRVPaned( "browsers", "covergrid_pos", 0.4) if config.getboolean("browsers", "covergrid_wide", False): self.songcontainer.set_orientation(Gtk.Orientation.HORIZONTAL) self._register_instance() if self.__model is None: self._init_model(library) self._cover_cancel = Gio.Cancellable() self.scrollwin = sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.view = view = IconView(model_filter) #view.set_item_width(get_cover_size() + 12) self.view.set_row_spacing(config.getint("browsers", "row_spacing", 6)) self.view.set_column_spacing(config.getint("browsers", "column_spacing", 6)) self.view.set_item_padding(config.getint("browsers", "item_padding", 6)) self.view.set_has_tooltip(True) self.view.connect("query-tooltip", self._show_tooltip) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) mag = config.getfloat("browsers", "covergrid_magnification", 3.) self.view.set_item_width(get_cover_size() * mag + 8) self.__cover = render = Gtk.CellRendererPixbuf() render.set_property('width', get_cover_size() * mag + 8) render.set_property('height', get_cover_size() * mag + 8) view.pack_start(render, False) def cell_data_pb(view, cell, model, iter_, no_cover): item = model.get_value(iter_) if item.album is None: surface = None elif item.cover: pixbuf = item.cover pixbuf = add_border_widget(pixbuf, self.view) surface = get_surface_for_pixbuf(self, pixbuf) # don't cache, too much state has an effect on the result self.__last_render_surface = None else: surface = no_cover if self.__last_render_surface == surface: return self.__last_render_surface = surface cell.set_property("surface", surface) view.set_cell_data_func(render, cell_data_pb, self._no_cover) self.__text_cells = render = Gtk.CellRendererText() render.set_visible(config.getboolean("browsers", "album_text", True)) render.set_property('alignment', Pango.Alignment.CENTER) render.set_property('xalign', 0.5) render.set_property('ellipsize', Pango.EllipsizeMode.END) view.pack_start(render, False) def cell_data(view, cell, model, iter_, data): album = model.get_album(iter_) if album is None: text = "<b>%s</b>" % _("All Albums") text += "\n" + ngettext("%d album", "%d albums", len(model) - 1) % (len(model) - 1) markup = text else: markup = self.display_pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) view.set_cell_data_func(render, cell_data, None) view.set_selection_mode(Gtk.SelectionMode.MULTIPLE) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.add(view) view.connect('item-activated', self.__play_selection, None) self.__sig = connect_destroy( view, 'selection-changed', util.DeferredSignal(self.__update_songs, owner=self)) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set( Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) view.connect("drag-data-get", self.__drag_data_get) # NOT WORKING connect_obj(view, 'button-press-event', self.__rightclick, view, library) connect_obj(view, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) self.pack_start(Align(search, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.view) self.__update_filter() self.connect('key-press-event', self.__key_pressed, library.librarian) if app.cover_manager: connect_destroy( app.cover_manager, "cover-changed", self._cover_changed) self.show_all()
def __init__(self, config, application): """ :param dict config: The main King Phisher client configuration. :param application: The application instance to which this window belongs. :type application: :py:class:`.KingPhisherClientApplication` """ assert isinstance(application, Gtk.Application) super(MainAppWindow, self).__init__(application=application) self.application = application self.logger = logging.getLogger('KingPhisher.Client.MainWindow') self.config = config """The main King Phisher client configuration.""" self.set_property('title', 'King Phisher') vbox = Gtk.Box() vbox.set_property('orientation', Gtk.Orientation.VERTICAL) vbox.show() self.add(vbox) default_icon_file = find.find_data_file('king-phisher-icon.svg') if default_icon_file: icon_pixbuf = GdkPixbuf.Pixbuf.new_from_file(default_icon_file) self.set_default_icon(icon_pixbuf) self.accel_group = Gtk.AccelGroup() self.add_accel_group(self.accel_group) self.menu_bar = MainMenuBar(application, self) vbox.pack_start(self.menu_bar.menubar, False, False, 0) # create notebook and tabs self.notebook = Gtk.Notebook() """The primary :py:class:`Gtk.Notebook` that holds the top level taps of the client GUI.""" self.notebook.connect('switch-page', self.signal_notebook_switch_page) self.notebook.set_scrollable(True) vbox.pack_start(self.notebook, True, True, 0) self.tabs = {} current_page = self.notebook.get_current_page() self.last_page_id = current_page mailer_tab = MailSenderTab(self, self.application) self.tabs['mailer'] = mailer_tab self.notebook.insert_page(mailer_tab.box, mailer_tab.label, current_page + 1) self.notebook.set_current_page(current_page + 1) campaign_tab = CampaignViewTab(self, self.application) campaign_tab.box.show() self.tabs['campaign'] = campaign_tab self.notebook.insert_page(campaign_tab.box, campaign_tab.label, current_page + 2) self.set_size_request(800, 600) self.connect('delete-event', self.signal_delete_event) self.notebook.show() self.show() self.rpc = None # needs to be initialized last """The :py:class:`.KingPhisherRPCClient` instance.""" self.application.connect('server-connected', self.signal_kp_server_connected) self.login_dialog = dialogs.LoginDialog(self.application) self.login_dialog.dialog.connect('response', self.signal_login_dialog_response) self.login_dialog.dialog.show()
def __init__(self, main): super(MenuBar, self).__init__() self.main = main self.gom = self.main.gom self.uicore = self.main.uicore agr = Gtk.AccelGroup() self.main.add_accel_group(agr) # New KB item newi = Gtk.ImageMenuItem(Gtk.STOCK_NEW, agr) #newi.connect("activate", self.new_file) newi.get_children()[0].set_label('New KB') key, mod = Gtk.accelerator_parse("<Control>N") newi.add_accelerator("activate", agr, key, mod, Gtk.AccelFlags.VISIBLE) newi.set_sensitive(False) self.append(newi) # Save KB item savei = Gtk.ImageMenuItem(Gtk.STOCK_SAVE) savei.get_children()[0].set_label('Save') key, mod = Gtk.accelerator_parse("<Control>S") savei.add_accelerator("activate", agr, key, mod, Gtk.AccelFlags.VISIBLE) savei.connect("activate", self.save_kb) self.append(savei) # Load KB item loadi = Gtk.ImageMenuItem(Gtk.STOCK_OPEN) loadi.get_children()[0].set_label('Load') key, mod = Gtk.accelerator_parse("<Control>O") loadi.add_accelerator("activate", agr, key, mod, Gtk.AccelFlags.VISIBLE) loadi.connect("activate", self.load_kb) self.append(loadi) # Recent KB items self.manager = Gtk.RecentManager.get_default() filter = Gtk.RecentFilter() filter.add_pattern("*.kb") recent_menu = Gtk.RecentChooserMenu.new_for_manager(self.manager) recent_menu.add_filter(filter) recentm = Gtk.MenuItem('Recent KB') recentm.set_submenu(recent_menu) recent_menu.connect('item-activated', self.recent_kb) self.append(recentm) # Separator sep = Gtk.SeparatorMenuItem() self.append(sep) # Imports: nmap, host list, w3af and burp... impi = Gtk.ImageMenuItem(Gtk.STOCK_CONVERT) #impi.get_children()[0].set_label('Import') label = impi.get_children()[0] label.set_markup('<b>Import</b>') impi.connect('activate', self.import_scan, None) self.append(impi) # Host list imp_hostsi = Gtk.MenuItem('Host list') imp_hostsi.connect('activate', self.import_scan, 'hosts') self.append(imp_hostsi) # Nmap scan imp_nmapi = Gtk.MenuItem('Nmap XML') imp_nmapi.connect('activate', self.import_scan, 'nmap') self.append(imp_nmapi) # w3af XML imp_w3afi = Gtk.MenuItem('w3af XML') imp_w3afi.set_sensitive(False) self.append(imp_w3afi) # Burp XML imp_burpi = Gtk.MenuItem('Burp XML') imp_burpi.set_sensitive(False) self.append(imp_burpi) # Separator sep = Gtk.SeparatorMenuItem() self.append(sep) # Documentation helpi = Gtk.ImageMenuItem(Gtk.STOCK_HELP, agr) helpi.get_children()[0].set_label('Documentation') # key, mod = Gtk.accelerator_parse("<Control>Q") # helpi.add_accelerator("activate", agr, key, # mod, Gtk.AccelFlags.VISIBLE) helpi.connect("activate", self.show_wiki) self.append(helpi) # About item abouti = Gtk.ImageMenuItem(Gtk.STOCK_ABOUT, agr) abouti.get_children()[0].set_label('About Inguma %s' % glob.version) key, mod = Gtk.accelerator_parse("<Control>A") abouti.add_accelerator("activate", agr, key, mod, Gtk.AccelFlags.VISIBLE) abouti.connect("activate", self.create_about_dialog) self.append(abouti) # Separator sep = Gtk.SeparatorMenuItem() self.append(sep) # Exit item exit = Gtk.ImageMenuItem(Gtk.STOCK_QUIT, agr) exit.get_children()[0].set_label('Quit') key, mod = Gtk.accelerator_parse("<Control>Q") exit.add_accelerator("activate", agr, key, mod, Gtk.AccelFlags.VISIBLE) exit.connect("activate", self.main.menu_quit) self.append(exit)
def __init__(self, library): super().__init__(spacing=12) self.set_orientation(Gtk.Orientation.VERTICAL) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) search.connect('query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_(u"_New Station…"), Icons.LIST_ADD) new_item.connect('activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Icons.VIEW_REFRESH) update_item.connect('activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() search.connect('focus-out', focus) # treeview scrolled_window = ScrolledWindow() scrolled_window.show() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.show() view.set_headers_visible(False) scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append( row=[self.TYPE_ALL, Icons.FOLDER, "__all", _("All Stations")]) model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""]) # Translators: Favorite radio stations model.append( row=[self.TYPE_FAV, Icons.FOLDER, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Icons.FOLDER, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Icons.EDIT_FIND, k, text]) model.append( row=[self.TYPE_NOCAT, Icons.FOLDER, "nocat", _("No Category")]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "icon-name", self.ICON_NAME) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = connect_destroy( selection, 'changed', util.DeferredSignal(lambda x: self.activate())) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) self._searchbox = Align(box, left=0, right=6, top=6) self._searchbox.show_all() def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() pane = qltk.ConfigRHPaned("browsers", "internetradio_pos", 0.4) pane.show() pane.pack1(scrolled_window, resize=False, shrink=False) songbox = Gtk.VBox(spacing=6) songbox.pack_start(self._searchbox, False, True, 0) self._songpane_container = Gtk.VBox() self._songpane_container.show() songbox.pack_start(self._songpane_container, True, True, 0) songbox.pack_start(self.qbar, False, True, 0) songbox.show() pane.pack2(songbox, resize=True, shrink=False) self.pack_start(pane, True, True, 0) self.show()
def __init__(self, oParent, oConfig, sFilterType, sDefaultFilter=None): super().__init__("Specify Filter", oParent, Gtk.DialogFlags.DESTROY_WITH_PARENT) self._oAccelGroup = Gtk.AccelGroup() self.__oParent = oParent self.__bWasCancelled = False self.__oParser = FilterParser.FilterParser() self.__oConfig = oConfig self.__sFilterType = sFilterType self.__oFilter = None self.__oFilterEditor = FilterEditor(None, self.__sFilterType, self.__oParser, self) self.__oFilterEditor.connect_name_changed(self.__name_changed) self.__sOriginalName = None self.__sOriginalAST = None self.set_default_size(700, 550) self.connect("response", self.__button_response) self._aDefaultFilters = oConfig.get_default_filters() # Dialog Buttons self.add_button("Clear Filter", self.RESPONSE_CLEAR) self.add_button("Revert Filter", self.RESPONSE_REVERT) self.add_button("Load", self.RESPONSE_LOAD) self.add_button("Save", self.RESPONSE_SAVE) self.add_button("Delete", self.RESPONSE_DELETE) self.action_area.pack_start(Gtk.VSeparator(), True, True, 0) self.add_button("_OK", Gtk.ResponseType.OK) self.add_button("_Cancel", Gtk.ResponseType.CANCEL) self.vbox.pack_start(self.__oFilterEditor, True, True, 0) # set initial filter aDefaultFilters = self.__fetch_filters(True) aConfigFilters = self.__fetch_filters(False) if sDefaultFilter: # Ensure filter isn't broken # pylint: disable=broad-except # we do want to catch all exceptions here try: oAST = self.__oParser.apply(sDefaultFilter) except Exception: # Fall back to usual behaviour sDefaultFilter = None if sDefaultFilter: sName, sFilter = "", sDefaultFilter oAST = self.__oParser.apply(sFilter) elif aDefaultFilters: sName, sFilter = aDefaultFilters[0] oAST = self.__oParser.apply(sFilter) elif aConfigFilters: sName, sFilter = aConfigFilters[0] oAST = self.__oParser.apply(sFilter) else: sName, oAST = "", None self.__load_filter(sName, oAST) self.add_accel_group(self._oAccelGroup) MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'replace_filter', self.replace_filter) MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'add_filter', self.add_remove_filter) MessageBus.subscribe(MessageBus.Type.CONFIG_MSG, 'remove_filter', self.add_remove_filter) self.show_all()
def on_activate(self, app): ui_file_path = os.path.join( os.path.dirname(os.path.abspath(__file__)), "app.ui") appwindow = 'applicationwindow1' builder = Gtk.Builder() builder.add_objects_from_file(ui_file_path, [appwindow]) window = builder.get_object(appwindow) window.set_wmclass ("GNOME Keysign", "GNOME Keysign") window.set_title("GNOME Keysign") window.connect("delete-event", self.on_delete_window) self.headerbar = window.get_titlebar() self.header_button = builder.get_object("back_refresh_button") self.header_button.connect('clicked', self.on_header_button_clicked) self.internet_toggle = builder.get_object("internet_toggle") self.internet_toggle.connect("toggled", self.on_toggle_clicked) sw = builder.get_object('stackswitcher1') # FIXME: I want to be able to press Alt+S and Alt+R respectively # to switch the stack pages to Send and Receive. # It's possible when using the Gtk Inspector and modify the # Switcher's children (ToggleButton and Label) to "use-underscore". # but it must be possible to do programmatically. # sw.get_children() self.stack_switcher = sw self.send_receive_stack = builder.get_object("send_receive_stack") self.send_receive_stack.connect('notify::visible-child', self.on_sr_stack_switch) ## Load Send part self.send = SendApp() ss = self.send.stack p = ss.get_parent() if p: p.remove(ss) ss.connect('notify::visible-child', self.on_send_stack_switch) ss.connect('map', self.on_send_stack_mapped) self.send_stack = ss ## End of loading send part # Load Receive part try: self.receive = PswMappingReceiveApp(self.on_presign_mapped) except NoAvahiDbus as de: log.info("Probably Avahi needs to be manually started: %s", de) ui_file_path = os.path.join( os.path.dirname(os.path.abspath(__file__)), "dialog_avahi.ui") appwindow = 'dialog_avahi' builder = Gtk.Builder() builder.add_objects_from_file(ui_file_path, [appwindow]) window.set_wmclass("GNOME Keysign", "GNOME Keysign") window.set_title("GNOME Keysign") ok_button = builder.get_object("avahi_ok") ok_button.connect('clicked', self.on_delete_window) window = builder.get_object(appwindow) else: rs = self.receive.stack rs.connect('notify::visible-child', self.on_receive_stack_switch) scanner = self.receive.scanner scanner.connect("map", self.on_scanner_mapped) self.receive_stack = rs # Hm. Leaving comments for translators does not seem to work self.send_receive_stack.add_titled(self.send_stack, "send_stack", _("Send")) self.send_receive_stack.add_titled(rs, "receive_stack", _("Receive")) # These properties must be set after the stacks has been added to the window # because they require a window element that "receive.ui" file doesn't provide. accel_group = Gtk.AccelGroup() window.add_accel_group(accel_group) self.receive.accept_button.add_accelerator("clicked", accel_group, ord('o'), Gdk.ModifierType.MOD1_MASK, Gtk.AccelFlags.VISIBLE) self.receive.accept_button.set_can_default(True) window.show_all() self.add_window(window)
def __init__(self, drawing_area, win, uibuilder): self.log = logging.getLogger('VideoPreviewsController') self.drawing_area = drawing_area self.win = win self.sources = Config.getlist('mix', 'sources') self.preview_players = {} self.previews = {} self.a_btns = {} self.b_btns = {} self.current_source = {'a': None, 'b': None} try: width = Config.getint('previews', 'width') self.log.debug('Preview-Width configured to %u', width) except: width = 320 self.log.debug('Preview-Width selected as %u', width) try: height = Config.getint('previews', 'height') self.log.debug('Preview-Height configured to %u', height) except: height = width * 9 / 16 self.log.debug('Preview-Height calculated to %u', height) # Accelerators accelerators = Gtk.AccelGroup() win.add_accel_group(accelerators) group_a = None group_b = None for idx, source in enumerate(self.sources): self.log.info('Initializing Video Preview %s', source) preview = uibuilder.get_check_widget('widget_preview', clone=True) video = uibuilder.find_widget_recursive(preview, 'video') video.set_size_request(width, height) drawing_area.pack_start(preview, fill=False, expand=False, padding=0) player = VideoDisplay(video, port=13000 + idx) uibuilder.find_widget_recursive(preview, 'label').set_label(source) btn_a = uibuilder.find_widget_recursive(preview, 'btn_a') btn_b = uibuilder.find_widget_recursive(preview, 'btn_b') btn_a.set_name("%c %u" % ('a', idx)) btn_b.set_name("%c %u" % ('b', idx)) if not group_a: group_a = btn_a else: btn_a.join_group(group_a) if not group_b: group_b = btn_b else: btn_b.join_group(group_b) btn_a.connect('toggled', self.btn_toggled) btn_b.connect('toggled', self.btn_toggled) key, mod = Gtk.accelerator_parse('%u' % (idx + 1)) btn_a.add_accelerator('activate', accelerators, key, mod, Gtk.AccelFlags.VISIBLE) key, mod = Gtk.accelerator_parse('<Ctrl>%u' % (idx + 1)) btn_b.add_accelerator('activate', accelerators, key, mod, Gtk.AccelFlags.VISIBLE) btn_fullscreen = uibuilder.find_widget_recursive( preview, 'btn_fullscreen') btn_fullscreen.set_name("%c %u" % ('f', idx)) btn_fullscreen.connect('clicked', self.btn_fullscreen_clicked) self.preview_players[source] = player self.previews[source] = preview self.a_btns[source] = btn_a self.b_btns[source] = btn_b # connect event-handler and request initial state Connection.on('video_status', self.on_video_status) Connection.send('get_video')
def _create_accel_group(self): self._accel_group = Gtk.AccelGroup() shortcut = self._gsettings.get_string(GSETTINGS_KEYBINDINGS) key, mod = Gtk.accelerator_parse(shortcut) self._accel_group.connect(key, mod, Gtk.AccelFlags.VISIBLE, self._open_terminal)