def __init__(self, bus): filename = path.join(path.dirname(__file__), "setup.glade") self.builder = Gtk.Builder() self.builder.set_translation_domain(DOMAINNAME) self.builder.add_from_file(filename) event_handler = EventHandler() self.builder.connect_signals(event_handler) if not self.check_instance(): dummy_service = SetupService() # Try to figure out the config file name: self.config_file = None if _ARGS.config_file: # If the config file is specified on the command line, use that: self.config_file = _ARGS.config_file else: # If the config file is not specified on the command line, # try to get it from the environment. This is necessary # in gnome-shell on Fedora 18 because the setup tool is # called without command line options there but the # environment variable IBUS_ENGINE_NAME is set: try: ibus_engine_name = os.environ['IBUS_ENGINE_NAME'] if ibus_engine_name.startswith('typing-booster:'): self.config_file = ( ibus_engine_name.replace('typing-booster:', '') + '.conf') else: self.__run_message_dialog( _('Unknown format of engine name: ' + 'IBUS_ENGINE_NAME=%(name)s') % {'name': ibus_engine_name}, Gtk.MessageType.WARNING) except: self.__run_message_dialog( _("IBUS_ENGINE_NAME environment variable is not set."), Gtk.MessageType.WARNING) if self.config_file is None: self.__run_message_dialog( _('Cannot determine the config file for this engine. ' + 'Please use the --config-file option.'), Gtk.MessageType.ERROR) sys.exit(1) return self.config_file_full_path = ( '/usr/share/ibus-typing-booster/hunspell-tables/' + self.config_file) if not os.path.isfile(self.config_file_full_path): self.__run_message_dialog( _("Config file %(file)s does not exist.") % {'file': self.config_file_full_path}, Gtk.MessageType.ERROR) sys.exit(1) return self.tabsqlitedb = tabsqlitedb.tabsqlitedb( config_filename=self.config_file_full_path) self.name = self.tabsqlitedb.ime_properties.get('name') self.config_section = "engine/typing-booster/%s" % self.name self.hunspell_dict_package = self.tabsqlitedb.ime_properties.get( 'hunspell_dict_package') self.symbol = self.tabsqlitedb.ime_properties.get('symbol') self.bus = bus self.config = self.bus.get_config() maindialog = self.builder.get_object("main_dialog") maindialog.set_title( _("Preferences for ibus-typing-booster \"%(symbol)s\"") % {'symbol': self.symbol}) # https://tronche.com/gui/x/icccm/sec-4.html#WM_CLASS # gnome-shell seems to use the first argument of set_wmclass() # to find the .desktop file. If the .desktop file can be # found, the name shown by gnome-shell in the top bar comes # from that .desktop file and the icon to show is also read # from that .desktop file. If the .desktop file cannot be # found, the second argument of set_wmclass() is shown by # gnome-shell in the top bar. # # It only works like this when gnome-shell runs under Xorg # though, under Wayland things are different. maindialog.set_wmclass('ibus-setup-typing-booster', 'Typing Booster Preferences') maindialog.show_all() name_version = self.builder.get_object("name_version_label") name_version.set_markup( '<span font_size="large"><b>ibus-typing-booster %s</b></span>' % version.get_version()) self.shortcut_entry = self.builder.get_object("shortcut_entry") self.shortcut_expansion_entry = self.builder.get_object( "shortcut_expansion_entry") shortcut_clear_button = self.builder.get_object( "shortcut_clear_button") shortcut_clear_button.connect('clicked', event_handler.on_shortcut_clear_clicked) shortcut_delete_button = self.builder.get_object( "shortcut_delete_button") shortcut_delete_button.connect( 'clicked', event_handler.on_shortcut_delete_clicked) shortcut_add_button = self.builder.get_object("shortcut_add_button") shortcut_add_button.connect('clicked', event_handler.on_shortcut_add_clicked) self.shortcut_treeview = self.builder.get_object("shortcut_treeview") self.shortcut_treeview_model = Gtk.ListStore(str, str) self.shortcut_treeview.set_model(self.shortcut_treeview_model) current_shortcuts = self.tabsqlitedb.list_user_shortcuts() for i, shortcut in enumerate(current_shortcuts): self.shortcut_treeview_model.append(shortcut) self.shortcut_treeview.append_column( Gtk.TreeViewColumn( # Translators: Column heading of the table listing the existing shortcuts _('Shortcut'), Gtk.CellRendererText(), text=0)) self.shortcut_treeview.append_column( Gtk.TreeViewColumn( # Translators: Column heading of the table listing the existing shortcuts _('Shortcut expansion'), Gtk.CellRendererText(), text=1)) self.shortcut_treeview.get_selection().connect( 'changed', event_handler.on_shortcut_selected) self.install_dictionary_button = self.builder.get_object( "install_dictionary_button") self.install_dictionary_button.connect( 'clicked', event_handler.on_install_dictionary_clicked) self.learn_from_file_button = self.builder.get_object( "learn_from_file_button") self.learn_from_file_button.connect( 'clicked', event_handler.on_learn_from_file_clicked) self.delete_learned_data_button = self.builder.get_object( "delete_learned_data_button") self.delete_learned_data_button.connect( 'clicked', event_handler.on_delete_learned_data_clicked) close_button = self.builder.get_object("close_button") close_button.connect('clicked', event_handler.onCloseClicked) tab_enable_checkbox = self.builder.get_object("tab_enable_checkbox") self.tab_enable = itb_util.variant_to_value( self.config.get_value(self.config_section, 'tabenable')) if self.tab_enable is None: self.tab_enable = False if self.tab_enable is True: tab_enable_checkbox.set_active(True) tab_enable_checkbox.connect('clicked', event_handler.on_tab_enable_checkbox) show_number_of_candidates_checkbox = self.builder.get_object( "show_number_of_candidates_checkbox") self.show_number_of_candidates = itb_util.variant_to_value( self.config.get_value(self.config_section, 'shownumberofcandidates')) if self.show_number_of_candidates is None: self.show_number_of_candidates = False if self.show_number_of_candidates is True: show_number_of_candidates_checkbox.set_active(True) show_number_of_candidates_checkbox.connect( 'clicked', event_handler.on_show_number_of_candidates_checkbox) use_digits_as_select_keys_checkbox = self.builder.get_object( "use_digits_as_select_keys_checkbox") self.use_digits_as_select_keys = itb_util.variant_to_value( self.config.get_value(self.config_section, 'usedigitsasselectkeys')) if self.use_digits_as_select_keys is None: self.use_digits_as_select_keys = True if self.use_digits_as_select_keys is True: use_digits_as_select_keys_checkbox.set_active(True) use_digits_as_select_keys_checkbox.connect( 'clicked', event_handler.on_use_digits_as_select_keys_checkbox) emoji_predictions_checkbox = self.builder.get_object( "emoji_predictions_checkbox") self.emoji_predictions = itb_util.variant_to_value( self.config.get_value(self.config_section, 'emojipredictions')) if self.emoji_predictions is None: self.emoji_predictions = True if self.emoji_predictions is True: emoji_predictions_checkbox.set_active(True) emoji_predictions_checkbox.connect( 'clicked', event_handler.on_emoji_predictions_checkbox) off_the_record_checkbox = self.builder.get_object( "off_the_record_checkbox") self.off_the_record = itb_util.variant_to_value( self.config.get_value(self.config_section, 'offtherecord')) if self.off_the_record is None: self.off_the_record = False if self.off_the_record is True: off_the_record_checkbox.set_active(True) off_the_record_checkbox.connect( 'clicked', event_handler.on_off_the_record_checkbox) qt_im_module_workaround_checkbox = self.builder.get_object( "qt_im_module_workaround_checkbox") self.qt_im_module_workaround = itb_util.variant_to_value( self.config.get_value(self.config_section, 'qtimmoduleworkaround')) if self.qt_im_module_workaround is None: self.qt_im_module_workaround = False if self.qt_im_module_workaround is True: qt_im_module_workaround_checkbox.set_active(True) qt_im_module_workaround_checkbox.connect( 'clicked', event_handler.on_qt_im_module_workaround_checkbox) arrow_keys_reopen_preedit_checkbox = self.builder.get_object( "arrow_keys_reopen_preedit_checkbox") self.arrow_keys_reopen_preedit = itb_util.variant_to_value( self.config.get_value(self.config_section, 'arrowkeysreopenpreedit')) if self.arrow_keys_reopen_preedit is None: self.arrow_keys_reopen_preedit = False if self.arrow_keys_reopen_preedit is True: arrow_keys_reopen_preedit_checkbox.set_active(True) arrow_keys_reopen_preedit_checkbox.connect( 'clicked', event_handler.on_arrow_keys_reopen_preedit_checkbox) show_status_info_in_auxiliary_text_checkbox = self.builder.get_object( "show_status_info_in_auxiliary_text_checkbox") self.show_status_info_in_auxiliary_text = itb_util.variant_to_value( self.config.get_value(self.config_section, 'showstatusinfoinaux')) if self.show_status_info_in_auxiliary_text is None: self.show_status_info_in_auxiliary_text = True if self.show_status_info_in_auxiliary_text is True: show_status_info_in_auxiliary_text_checkbox.set_active(True) show_status_info_in_auxiliary_text_checkbox.connect( 'clicked', event_handler.on_show_status_info_in_auxiliary_text_checkbox) add_direct_input_checkbox = self.builder.get_object( "add_direct_input_checkbox") self.add_direct_input = itb_util.variant_to_value( self.config.get_value(self.config_section, 'adddirectinput')) if self.add_direct_input is None: self.add_direct_input = False if self.add_direct_input is True: add_direct_input_checkbox.set_active(True) add_direct_input_checkbox.connect( 'clicked', event_handler.on_add_direct_input_checkbox) remember_last_used_preedit_ime_checkbox = self.builder.get_object( "remember_last_used_preedit_ime_checkbox") self.remember_last_used_predit_ime = itb_util.variant_to_value( self.config.get_value(self.config_section, 'rememberlastusedpreeditime')) if self.remember_last_used_predit_ime is None: self.remember_last_used_predit_ime = False if self.remember_last_used_predit_ime is True: remember_last_used_preedit_ime_checkbox.set_active(True) remember_last_used_preedit_ime_checkbox.connect( 'clicked', event_handler.on_remember_last_used_preedit_ime_checkbox) auto_commit_characters_entry = self.builder.get_object( "auto_commit_characters_entry") self.auto_commit_characters = itb_util.variant_to_value( self.config.get_value(self.config_section, 'autocommitcharacters')) if not self.auto_commit_characters: self.auto_commit_characters = '' auto_commit_characters_entry.set_text(self.auto_commit_characters) auto_commit_characters_entry.connect( 'notify::text', event_handler.on_auto_commit_characters_entry) self.page_size_adjustment = self.builder.get_object( "page_size_adjustment") self.page_size = itb_util.variant_to_value( self.config.get_value(self.config_section, 'pagesize')) if self.page_size: self.page_size_adjustment.set_value(int(self.page_size)) else: self.page_size_adjustment.set_value(6) self.page_size_adjustment.connect( 'value-changed', event_handler.on_page_size_adjustment_value_changed) self.min_char_complete_adjustment = self.builder.get_object( "min_char_complete_adjustment") self.min_char_complete = itb_util.variant_to_value( self.config.get_value(self.config_section, 'mincharcomplete')) if self.min_char_complete: self.min_char_complete_adjustment.set_value( int(self.min_char_complete)) else: self.min_char_complete_adjustment.set_value(1) self.min_char_complete_adjustment.connect( 'value-changed', event_handler.on_min_char_complete_adjustment_value_changed) self.lookup_table_orientation_combobox = self.builder.get_object( "lookup_table_orientation_combobox") lookup_table_orientation_store = Gtk.ListStore(str, int) lookup_table_orientation_store.append( [_('Horizontal'), IBus.Orientation.HORIZONTAL]) lookup_table_orientation_store.append( [_('Vertical'), IBus.Orientation.VERTICAL]) lookup_table_orientation_store.append( [_('System default'), IBus.Orientation.SYSTEM]) self.lookup_table_orientation_combobox.set_model( lookup_table_orientation_store) renderer_text = Gtk.CellRendererText() self.lookup_table_orientation_combobox.pack_start(renderer_text, True) self.lookup_table_orientation_combobox.add_attribute( renderer_text, "text", 0) lookup_table_orientation = itb_util.variant_to_value( self.config.get_value(self.config_section, 'lookuptableorientation')) if lookup_table_orientation is None: lookup_table_orientation = IBus.Orientation.VERTICAL for i, item in enumerate(lookup_table_orientation_store): if lookup_table_orientation == item[1]: self.lookup_table_orientation_combobox.set_active(i) self.lookup_table_orientation_combobox.connect( "changed", event_handler.on_lookup_table_orientation_combobox_changed) self.ime_combobox = self.builder.get_object("input_method_combobox") self.input_method_help_button = self.builder.get_object( "input_method_help_button") ime_store = Gtk.ListStore(str, str) self.supported_imes = [] imes = self.tabsqlitedb.ime_properties.get('imes').split(',') if not imes: imes = ['Native Keyboard:NoIme'] for item in imes: ime_store.append([item.split(':')[0], item.split(':')[1]]) self.supported_imes.append(item.split(':')[1]) self.ime_combobox.set_model(ime_store) self.ime_combobox.pack_start(renderer_text, True) self.ime_combobox.add_attribute(renderer_text, "text", 0) self.current_imes = [] inputmethod = itb_util.variant_to_value( self.config.get_value(self.config_section, 'inputmethod')) if inputmethod: inputmethods = [x.strip() for x in inputmethod.split(',')] for ime in inputmethods: self.current_imes.append(ime) if self.current_imes == []: # There is no ime set in dconf, use the first value from # the combobox as the default: self.current_imes = [ime_store[0][1]] if self.add_direct_input and 'NoIme' not in self.current_imes: self.current_imes.append('NoIme') if len(self.current_imes) == 1: self.main_ime = self.current_imes[0] else: self.main_ime = ([ x for x in self.current_imes if x in self.supported_imes ][0]) combobox_has_ime = False for i, dummy_item in enumerate(ime_store): if ime_store[i][1] == self.main_ime: self.ime_combobox.set_active(i) combobox_has_ime = True if combobox_has_ime is False: # the combobox did not have the ime from the settings # take the ime from the first row of # the combobox as the fallback: self.main_ime = ime_store[0][1] self.ime_combobox.set_active(0) self.ime_combobox.connect("changed", event_handler.on_ime_combobox_changed) if len(ime_store) < 2: self.ime_combobox.set_sensitive(False) self.input_method_help_button.connect( 'clicked', event_handler.on_input_method_help_button_clicked) if self.main_ime == 'NoIme': self.input_method_help_button.set_sensitive(False)
def __init__(self, exaile): """ Initializes the GUI @param exaile: The Exaile instance """ from xlgui import icons, main, panels, tray, progress Gdk.set_program_class("Exaile") # For GNOME Shell # https://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Clients/ApplicationProperties/ GLib.set_application_name("Exaile") os.environ['PULSE_PROP_media.role'] = 'music' self.exaile = exaile self.first_removed = False self.tray_icon = None self.builder = Gtk.Builder() self.builder.add_from_file(xdg.get_data_path('ui', 'main.ui')) self.progress_box = self.builder.get_object('progress_box') self.progress_manager = progress.ProgressManager(self.progress_box) add_icon = icons.MANAGER.add_icon_name_from_directory images_dir = xdg.get_data_path('images') exaile_icon_path = add_icon('exaile', images_dir) Gtk.Window.set_default_icon_name('exaile') if xdg.local_hack: # PulseAudio also attaches the above name to streams. However, if # Exaile is not installed, any app trying to display the icon won't # be able to find it just by name. The following is a hack to tell # PA the icon file path instead of the name; this only works on # some clients, e.g. pavucontrol. os.environ['PULSE_PROP_application.icon_name'] = exaile_icon_path for name in ( 'exaile-pause', 'exaile-play', 'office-calendar', 'extension', 'music-library', 'artist', 'genre', ): add_icon(name, images_dir) for name in ('dynamic', 'repeat', 'shuffle'): add_icon('media-playlist-' + name, images_dir) logger.info("Loading main window...") self.main = main.MainWindow(self, self.builder, exaile.collection) if self.exaile.options.StartMinimized: self.main.window.iconify() self.play_toolbar = self.builder.get_object('play_toolbar') panel_notebook = self.builder.get_object('panel_notebook') self.panel_notebook = panels.PanelNotebook(exaile, self) self.device_panels = {} # add the device panels for device in self.exaile.devices.list_devices(): if device.connected: self.add_device_panel(None, None, device) logger.info("Connecting panel events...") self.main._connect_panel_events() guiutil.gtk_widget_replace(panel_notebook, self.panel_notebook) self.panel_notebook.get_parent().child_set_property( self.panel_notebook, 'shrink', False ) if settings.get_option('gui/use_tray', False): if tray.is_supported(): self.tray_icon = tray.TrayIcon(self.main) else: settings.set_option('gui/use_tray', False) logger.warn( "Tray icons are not supported on your platform. Disabling tray icon." ) from xl import event event.add_ui_callback(self.add_device_panel, 'device_connected') event.add_ui_callback(self.remove_device_panel, 'device_disconnected') event.add_ui_callback(self.on_gui_loaded, 'gui_loaded') logger.info("Done loading main window...") Main._main = self if sys.platform == 'darwin': self._setup_osx()
class Handler: def __init__(self, label, button): self.clock = Clock(label, button) self.clock.start() def onDestroy(self, *args): self.clock.quit() Gtk.main_quit() def onButtonToggled(self, button): if self.clock.stopped: self.clock.restart() else: self.clock.stop() builder = Gtk.Builder() builder.add_from_file("clock.glade") window = builder.get_object("window") label = builder.get_object("label") button = builder.get_object("stop") handler = Handler(label, button) builder.connect_signals(handler) window.show_all() Gtk.main()
def __init__(self): import gui.application app = gui.application.get_app() assert app is not None super(PreferencesWindow, self).__init__( app=app, title=_('Preferences'), transient_for=app.drawWindow, destroy_with_parent=True, ) self.add_buttons( Gtk.STOCK_REVERT_TO_SAVED, RESPONSE_REVERT, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT, ) self.connect('response', self.on_response) self.in_update_ui = False # Set up widgets builder = Gtk.Builder() builder.set_translation_domain("mypaint") ui_dir = os.path.dirname(os.path.abspath(__file__)) xml_path = os.path.join(ui_dir, 'preferenceswindow.glade') builder.add_from_file(xml_path) self._builder = builder getobj = builder.get_object # Notebook nb = getobj("prefs_notebook") self.nb = nb self.vbox.pack_start(nb, True, True, 0) # Curve init curve = getobj("mapping_curve") curve.changed_cb = self.pressure_curve_changed_cb curve.magnetic = False self._pressure_curve = curve # Button mappings editor assert "input.button_mapping" in app.preferences reg = gui.mode.ModeRegistry actions_possible = [ n for n in reg.get_action_names() if issubclass(reg.get_mode_class(n), gui.mode.DragMode) ] actions_possible += gui.mode.BUTTON_BINDING_ACTIONS bm_ed = getobj("button_mapping_editor") bm_ed.set_bindings(app.preferences["input.button_mapping"]) bm_ed.set_actions(actions_possible) bm_ed.bindings_observers.append(self.button_mapping_edited_cb) # Autosave controls autosave_interval_spinbut = getobj("autosave_interval_spinbutton") self._autosave_interval_spinbutton = autosave_interval_spinbut # Signal hookup now everything is in the right initial state self._builder.connect_signals(self)
def _setup_headerbar(self): # define the main buttons for the headerbar builder = Gtk.Builder() ui = rb.find_plugin_file(self.plugin, 'ui/altlibrary.ui') builder.add_from_file(ui) self.load_builder_content(builder) view_name = "Categories" self.library_browser_radiobutton.set_label(view_name) default = Gtk.Settings.get_default() self.headerbar = Gtk.HeaderBar.new() self.headerbar.set_show_close_button(True) self.main_window.set_titlebar( self.headerbar ) # this is needed for gnome-shell to replace the decoration self.main_window.set_show_menubar(False) self.plugin.rb_toolbar.hide() self.start_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0) # left side box self.headerbar.pack_start(self.start_box) self.headerbar.set_custom_title(self.library_box) self._end_box_controls = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0) # right side box self.end_box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0) # any source defined controls self._end_box_controls.add(self.end_box) if (not default.props.gtk_shell_shows_app_menu ) or default.props.gtk_shell_shows_menubar: # for environments that dont support app-menus menu_button = Gtk.MenuButton.new() # menu_button.set_relief(Gtk.ReliefStyle.NONE) if gtk_version() >= 3.14: symbol = "open-menu-symbolic" menu_button.set_margin_start(3) else: symbol = "emblem-system-symbolic" menu_button.set_margin_left(3) image = Gtk.Image.new_from_icon_name(symbol, Gtk.IconSize.SMALL_TOOLBAR) menu_button.add(image) menu = self.shell.props.application.get_shared_menu('app-menu') menu_button.set_menu_model(menu) self._end_box_controls.add(menu_button) self.headerbar.pack_end(self._end_box_controls) self.headerbar.show_all() action = self.plugin.toggle_action_group.get_action('ToggleToolbar') if not self.plugin.start_hidden: action.set_active(True) print("not hidden") else: action.set_active(False) self.set_visible(False)
def add_from_file(self, fn): builder = Gtk.Builder() if self.domain is not None: builder.set_translation_domain(self.domain) self.builders.append(builder) builder.add_from_file(fn)
def __init__(self, state, uistate, track, categories, msg, label=None, button_label=None, tool_tip=None, content=_REPORTS): """ Display the dialog box, and build up the list of available reports. This is used to build the selection tree on the left hand side of the dialog box. """ self.active = uistate.get_active('Person') self.imap = {} self.msg = msg self.content = content self._pmgr = GuiPluginManager.get_instance() ManagedWindow.__init__(self, uistate, track, self.__class__) self.state = state self.uistate = uistate self.dialog = Gtk.Builder() self.dialog.add_from_file(PLUGINS_GLADE) self.dialog.connect_signals({ "on_report_apply_clicked": self.on_apply_clicked, "destroy_passed_object": self.close, "on_delete_event": self.close, }) self.tree = self.dialog.get_object("tree") window = self.dialog.get_object("report") self.title = self.dialog.get_object("title") self.set_window(window, self.title, msg) self.store = Gtk.TreeStore(str) self.selection = self.tree.get_selection() self.selection.connect('changed', self.on_node_selected) col = Gtk.TreeViewColumn('', Gtk.CellRendererText(), text=0) self.tree.append_column(col) self.tree.set_model(self.store) self.description = self.dialog.get_object("description") if label: self.description.set_text(label) self.status = self.dialog.get_object("report_status") self.author_name = self.dialog.get_object("author_name") self.author_email = self.dialog.get_object("author_email") self.apply_button = self.dialog.get_object("apply") if button_label: self.apply_button.set_label(button_label) else: self.apply_button.set_label(_("_Apply")) self.apply_button.set_use_underline(True) if tool_tip: self.apply_button.set_tooltip_text(tool_tip) self.item = None if content == _REPORTS: reg_list = self._pmgr.get_reg_reports() elif content == _TOOLS: reg_list = self._pmgr.get_reg_tools() else: reg_list = [] self.build_plugin_tree(reg_list, categories) self.show()
def __init__(self): if Wnck: self.screen = Wnck.Screen.get_default() component.Component.__init__(self, 'MainWindow', interval=2) self.config = ConfigManager('gtk3ui.conf') self.main_builder = Gtk.Builder() # Patch this GtkBuilder to avoid connecting signals from elsewhere # # Think about splitting up mainwindow gtkbuilder file into the necessary parts # to avoid GtkBuilder monkey patch. Those parts would then need adding to mainwindow 'by hand'. self.gtk_builder_signals_holder = _GtkBuilderSignalsHolder() # FIXME: The deepcopy has been removed: copy.deepcopy(self.main_builder.connect_signals) self.main_builder.prev_connect_signals = self.main_builder.connect_signals def patched_connect_signals(*a, **k): raise RuntimeError( 'In order to connect signals to this GtkBuilder instance please use ' '"component.get(\'MainWindow\').connect_signals()"') self.main_builder.connect_signals = patched_connect_signals # Get Gtk Builder files Main Window, New release dialog, and Tabs. ui_filenames = [ 'main_window.ui', 'main_window.new_release.ui', 'main_window.tabs.ui', 'main_window.tabs.menu_file.ui', 'main_window.tabs.menu_peer.ui', ] for filename in ui_filenames: self.main_builder.add_from_file( resource_filename(__package__, os.path.join('glade', filename))) self.window = self.main_builder.get_object('main_window') self.window.set_icon(get_deluge_icon()) self.tabsbar_pane = self.main_builder.get_object('tabsbar_pane') self.sidebar_pane = self.main_builder.get_object('sidebar_pane') # Keep a list of components to pause and resume when changing window state. self.child_components = ['TorrentView', 'StatusBar', 'TorrentDetails'] # Load the window state self.load_window_state() # Keep track of window minimization state so we don't update UI when it is minimized. self.is_minimized = False self.restart = False self.window.drag_dest_set( Gtk.DestDefaults.ALL, [Gtk.TargetEntry.new(target='text/uri-list', flags=0, info=80)], DragAction.COPY, ) # Connect events self.window.connect('window-state-event', self.on_window_state_event) self.window.connect('configure-event', self.on_window_configure_event) self.window.connect('delete-event', self.on_window_delete_event) self.window.connect('drag-data-received', self.on_drag_data_received_event) self.tabsbar_pane.connect('notify::position', self.on_tabsbar_pane_position_event) self.sidebar_pane.connect('notify::position', self.on_sidebar_pane_position_event) self.window.connect('draw', self.on_expose_event) self.config.register_set_function('show_rate_in_title', self._on_set_show_rate_in_title, apply_now=False) client.register_event_handler('NewVersionAvailableEvent', self.on_newversionavailable_event)
def __init__(self, base_codename, ppa_owner, ppa_name): if platform.machine() == "x86_64": architecture = "amd64" else: architecture = "i386" ppa_origin = "LP-PPA-%s-%s" % (ppa_owner, ppa_name) ppa_origin_simple = "LP-PPA-%s" % (ppa_owner) ppa_file = "/var/lib/apt/lists/ppa.launchpad.net_%s_%s_ubuntu_dists_%s_main_binary-%s_Packages" % (ppa_owner, ppa_name, base_codename, architecture) if not os.path.exists(ppa_file): print ("%s not found!" % ppa_file) sys.exit(1) self.packages_to_install = [] self.packages_installed_from_ppa = [] glade_file = "/usr/lib/linuxmint/mintSources/mintsources.glade" self.builder = Gtk.Builder() self.builder.set_translation_domain("mintsources") self.builder.add_from_file(glade_file) self.window = self.builder.get_object("ppa_window") self.window.set_title(_("PPA")) self.window.set_icon_name("software-sources") self.window.connect("destroy", Gtk.main_quit) self.builder.get_object("button_cancel").connect("clicked", Gtk.main_quit) self.install_button = self.builder.get_object("button_install") self.install_button.connect("clicked", self.install) self.install_button.set_sensitive(False) self.builder.get_object("label_ppa_name").set_markup("%s/%s" % (ppa_owner, ppa_name)) self.model = Gtk.ListStore(object, bool, str) treeview = self.builder.get_object("treeview_ppa_pkgs") treeview.set_model(self.model) self.model.set_sort_column_id(2, Gtk.SortType.ASCENDING) r = Gtk.CellRendererToggle() r.connect("toggled", self.toggled) col = Gtk.TreeViewColumn("", r) col.set_cell_data_func(r, self.datafunction_checkbox) treeview.append_column(col) col.set_sort_column_id(1) r = Gtk.CellRendererText() col = Gtk.TreeViewColumn("", r, markup = 2) treeview.append_column(col) col.set_sort_column_id(2) cache = apt.Cache() self.apt = mintcommon.aptdaemon.APT(self.window) packages = subprocess.getoutput("grep 'Package:' %s | sort | awk {'print $2;'}" % ppa_file).split("\n") for package in packages: if package in cache: pkg = cache[package] candidate = pkg.candidate if candidate is not None and candidate.downloadable: for origin in candidate.origins: if origin.origin == ppa_origin or origin.origin == ppa_origin_simple: if pkg.is_installed: if pkg.installed.version != candidate.version: already_installed_str = _("version %s already installed") % pkg.installed.version self.model.append((pkg, False, "<b>%s</b>\n%s (%s)" % (pkg.name, candidate.version, already_installed_str))) else: already_installed_str = _("already installed") self.model.append((pkg, False, "<b>%s</b>\n%s (%s)" % (pkg.name, candidate.version, already_installed_str))) self.packages_installed_from_ppa.append(pkg.name) else: self.model.append((pkg, False, "<b>%s</b>\n%s" % (pkg.name, candidate.version))) break treeview.show() self.window.show_all()
DISPLAY = os.environ["DISPLAY"] DisplayServer = os.getenv('XDG_SESSION_TYPE', 'xorg') print("You are recording on: " + str(DisplayServer)) if "wayland" in DisplayServer: DisplayServer = "gnomewayland" global GNOMEScreencast GNOMEScreencast = bus.get('org.gnome.Shell.Screencast', '/org/gnome/Shell/Screencast') else: DisplayServer = "xorg" # Import the glade file and its widgets. builder = Gtk.Builder() # type: Gtk.Builder install_prefix = prefix() possible_ui_file_locations = [] app_indicator_icon = '' if os.getenv('VIRTUAL_ENV'): possible_ui_file_locations.append( os.path.join(os.path.dirname(os.getenv('VIRTUAL_ENV')), "ui", "ui.glade")) app_indicator_icon = os.path.join( os.path.dirname(os.getenv('VIRTUAL_ENV')), "data", "green-recorder.png") elif install_prefix: possible_ui_file_locations.append(install_prefix + "/share/green-recorder/ui.glade") app_indicator_icon = install_prefix + "/share/pixmaps/green-recorder.png"
def __init__(self): # state self.step = 0 #Load GUI from glade file self.builder = Gtk.Builder() self.builder.add_from_file("client_gui.glade") # update constants in builder update_range([ self.builder.get_object("lift_adjustment"), self.builder.get_object("lift_meas_adjustment") ], miro.constants.LIFT_RAD_MIN, miro.constants.LIFT_RAD_MAX) update_range([ self.builder.get_object("yaw_adjustment"), self.builder.get_object("yaw_meas_adjustment") ], miro.constants.YAW_RAD_MIN, miro.constants.YAW_RAD_MAX) update_range([ self.builder.get_object("pitch_adjustment"), self.builder.get_object("pitch_meas_adjustment") ], miro.constants.PITCH_RAD_MIN, miro.constants.PITCH_RAD_MAX) #Connect signals to handle callbacks from event self.builder.connect_signals(self) #Get Windows from GUI self.MainWindow = self.builder.get_object("MainWindow") self.CamWindow = self.builder.get_object("CamWindow") self.MicWindow = self.builder.get_object("MicWindow") self.MicScrolledWindow = self.builder.get_object("MicScrolledWindow") #Get Cam and Mic Buttons from GUI self.DisplayCamButton = self.builder.get_object("DisplayCamButton") self.DisplayMicButton = self.builder.get_object("DisplayMicButton") #Get Battery objects from GUI self.BatteryText = self.builder.get_object("BatteryText") self.BatteryBar = self.builder.get_object("BatteryBar") self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_LOW, 4.6) self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_HIGH, 4.8) #self.BatteryBar.add_offset_value(Gtk.LEVEL_BAR_OFFSET_FULL, 5.0) #Get Sonar objects from GUI self.SonarText = self.builder.get_object("SonarText") self.SonarBar = self.builder.get_object("SonarBar") #Get Light objects from GUI self.gui_LightBarFL = self.builder.get_object("LightBarFL") self.gui_LightBarFR = self.builder.get_object("LightBarFR") self.gui_LightBarRL = self.builder.get_object("LightBarRL") self.gui_LightBarRR = self.builder.get_object("LightBarRR") #Get Touch objects from GUI self.BodyTouchText = self.builder.get_object("BodyTouchText") self.HeadTouchText = self.builder.get_object("HeadTouchText") self.BodyTouchBars = [] self.HeadTouchBars = [] for i in range(14): temp = self.builder.get_object("BT" + str(i)) self.BodyTouchBars.append(temp) temp = self.builder.get_object("HT" + str(i)) self.HeadTouchBars.append(temp) #Get Accelerometer objects from GUI self.gui_AccBarBX = self.builder.get_object("AccBarBX") self.gui_AccBarBY = self.builder.get_object("AccBarBY") self.gui_AccBarBZ = self.builder.get_object("AccBarBZ") self.gui_AccBarBL2 = self.builder.get_object("AccBarBL2") self.gui_AccBarHX = self.builder.get_object("AccBarHX") self.gui_AccBarHY = self.builder.get_object("AccBarHY") self.gui_AccBarHZ = self.builder.get_object("AccBarHZ") self.gui_AccBarHL2 = self.builder.get_object("AccBarHL2") #Get Cliff objects from GUI self.gui_CliffBarL = self.builder.get_object("CliffBarL") self.gui_CliffBarR = self.builder.get_object("CliffBarR") #Get Wheel Speed objects from GUI self.gui_WheelSpeedOptoL = self.builder.get_object("WheelSpeedOptoL") self.gui_WheelSpeedOptoR = self.builder.get_object("WheelSpeedOptoR") self.gui_WheelSpeedEMFL = self.builder.get_object("WheelSpeedEMFL") self.gui_WheelSpeedEMFR = self.builder.get_object("WheelSpeedEMFR") self.VelControl = self.builder.get_object("VelControl") self.AngVelControl = self.builder.get_object("AngVelControl") self.UserControlVel = self.builder.get_object("UserControlVelocity") self.YawControl = self.builder.get_object("YawControl") self.LiftControl = self.builder.get_object("LiftControl") self.PitchControl = self.builder.get_object("PitchControl") self.ResetKinButton = self.builder.get_object("ResetKinButton") self.UserControlKin = self.builder.get_object("UserControlKin") self.LeftEyeControl = self.builder.get_object("LeftEyeControl") self.RightEyeControl = self.builder.get_object("RightEyeControl") self.BlinkButton = self.builder.get_object("BlinkButton") self.WiggleButton = self.builder.get_object("WiggleButton") self.LeftEarControl = self.builder.get_object("LeftEarControl") self.RightEarControl = self.builder.get_object("RightEarControl") self.WagControl = self.builder.get_object("WagControl") self.DroopControl = self.builder.get_object("DroopControl") self.WagRateControl = self.builder.get_object("WagRateControl") self.CosResetButton = self.builder.get_object("CosResetButton") self.UserControlCos = self.builder.get_object("UserControlCos") self.VelMeasured = self.builder.get_object("VelMeasured") self.AngVelMeasured = self.builder.get_object("AngVelMeasured") self.LiftMeasured = self.builder.get_object("LiftMeasured") self.YawMeasured = self.builder.get_object("YawMeasured") self.PitchMeasured = self.builder.get_object("PitchMeasured") self.FreqControl = self.builder.get_object("FreqControl") self.VolControl = self.builder.get_object("VolControl") self.DurationControl = self.builder.get_object("DurationControl") self.Tone1Button = self.builder.get_object("Tone1Button") self.Tone2Button = self.builder.get_object("Tone2Button") self.Tone3Button = self.builder.get_object("Tone3Button") self.Tone4Button = self.builder.get_object("Tone4Button") self.SendToneButton = self.builder.get_object("SendToneButton") self.UserControlIllum = self.builder.get_object("UserControlIllum") self.gui_LEDBrightF = self.builder.get_object("LEDBrightF") self.gui_LEDBrightM = self.builder.get_object("LEDBrightM") self.gui_LEDBrightR = self.builder.get_object("LEDBrightR") self.gui_LEDColourF = self.builder.get_object("LEDColourF") self.gui_LEDColourM = self.builder.get_object("LEDColourM") self.gui_LEDColourR = self.builder.get_object("LEDColourR") self.gui_Camera = [ self.builder.get_object("CameraLeft"), self.builder.get_object("CameraRight") ] self.gui_ResolutionSelection = self.builder.get_object( "ResolutionSelection") self.gui_CapResolutionSelection = self.builder.get_object( "CapResolutionSelection") self.gui_CapFPSSelection = self.builder.get_object("CapFPSSelection") self.gui_MeasuredFPS = self.builder.get_object("MeasuredFPS") #Generate variables to store user input self.preset = False self.user_blink = 0 self.user_waggle = 0 self.user_wiggle = 0 self.user_wag_rate = 0 self.wag_phase = 0 #Microphone Parameters # Number of points to display self.x_len = 40000 # number of microphones coming through on topic self.no_of_mics = 4 #Generate figure for plotting mics self.fig1 = plt.figure() self.fig1.suptitle("Microphones") # Give figure title #LEFT EAR self.left_ear_plot = self.fig1.add_subplot(4, 1, 1) self.left_ear_plot.set_ylim([-33000, 33000]) self.left_ear_plot.set_xlim([0, self.x_len]) self.left_ear_xs = np.arange(0, self.x_len) self.left_ear_plot.set_xticklabels([]) self.left_ear_plot.set_yticks([]) self.left_ear_plot.grid(which="both", axis="x") self.left_ear_plot.set_ylabel("Left Ear", rotation=0, ha="right") self.left_ear_ys = np.zeros(self.x_len) self.left_ear_line, = self.left_ear_plot.plot(self.left_ear_xs, self.left_ear_ys, linewidth=0.5, color="b") #RIGHT EAR self.right_ear_plot = self.fig1.add_subplot(4, 1, 2) self.right_ear_plot.set_ylim([-33000, 33000]) self.right_ear_plot.set_xlim([0, self.x_len]) self.right_ear_xs = np.arange(0, self.x_len) self.right_ear_plot.set_xticklabels([]) self.right_ear_plot.set_yticks([]) self.right_ear_plot.grid(which="both", axis="x") self.right_ear_plot.set_ylabel("Right Ear", rotation=0, ha="right") self.right_ear_ys = np.zeros(self.x_len) self.right_ear_line, = self.right_ear_plot.plot(self.right_ear_xs, self.right_ear_ys, linewidth=0.5, color="r") #HEAD self.head_plot = self.fig1.add_subplot(4, 1, 3) self.head_plot.set_ylim([-33000, 33000]) self.head_plot.set_xlim([0, self.x_len]) self.head_xs = np.arange(0, self.x_len) self.head_plot.set_xticklabels([]) self.head_plot.set_yticks([]) self.head_plot.grid(which="both", axis="x") self.head_plot.set_ylabel("Head", rotation=0, ha="right") self.head_ys = np.zeros(self.x_len) self.head_line, = self.head_plot.plot(self.head_xs, self.head_ys, linewidth=0.5, color="g") #Tail self.tail_plot = self.fig1.add_subplot(4, 1, 4) self.tail_plot.set_ylim([-33000, 33000]) self.tail_plot.set_xlim([0, self.x_len]) self.tail_xs = np.arange(0, self.x_len) self.tail_plot.set_yticks([]) self.tail_plot.set_xlabel("Samples") self.tail_plot.grid(which="both", axis="x") self.tail_plot.set_ylabel("Tail", rotation=0, ha="right") self.tail_ys = np.zeros(self.x_len) self.tail_line, = self.tail_plot.plot(self.tail_xs, self.tail_ys, linewidth=0.5, color="c") self.canvas = FigureCanvas(self.fig1) self.ani = animation.FuncAnimation(self.fig1, self.update_line, fargs=( self.left_ear_ys, self.right_ear_ys, self.head_ys, self.tail_ys, ), init_func=self.animation_init, interval=10, blit=False) self.fig1.subplots_adjust(hspace=0, wspace=0) self.MicScrolledWindow.add_with_viewport(self.canvas) # variables to store input data self.input_package = None self.input_camera = [None, None] self.t_input_camera = [[], []] self.input_mics = np.zeros((self.x_len, self.no_of_mics)) #Create object to convert ROS images to OpenCV format self.image_converter = CvBridge() #Start timer to call function which updates GUI GObject.timeout_add(20, self.update_gui) GObject.timeout_add(20, self.update_images) #Create objects to hold published data self.velocity = TwistStamped() self.kin_joints = JointState() self.kin_joints.name = ["tilt", "lift", "yaw", "pitch"] self.kin_joints.position = [0.0, math.radians(34.0), 0.0, 0.0] self.cos_joints = Float32MultiArray() self.cos_joints.data = [0.0, 0.5, 0.0, 0.0, 0.0, 0.0] self.tone = UInt16MultiArray() self.tone.data = [0, 0, 0] self.illum = UInt32MultiArray() self.illum.data = [ 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF ] # self.camera_zoom = None self.auto_camera_zoom = [0, 0] # determine zoom from first received frame self.frame_params = [180, '180w', 15] self.meas_fps = ["", ""] # set initial values self.on_ResetCosButton_clicked() self.on_LEDReset_clicked() # display GUI self.MainWindow.show_all() # robot name topic_base = "/" + os.getenv("MIRO_ROBOT_NAME") + "/" # publishers self.pub_cmd_vel = rospy.Publisher(topic_base + "control/cmd_vel", TwistStamped, queue_size=0) self.pub_cos = rospy.Publisher(topic_base + "control/cosmetic_joints", Float32MultiArray, queue_size=0) self.pub_illum = rospy.Publisher(topic_base + "control/illum", UInt32MultiArray, queue_size=0) self.pub_kin = rospy.Publisher(topic_base + "control/kinematic_joints", JointState, queue_size=0) self.pub_tone = rospy.Publisher(topic_base + "control/tone", UInt16MultiArray, queue_size=0) self.pub_command = rospy.Publisher(topic_base + "control/command", String, queue_size=0) # subscribers self.sub_package = rospy.Subscriber(topic_base + "sensors/package", miro.msg.sensors_package, self.callback_package) self.sub_mics = rospy.Subscriber(topic_base + "sensors/mics", Int16MultiArray, self.callback_mics) self.sub_caml = rospy.Subscriber( topic_base + "sensors/caml/compressed", CompressedImage, self.callback_caml) self.sub_camr = rospy.Subscriber( topic_base + "sensors/camr/compressed", CompressedImage, self.callback_camr)
def __init__(self): self.client_tcp=None self.operator="INV" self.operandes="MATRICE" self.matrix_list={} self.builder=Gtk.Builder() self.builder.add_from_file("./glade/LAC_Applicationwindow.glade") self.window=self.builder.get_object("window") self.spinner=self.builder.get_object('spinner') self.ajouter_resultat_button=self.builder.get_object('ajouter_resultat_button') self.sendsms_button=self.builder.get_object('sendsms_button') self.delete_matrix_button=self.builder.get_object('delete_matrix_button') self.edit_matrix_button=self.builder.get_object('edit_matrix_button') self.premiere_op_box=self.builder.get_object("premiere_op_box") self.deuxieme_op_box=self.builder.get_object("deuxieme_op_box") self.operation_label=self.builder.get_object("operation_label") self.premiere_op_label=self.builder.get_object("premiere_op_label") self.comboboxtext1=self.builder.get_object("comboboxtext1") self.famille_box1=self.builder.get_object("famille_box1") self.deuxieme_op_label=self.builder.get_object("deuxieme_op_label") self.comboboxtext2=self.builder.get_object("comboboxtext2") self.famille_box2=self.builder.get_object("famille_box2") self.spinbutton=self.builder.get_object("spinbutton") self.treeview=self.builder.get_object("treeview") self.combobox=self.builder.get_object("combobox") self.resultat_matrix_box=self.builder.get_object("resultat_matrix_box") self.liststore=Gtk.ListStore(str,int,int) self.treeview.set_model(self.liststore) renderer=Gtk.CellRendererText() column=Gtk.TreeViewColumn("Nom",renderer,text=0) self.treeview.append_column(column) column=Gtk.TreeViewColumn("Nbr Ligne",renderer,text=1) self.treeview.append_column(column) column=Gtk.TreeViewColumn("Nbr Col",renderer,text=2) self.treeview.append_column(column) self.window.show_all() self.error_label=self.builder.get_object("error_label") self.resultat_label1=self.builder.get_object("resultat_label1") self.resultat_label2=self.builder.get_object("resultat_label2") self.textbuffer1=self.builder.get_object("textbuffer1") self.textbuffer2=self.builder.get_object("textbuffer2") self.ajouter_resultat_button.hide() self.deuxieme_op_box.set_visible(False) self.premiere_op_label.set_text("Choisir une matrice") self.famille_box1.set_visible(False) self.error_label.hide() self.resultat_label2.hide() self.resultat_label1.hide() self.combobox1_type="MATRICE" self.combobox2_type="" self.builder.connect_signals(Handler(self))
def __init__(self, album_id, genre_ids, artist_ids, popover, size_group): """ Init detailed album widget @param album id as int @param genre ids as [int] @param artist ids as [int] @param popover as bool @param size group as Gtk.SizeGroup """ Gtk.Bin.__init__(self) AlbumWidget.__init__(self, album_id, genre_ids) self._artist_ids = artist_ids self._pop_allowed = not popover or Gtk.get_minor_version() > 16 builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Lollypop/%s.ui' % type(self).__name__) self._color = builder.get_object('color') rating = RatingWidget(self._album) rating.show() builder.get_object('coverbox').add(rating) builder.connect_signals(self) self._artist_label = builder.get_object('artist') if len(artist_ids) > 1: self._artist_label.set_text(self._album.artist_name) self._artist_label.show() label = builder.get_object('duration') duration = Lp().albums.get_duration(album_id, genre_ids) hours = int(duration / 3600) mins = int(duration / 60) if hours > 0: mins -= hours * 60 if mins > 0: label.set_text(_("%s h %s m") % (hours, mins)) else: label.set_text(_("%s h") % hours) else: label.set_text(_("%s m") % mins) grid = builder.get_object('tracks') self._discs = self._album.discs self._tracks_left = {} self._tracks_right = {} show_label = len(self._discs) > 1 i = 0 for disc in self._discs: index = disc.number if show_label: label = Gtk.Label() label.set_text(_("Disc %s") % index) label.set_property('halign', Gtk.Align.START) label.get_style_context().add_class('dim-label') if i: label.set_property('margin-top', 30) label.show() grid.attach(label, 0, i, 2, 1) i += 1 self._tracks_left[index] = TracksWidget(self._pop_allowed, True) self._tracks_right[index] = TracksWidget(self._pop_allowed, True) grid.attach(self._tracks_left[index], 0, i, 1, 1) grid.attach(self._tracks_right[index], 1, i, 1, 1) size_group.add_widget(self._tracks_left[index]) size_group.add_widget(self._tracks_right[index]) self._tracks_left[index].connect('activated', self._on_activated) self._tracks_left[index].connect('button-press-event', self._on_button_press_event) self._tracks_right[index].connect('activated', self._on_activated) self._tracks_right[index].connect('button-press-event', self._on_button_press_event) self._tracks_left[index].show() self._tracks_right[index].show() i += 1 self._cover = builder.get_object('cover') self.set_cover() self.update_state() builder.get_object('title').set_label(self._album.name) if self._album.year: year = builder.get_object('year') year.set_label(self._album.year) year.show() self.add(builder.get_object('widget')) # TODO: Remove this test later if self._pop_allowed: self._menu = builder.get_object('menu') self._menu.connect('clicked', self._pop_menu) self._menu.show()
def __init__(self): self.dbus = None self.start_processes() self.group = None self.preset_name = None css_provider = Gtk.CssProvider() with open(get_data_path('style.css'), 'r') as file: css_provider.load_from_data(bytes(file.read(), encoding='UTF-8')) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) gladefile = get_data_path('key-mapper.glade') builder = Gtk.Builder() builder.add_from_file(gladefile) builder.connect_signals(self) self.builder = builder # set up the device selection # https://python-gtk-3-tutorial.readthedocs.io/en/latest/treeview.html#the-view combobox = self.get('device_selection') self.device_store = Gtk.ListStore(str, str, str) combobox.set_model(self.device_store) renderer_icon = Gtk.CellRendererPixbuf() renderer_text = Gtk.CellRendererText() renderer_text.set_padding(5, 0) combobox.pack_start(renderer_icon, False) combobox.pack_start(renderer_text, False) combobox.add_attribute(renderer_icon, 'icon-name', 1) combobox.add_attribute(renderer_text, 'text', 2) combobox.set_id_column(0) self.confirm_delete = builder.get_object('confirm-delete') self.about = builder.get_object('about-dialog') self.about.connect('delete-event', on_close_about) # set_position needs to be done once initially, otherwise the # dialog is not centered when it is opened for the first time self.about.set_position(Gtk.WindowPosition.CENTER_ON_PARENT) self.get('version-label').set_text( f'key-mapper {VERSION} {COMMIT_HASH[:7]}' f'\npython-evdev {EVDEV_VERSION}' if EVDEV_VERSION else '') window = self.get('window') window.show() # hide everything until stuff is populated self.get('vertical-wrapper').set_opacity(0) self.window = window # if any of the next steps take a bit to complete, have the window # already visible (without content) to make it look more responsive. gtk_iteration() # this is not set to invisible in glade to give the ui a default # height that doesn't jump when a gamepad is selected self.get('gamepad_separator').hide() self.get('gamepad_config').hide() self.populate_devices() self.timeouts = [] self.setup_timeouts() # now show the proper finished content of the window self.get('vertical-wrapper').set_opacity(1) self.ctrl = False self.unreleased_warn = False self.button_left_warn = False if not is_helper_running(): self.show_status(CTX_ERROR, 'The helper did not start')
def __init__(self, journal): self.journal = journal # Load Glade file. # TODO: Remove workaround for Windows once it is no longer needed. self.gladefile = os.path.join(filesystem.files_dir, 'main_window.glade') self.builder = Gtk.Builder() # Register GtkSourceView so builder can use it when loading the file # https://stackoverflow.com/q/10524196/434217 GObject.type_register(GtkSource.View) if filesystem.IS_WIN: import xml.etree.ElementTree as ET tree = ET.parse(self.gladefile) for node in tree.iter(): if 'translatable' in node.attrib: node.text = _(node.text) xml_text = ET.tostring(tree.getroot(), encoding='unicode') self.builder = Gtk.Builder.new_from_string(xml_text, len(xml_text)) else: self.builder.set_translation_domain('rednotebook') self.builder.add_from_file(self.gladefile) # Get the main window and set the icon self.main_frame = self.builder.get_object('main_frame') self.main_frame.set_title('RedNotebook') icon = GdkPixbuf.Pixbuf.new_from_file( os.path.join(filesystem.frame_icon_dir, 'rednotebook.svg')) self.main_frame.set_icon(icon) self.is_fullscreen = False self.uimanager = Gtk.UIManager() # Before fetching the menubar, add all menus and actiongroups. # Setup the toolbar items first to avoid warnings for missing actions. insert_menu.InsertMenu(self) format_menu.FormatMenu(self) self.menubar_manager = MainMenuBar(self) self.menubar = self.menubar_manager.get_menu_bar() main_vbox = self.builder.get_object('vbox3') main_vbox.pack_start(self.menubar, False, False, 0) main_vbox.reorder_child(self.menubar, 0) self.undo_action = self.uimanager.get_action('/MainMenuBar/Edit/Undo') self.redo_action = self.uimanager.get_action('/MainMenuBar/Edit/Redo') self.calendar = MainCalendar(self.journal, self.builder.get_object('calendar')) self.day_text_field = DayEditor( self.builder.get_object('day_text_view')) self.day_text_field.connect('can-undo-redo-changed', self.update_undo_redo_buttons) self.update_undo_redo_buttons() self.day_text_field.day_text_view.grab_focus() can_spell_check = self.day_text_field.can_spell_check() spell_check_enabled = bool(self.journal.config.read('spellcheck')) for actiongroup in self.menubar_manager.uimanager.get_action_groups(): if actiongroup.get_name() == 'MainMenuActionGroup': for action in actiongroup.list_actions(): if action.get_name() == 'CheckSpelling': action.set_sensitive(can_spell_check) action.set_active(spell_check_enabled and can_spell_check) self.day_text_field.enable_spell_check(spell_check_enabled) self.statusbar = Statusbar(self.builder.get_object('statusbar')) self.new_entry_dialog = NewEntryDialog(self) self.categories_tree_view = categories.CategoriesTreeView( self.builder.get_object('categories_tree_view'), self) self.new_entry_dialog.categories_tree_view = self.categories_tree_view self.back_one_day_button = self.builder.get_object( 'back_one_day_button') self.today_button = self.builder.get_object('today_button') self.forward_one_day_button = self.builder.get_object( 'forward_one_day_button') self.edit_pane = self.builder.get_object('edit_pane') self.text_vbox = self.builder.get_object('text_vbox') if browser.WebKit2: class Preview(browser.HtmlView): def __init__(self, journal): browser.HtmlView.__init__(self) self.journal = journal self.internal = True def show_day(self, new_day): html = self.journal.convert(new_day.text, 'xhtml') self.load_html(html) def shutdown(self): pass self.html_editor = Preview(self.journal) self.html_editor.connect('button-press-event', self.on_browser_clicked) self.html_editor.connect('decide-policy', self.on_browser_decide_policy) self.text_vbox.pack_start(self.html_editor, True, True, 0) self.html_editor.set_editable(False) elif browser_cef.cef: class Preview(browser_cef.HtmlView): def __init__(self, journal): super().__init__() self.journal = journal self.internal = True def show_day(self, new_day): html = self.journal.convert(new_day.text, 'xhtml') self.load_html(html) def highlight(self, text): pass self.html_editor = Preview(self.journal) self.text_vbox.pack_start(self.html_editor, True, True, 0) else: self.html_editor = mock.MagicMock() self.html_editor.internal = False preview_button = self.builder.get_object('preview_button') preview_button.set_label(_('Preview in Browser')) self.html_editor.hide() self.preview_mode = False # Let the edit_paned respect its childs size requests self.edit_pane.child_set_property(self.text_vbox, 'shrink', False) # Add InfoBar. self.infobar = customwidgets.Info() self.text_vbox.pack_start(self.infobar, False, False, 0) self.text_vbox.reorder_child(self.infobar, 1) # Add TemplateBar. self.template_bar = customwidgets.TemplateBar() self.text_vbox.pack_start(self.template_bar, False, False, 0) self.text_vbox.reorder_child(self.template_bar, 1) self.template_bar.hide() self.load_values_from_config() self.main_frame.show() self.options_manager = OptionsManager(self) self.export_assistant = ExportAssistant(self.journal) self.export_assistant.set_transient_for(self.main_frame) self.setup_clouds() self.setup_search() # Create an event->method dictionary and connect it to the widgets dic = { 'on_back_one_day_button_clicked': self.on_back_one_day_button_clicked, 'on_today_button_clicked': self.on_today_button_clicked, 'on_forward_one_day_button_clicked': self.on_forward_one_day_button_clicked, 'on_preview_button_clicked': self.on_preview_button_clicked, 'on_edit_button_clicked': self.on_edit_button_clicked, 'on_main_frame_configure_event': self.on_main_frame_configure_event, 'on_main_frame_window_state_event': self.on_main_frame_window_state_event, 'on_add_new_entry_button_clicked': self.on_add_new_entry_button_clicked, 'on_main_frame_delete_event': self.on_main_frame_delete_event, # connect_signals can only be called once, it seems # Otherwise RuntimeWarnings are raised: RuntimeWarning: missing handler '...' } self.builder.connect_signals(dic) self.set_shortcuts() self.setup_stats_dialog() self.template_manager = templates.TemplateManager(self) self.template_manager.make_empty_template_files() self.setup_template_menu() self.set_tooltips() self.setup_tray_icon() # Show/hide the "tags" panel on the right. self.builder.get_object('annotations_pane').set_visible( self.journal.config.read('showTagsPane'))
def setup(self): shell = self.props.shell builder = Gtk.Builder() builder.add_from_file( rb.find_plugin_file(self.props.plugin, "soundcloud.ui")) self.scrolled = builder.get_object("container-scrolled") self.scrolled.set_no_show_all(True) self.scrolled.hide() self.more_containers_idle = 0 adj = self.scrolled.get_vadjustment() adj.connect("changed", self.scroll_adjust_changed_cb) adj.connect("value-changed", self.scroll_adjust_changed_cb) self.search_entry = RB.SearchEntry(spacing=6) self.search_entry.props.explicit_mode = True self.fetch_more_button = Gtk.Button.new_with_label( _("Fetch more tracks")) self.fetch_more_button.connect("clicked", self.show_more_cb) action = Gio.SimpleAction.new("soundcloud-search-type", GLib.VariantType.new('s')) action.connect("activate", self.search_type_action_cb) shell.props.window.add_action(action) m = Gio.Menu() for st in sorted(self.search_types): i = Gio.MenuItem() i.set_label(self.search_types[st]['label']) i.set_action_and_target_value("win.soundcloud-search-type", GLib.Variant.new_string(st)) m.append_item(i) self.search_popup = Gtk.Menu.new_from_model(m) action.activate(GLib.Variant.new_string("tracks")) grid = builder.get_object("soundcloud-source") self.search_entry.connect("search", self.search_entry_cb) self.search_entry.connect("activate", self.search_entry_cb) self.search_entry.connect("show-popup", self.search_popup_cb) self.search_entry.set_size_request(400, -1) searchbox = builder.get_object("search-box") searchbox.pack_start(self.search_entry, False, True, 0) searchbox.pack_start(self.fetch_more_button, False, True, 0) self.search_popup.attach_to_widget(self.search_entry, None) self.containers = builder.get_object("container-store") self.container_view = builder.get_object("containers") self.container_view.set_model(self.containers) action = Gio.SimpleAction.new("soundcloud-open-uri", GLib.VariantType.new('s')) action.connect("activate", self.open_uri_action_cb) shell.props.window.add_action(action) r = Gtk.CellRendererText() c = Gtk.TreeViewColumn("", r, text=0) self.container_view.append_column(c) self.container_view.get_selection().connect('changed', self.selection_changed_cb) self.songs = RB.EntryView(db=shell.props.db, shell_player=shell.props.shell_player, is_drag_source=True, is_drag_dest=False) self.songs.append_column(RB.EntryViewColumn.TITLE, True) self.songs.append_column(RB.EntryViewColumn.ARTIST, True) self.songs.append_column(RB.EntryViewColumn.DURATION, True) self.songs.append_column(RB.EntryViewColumn.YEAR, False) self.songs.append_column(RB.EntryViewColumn.GENRE, False) self.songs.append_column(RB.EntryViewColumn.BPM, False) self.songs.append_column(RB.EntryViewColumn.FIRST_SEEN, False) self.songs.set_model(self.props.query_model) self.songs.connect("notify::sort-order", self.sort_order_changed_cb) self.songs.connect("selection-changed", self.songs_selection_changed_cb) paned = builder.get_object("paned") paned.pack2(self.songs) self.bind_settings(self.songs, paned, None, True) self.sc_button = Gtk.MenuButton() self.sc_button.set_relief(Gtk.ReliefStyle.NONE) img = Gtk.Image.new_from_file( rb.find_plugin_file(self.props.plugin, "powered-by-soundcloud.png")) self.sc_button.add(img) box = builder.get_object("soundcloud-button-box") box.pack_start(self.sc_button, True, True, 0) self.build_sc_menu() self.pack_start(grid, expand=True, fill=True, padding=0) grid.show_all() self.art_store = RB.ExtDB(name="album-art") player = shell.props.shell_player player.connect('playing-song-changed', self.playing_entry_changed_cb)
def __init__(self, album_id, genre_ids, artist_ids, show_cover): """ Init detailed album widget @param album id as int @param genre ids as [int] @param artist ids as [int] @param lazy as LazyLoadingView @param show cover as bool """ Gtk.Bin.__init__(self) AlbumWidget.__init__(self, album_id, genre_ids) self._album.set_artists(artist_ids) self.__width = None # Cover + rating + spacing self.__height = ArtSize.BIG + 26 self.__orientation = None self.__child_height = TrackRow.get_best_height(self) # Header + separator + spacing + margin self.__requested_height = self.__child_height + 6 # Discs to load, will be emptied self.__discs = self._album.discs self.__locked_widget_right = True self._filter_ids = artist_ids self.set_property('height-request', self.__height) self.connect('size-allocate', self.__on_size_allocate) builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Lollypop/AlbumDetailedWidget.ui') self._widget = builder.get_object('widget') self.__overlay = builder.get_object('overlay') self._play_button = builder.get_object('play-button') self._artwork_button = builder.get_object('artwork-button') self._action_button = builder.get_object('action-button') self._action_event = builder.get_object('action-event') builder.connect_signals(self) rating = RatingWidget(self._album) rating.show() artist_label = builder.get_object('artist') if show_cover: self._cover = builder.get_object('cover') builder.get_object('duration').set_hexpand(True) self._cover.get_style_context().add_class('cover-frame') self.__coverbox = builder.get_object('coverbox') self.__coverbox.show() # 6 for 2*3px (application.css) self.__coverbox.set_property('width-request', ArtSize.BIG + 6) self.__coverbox.add(rating) if Lp().window.get_view_width() < WindowSize.MEDIUM: self.__coverbox.hide() if len(artist_ids) > 1: artist_label.set_text(", ".join(self._album.artists)) artist_label.show() else: builder.get_object('header').attach(rating, 4, 0, 1, 1) rating.set_hexpand(True) rating.set_property('halign', Gtk.Align.END) rating.set_property('valign', Gtk.Align.CENTER) artist_label.set_text(", ".join(self._album.artists)) artist_label.show() self._cover = None label = builder.get_object('duration') duration = Lp().albums.get_duration(album_id, genre_ids) hours = int(duration / 3600) mins = int(duration / 60) if hours > 0: mins -= hours * 60 if mins > 0: label.set_text(_("%s h %s m") % (hours, mins)) else: label.set_text(_("%s h") % hours) else: label.set_text(_("%s m") % mins) self.__box = Gtk.Grid() self.__box.set_column_homogeneous(True) self.__box.set_property('valign', Gtk.Align.START) self.__box.show() builder.get_object('albuminfo').add(self.__box) self._tracks_left = {} self._tracks_right = {} self.set_cover() self.update_state() builder.get_object('title').set_label(self._album.name) if self._album.year: year = builder.get_object('year') year.set_label(self._album.year) year.show() for disc in self.__discs: self.__add_disc_container(disc.number) self.__set_disc_height(disc) self.add(self._widget) # We start transparent, we switch opaque at size allocation # This prevent artifacts self.set_opacity(0) self._menu = builder.get_object('menu') self._menu.connect('clicked', self.__pop_menu) # TODO Remove this later if Gtk.get_minor_version() > 16: self._menu.show() else: self.connect('map', self.__on_map) if self._album.is_youtube and show_cover: self._cover.get_style_context().add_class('cover-frame-youtube')
def __init__(self): """ Init dialog """ self.__timeout_id = None self.__choosers = [] self.__locked = [] builder = Gtk.Builder() builder.add_from_resource("/org/gnome/Lollypop/SettingsDialog.ui") self.__settings_dialog = builder.get_object("settings_dialog") self.__progress = builder.get_object("progress") for setting in self.__BOOLEAN: button = builder.get_object("%s_boolean" % setting) value = App().settings.get_value(setting) button.set_state(value) for setting in self.__ENTRY: entry = builder.get_object("%s_entry" % setting) value = App().settings.get_value(setting).get_string() entry.set_text(value) for setting in self.__RANGE: widget = builder.get_object("%s_range" % setting) value = App().settings.get_value(setting).get_int32() widget.set_value(value) for setting in self.__COMBO: widget = builder.get_object("%s_combo" % setting) value = App().settings.get_enum(setting) widget.set_active(value) for locked in self.__LOCKED: widget = builder.get_object(locked) self.__locked.append(widget) self.__update_locked() self.__music_group = builder.get_object("music_group") for uri in App().settings.get_value("music-uris"): button = self.__get_new_chooser(uri) self.__music_group.add(button) for device in App().settings.get_value("devices"): row = DeviceRow(device) builder.get_object("device_group").add(row) acl = App().settings.get_value("network-access-acl").get_int32() for key in NetworkAccessACL.keys(): if acl & NetworkAccessACL[key]: builder.get_object("%s_button" % key).set_state(True) artists_count = App().artists.count() albums_count = App().albums.count() tracks_count = App().tracks.count() builder.get_object("stat_artists").set_title( _("Artists count: %s") % artists_count) builder.get_object("stat_albums").set_title( _("Albums count: %s") % albums_count) builder.get_object("stat_tracks").set_title( _("Tracks count: %s") % tracks_count) self.__settings_dialog.set_transient_for(App().window) self.__settings_dialog.connect("destroy", self.__on_destroy) passwords_helper = PasswordsHelper() passwords_helper.get("LASTFM", self.__on_get_password, builder.get_object("lastfm_button")) passwords_helper.get("LIBREFM", self.__on_get_password, builder.get_object("librefm_button")) builder.connect_signals(self) self.__multi_press = Gtk.EventControllerKey.new(self.__settings_dialog) self.__multi_press.connect("key-released", self.__on_key_released)
def add_from_string(self, strg): builder = Gtk.Builder() if self.domain is not None: builder.set_translation_domain(self.domain) self.builders.append(builder) builder.add_from_string(strg)
def create_headerbar(self): """Create the headerbar""" hbar = Gtk.HeaderBar() hbar.props.show_close_button = True hbar.props.title = APP_NAME box = Gtk.Box() Gtk.StyleContext.add_class(box.get_style_context(), "linked") if os.name == 'nt': icon_size = Gtk.IconSize.BUTTON else: icon_size = Gtk.IconSize.LARGE_TOOLBAR # create the preview button self.preview_button = Gtk.Button.new_from_icon_name( 'edit-find', icon_size) self.preview_button.set_always_show_image(True) self.preview_button.connect( 'clicked', lambda *dummy: self.preview_or_run_operations(False)) self.preview_button.set_tooltip_text( _("Preview files in the selected operations (without deleting any files)" )) # TRANSLATORS: This is the preview button on the main window. It # previews changes. self.preview_button.set_label(_('Preview')) box.add(self.preview_button) # create the delete button self.run_button = Gtk.Button.new_from_icon_name( 'edit-clear-all', icon_size) self.run_button.set_always_show_image(True) # TRANSLATORS: This is the clean button on the main window. # It makes permanent changes: usually deleting files, sometimes # altering them. self.run_button.set_label(_('Clean')) self.run_button.set_tooltip_text( _("Clean files in the selected operations")) self.run_button.connect("clicked", self.run_operations) box.add(self.run_button) # stop cleaning self.stop_button = Gtk.Button.new_from_icon_name( 'process-stop', icon_size) self.stop_button.set_always_show_image(True) self.stop_button.set_label(_('Abort')) self.stop_button.set_tooltip_text( _('Abort the preview or cleaning process')) self.stop_button.set_sensitive(False) self.stop_button.connect('clicked', self.cb_stop_operations) box.add(self.stop_button) hbar.pack_start(box) # Add hamburger menu on the right. # This is not needed for Microsoft Windows because other code places its # menu on the left side. if os.name == 'nt': return hbar menu_button = Gtk.MenuButton() icon = Gio.ThemedIcon(name="open-menu-symbolic") image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON) builder = Gtk.Builder() builder.add_from_file(bleachbit.app_menu_filename) menu_button.set_menu_model(builder.get_object('app-menu')) menu_button.add(image) hbar.pack_end(menu_button) return hbar
def __init__(self, window, player): """Initialize :param GtkWidget window: The main window :param player: The main player object """ self._playlists_sidebar = Gd.MainView() super().__init__('playlists', _("Playlists"), window, Gd.MainViewType.LIST, True, self._playlists_sidebar) self._window = window self.player = player style_context = self._view.get_generic_view().get_style_context() style_context.add_class('songs-list') style_context.remove_class('content-view') self._add_list_renderers() builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Music/PlaylistControls.ui') headerbar = builder.get_object('grid') self._name_label = builder.get_object('playlist_name') self._songs_count_label = builder.get_object('songs_count') self._menubutton = builder.get_object('playlist_menubutton') playlist_play_action = Gio.SimpleAction.new('playlist_play', None) playlist_play_action.connect('activate', self._on_play_activate) self._window.add_action(playlist_play_action) self._playlist_delete_action = Gio.SimpleAction.new( 'playlist_delete', None) self._playlist_delete_action.connect('activate', self._on_delete_activate) self._window.add_action(self._playlist_delete_action) self._grid.insert_row(0) self._grid.attach(headerbar, 1, 0, 1, 1) self._playlists_model = Gtk.ListStore( GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GdkPixbuf.Pixbuf, GObject.TYPE_OBJECT, GObject.TYPE_BOOLEAN, GObject.TYPE_INT, GObject.TYPE_STRING, GObject.TYPE_INT, GObject.TYPE_BOOLEAN, GObject.TYPE_INT) self._playlists_sidebar.set_view_type(Gd.MainViewType.LIST) self._playlists_sidebar.set_model(self._playlists_model) self._playlists_sidebar.set_hexpand(False) self._playlists_sidebar.get_style_context().add_class('side-panel') self._pl_generic_view = self._playlists_sidebar.get_generic_view() self._pl_generic_view.get_selection().set_mode( Gtk.SelectionMode.SINGLE) self._playlists_sidebar.connect('item-activated', self._on_playlist_activated) self._grid.insert_column(0) self._grid.child_set_property(self.stack, 'top-attach', 0) self._grid.child_set_property(self.stack, 'height', 2) self._add_sidebar_renderers() self._pl_generic_view.get_style_context().remove_class('content-view') self._iter_to_clean = None self._iter_to_clean_model = None self.current_playlist = None self._current_playlist_index = None self.pl_todelete = None self._pl_todelete_index = None self._songs_count = 0 self._update_songs_count() self.player.connect('playlist-item-changed', self._update_model) playlists.connect('playlist-created', self._on_playlist_created) playlists.connect('playlist-updated', self._on_playlist_update) playlists.connect('song-added-to-playlist', self._on_song_added_to_playlist) playlists.connect('song-removed-from-playlist', self._on_song_removed_from_playlist) self.show_all()
def __init__(self, node_name_override = 'finderv2_testing_interface'): rospy.init_node(node_name_override) #self.nodename = rospy.get_name() #rospy.loginfo("finder starting with name %s", self.nodename) self.joy_Sub = rospy.Subscriber("joy", Joy, self.joyCb) self.pub1 = rospy.Publisher("motor_arm_base", Int16) self.pub2 = rospy.Publisher("motor_arm_1", Int16) self.pub3 = rospy.Publisher("motor_arm_2", Int16) self.pub4 = rospy.Publisher("servo_arm_1", Int16) self.pub5 = rospy.Publisher("servo_arm_2", Int16) self.pub6 = rospy.Publisher("servo_arm_gripper", Int16) self.pub7 = rospy.Publisher("motor_traction_left", Int16) self.pub8 = rospy.Publisher("motor_traction_right", Int16) self.pub9 = rospy.Publisher("motor_traction_arm_fr", Int16) self.pub10 = rospy.Publisher("motor_traction_arm_fl", Int16) self.pub11 = rospy.Publisher("motor_traction_arm_br", Int16) self.pub12 = rospy.Publisher("motor_traction_arm_bl", Int16) self.motor_arm_base_value = 0 self.motor_arm_1_value = 0 self.motor_arm_2_value = 0 self.servo_arm_1_value = 0 self.servo_arm_2_value = 0 self.servo_arm_gripper_value = 0 self.motor_traction_left_value = 0 self.motor_traction_right_value = 0 self.motor_traction_arm_fr_value = 0 self.motor_traction_arm_fl_value = 0 self.motor_traction_arm_br_value = 0 self.motor_traction_arm_bl_value = 0 self.leftpad = 0 self.rightpad = 0 #str = roslib.packages.get_pkg_dir('finder') + "/scripts/finderv2_testing_interface.glade" #fix for user path, fix better str = expanduser("~") + "/workspace/catkin/src/finder/scripts/finderv2_testing_interface.glade" self.gladefile = str builder = Gtk.Builder() builder.add_from_file(self.gladefile) builder.connect_signals(self) # self.gui_d1 = builder.get_object("d1") self.motor_arm_base_leftpad = builder.get_object("motor_arm_base_leftpad") self.motor_arm_1_leftpad = builder.get_object("motor_arm_1_leftpad") self.motor_arm_2_leftpad = builder.get_object("motor_arm_2_leftpad") self.servo_arm_1_leftpad = builder.get_object("servo_arm_1_leftpad") self.servo_arm_2_leftpad = builder.get_object("servo_arm_2_leftpad") self.servo_arm_gripper_leftpad = builder.get_object("servo_arm_gripper_leftpad") self.motor_traction_arm_fr_leftpad = builder.get_object("motor_traction_arm_fr_leftpad") self.motor_traction_arm_fl_leftpad = builder.get_object("motor_traction_arm_fl_leftpad") self.motor_traction_arm_br_leftpad = builder.get_object("motor_traction_arm_br_leftpad") self.motor_traction_arm_bl_leftpad = builder.get_object("motor_traction_arm_bl_leftpad") self.motor_traction_left_leftpad = builder.get_object("motor_traction_left_leftpad") self.motor_traction_right_leftpad = builder.get_object("motor_traction_right_leftpad") self.motor_arm_base_rightpad = builder.get_object("motor_arm_base_rightpad") self.motor_arm_1_rightpad = builder.get_object("motor_arm_1_rightpad") self.motor_arm_2_rightpad = builder.get_object("motor_arm_2_rightpad") self.servo_arm_1_rightpad = builder.get_object("servo_arm_1_rightpad") self.servo_arm_2_rightpad = builder.get_object("servo_arm_2_rightpad") self.servo_arm_gripper_rightpad = builder.get_object("servo_arm_gripper_rightpad") self.motor_traction_arm_fr_rightpad = builder.get_object("motor_traction_arm_fr_rightpad") self.motor_traction_arm_fl_rightpad = builder.get_object("motor_traction_arm_fl_rightpad") self.motor_traction_arm_br_rightpad = builder.get_object("motor_traction_arm_br_rightpad") self.motor_traction_arm_bl_rightpad = builder.get_object("motor_traction_arm_bl_rightpad") self.motor_traction_left_rightpad = builder.get_object("motor_traction_left_rightpad") self.motor_traction_right_rightpad = builder.get_object("motor_traction_right_rightpad") self.window = builder.get_object("window1") self.window.show_all()
def initialize_builder(self): self.builder = Gtk.Builder() self.builder.add_from_file('resources/glade/ui.xml')
def __init__(self): try: self.builder = Gtk.Builder() self.builder.add_from_file("/usr/lib/cinnamon-settings-users/cinnamon-settings-users.ui") self.window = self.builder.get_object("main_window") self.window.connect("destroy", Gtk.main_quit) self.window.set_title(_("Users and Groups")) self.builder.get_object("label_users").set_label(_("Users")) self.builder.get_object("label_groups").set_label(_("Groups")) self.builder.get_object("button_add_user").connect("clicked", self.on_user_addition) self.builder.get_object("button_delete_user").connect("clicked", self.on_user_deletion) self.builder.get_object("button_add_group").connect("clicked", self.on_group_addition) self.builder.get_object("button_edit_group").connect("clicked", self.on_group_edition) self.builder.get_object("button_delete_group").connect("clicked", self.on_group_deletion) self.users = Gtk.TreeStore(object, GdkPixbuf.Pixbuf, str) self.users.set_sort_column_id(2, Gtk.SortType.ASCENDING) self.groups = Gtk.TreeStore(int, str) self.groups.set_sort_column_id(1, Gtk.SortType.ASCENDING) self.users_treeview = self.builder.get_object("treeview_users") self.users_treeview.set_rules_hint(True) self.groups_treeview = self.builder.get_object("treeview_groups") self.users_treeview.get_selection().connect("changed", self.on_user_selection) self.groups_treeview.get_selection().connect("changed", self.on_group_selection) column = Gtk.TreeViewColumn() cell = Gtk.CellRendererPixbuf() column.pack_start(cell, True) column.add_attribute(cell, 'pixbuf', INDEX_USER_PICTURE) cell.set_property('ypad', 1) self.users_treeview.append_column(column) column = Gtk.TreeViewColumn() cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'markup', INDEX_USER_DESCRIPTION) self.users_treeview.append_column(column) column = Gtk.TreeViewColumn() cell = Gtk.CellRendererText() column.pack_start(cell, True) column.add_attribute(cell, 'text', INDEX_GROUPNAME) column.set_sort_column_id(1) self.groups_treeview.append_column(column) self.builder.get_object("button_delete_user").set_sensitive(False) self.builder.get_object("button_edit_group").set_sensitive(False) self.builder.get_object("button_delete_group").set_sensitive(False) self.face_button = Gtk.Button() self.face_image = Gtk.Image() self.face_button.set_image(self.face_image) self.face_image.set_from_file("/usr/share/cinnamon/faces/user-generic.png") self.face_button.set_alignment(0.0, 0.5) self.face_button.set_tooltip_text(_("Click to change the picture")) self.menu = Gtk.Menu() separator = Gtk.SeparatorMenuItem() face_browse_menuitem = Gtk.MenuItem(_("Browse for more pictures...")) face_browse_menuitem.connect('activate', self._on_face_browse_menuitem_activated) self.face_button.connect("button-release-event", self.menu_display) row = 0 col = 0 num_cols = 4 face_dirs = ["/usr/share/cinnamon/faces"] for face_dir in face_dirs: if os.path.exists(face_dir): pictures = sorted(os.listdir(face_dir)) for picture in pictures: path = os.path.join(face_dir, picture) file = Gio.File.new_for_path(path) file_icon = Gio.FileIcon.new(file) image = Gtk.Image.new_from_gicon (file_icon, Gtk.IconSize.DIALOG) menuitem = Gtk.MenuItem() menuitem.add(image) menuitem.connect('activate', self._on_face_menuitem_activated, path) self.menu.attach(menuitem, col, col+1, row, row+1) col = (col+1) % num_cols if (col == 0): row = row + 1 row = row + 1 self.menu.attach(separator, 0, 4, row, row+1) self.menu.attach(face_browse_menuitem, 0, 4, row+2, row+3) self.account_type_combo = Gtk.ComboBoxText() self.account_type_combo.append_text(_("Standard")) self.account_type_combo.append_text(_("Administrator")) self.account_type_combo.connect("changed", self._on_accounttype_changed) self.realname_entry = EditableEntry() self.realname_entry.connect("changed", self._on_realname_changed) self.realname_entry.set_tooltip_text(_("Click to change the name")) self.password_mask = Gtk.Label() self.password_mask.set_alignment(0.0, 0.5) self.password_button = Gtk.Button() self.password_button.add(self.password_mask) self.password_button.set_relief(Gtk.ReliefStyle.NONE) self.password_button.set_tooltip_text(_("Click to change the password")) self.password_button.connect('activate', self._on_password_button_clicked) self.password_button.connect('released', self._on_password_button_clicked) self.groups_label = Gtk.Label() self.groups_label.set_line_wrap(True) self.groups_label.set_alignment(0, 0.5) self.groups_button = Gtk.Button() self.groups_button.add(self.groups_label) self.groups_button.set_relief(Gtk.ReliefStyle.NONE) self.groups_button.set_tooltip_text(_("Click to change the groups")) self.groups_button.connect("clicked", self._on_groups_button_clicked) box = Gtk.Box() box.pack_start(self.face_button, False, False, 0) table = DimmedTable() table.add_labels([_("Picture"), _("Account Type"), _("Name"), _("Password"), _("Groups")]) table.add_controls([box, self.account_type_combo, self.realname_entry, self.password_button, self.groups_button]) self.builder.get_object("box_users").add(table) self.accountService = AccountsService.UserManager.get_default() self.accountService.connect('notify::is-loaded', self.on_accounts_service_loaded) self.load_groups() self.window.show_all() self.builder.get_object("box_users").hide() except Exception, detail: print detail
def initialise(self, plugin): super(AltToolbarShared, self).initialise(plugin) ui = rb.find_plugin_file(plugin, 'ui/alttoolbar.ui') builder = Gtk.Builder() builder.add_from_file(ui) self.load_builder_content(builder) self.connect_builder_content(builder) self._controllers['generic'] = AltGenericController(self) # every potential source should have its own controller - we use this to # categorise the source and provide specific capability for inherited classes # where a controller is not specified then a generic controller is used # i.e. use add_controller method to add a controller self.add_controller(AltMusicLibraryController(self)) self.add_controller(AltSoundCloudController(self)) self.add_controller(AltCoverArtBrowserController(self)) self.add_controller(AltCoverArtPlaySourceController(self)) self.add_controller(AltQueueController(self)) self.add_controller(AltStandardOnlineController(self)) self.add_controller(AltStandardLocalController(self)) self.add_controller(AltRadioController(self)) self.add_controller(AltLastFMController(self)) self.add_controller(AltPlaylistController(self)) self.add_controller(AltErrorsController(self)) self.add_controller(AltPodcastController(self)) self.add_controller(AltAndroidController(self)) # support RTL for control, icon_name in [ (self.prev_button, 'media-skip-backward-symbolic'), (self.play_button, 'media-playback-start-symbolic'), (self.next_button, 'media-skip-forward-symbolic') ]: image = control.get_child() icon_name = self.request_rtl_icon(control, icon_name) image.set_from_icon_name(icon_name, image.props.icon_size) # now move current RBDisplayPageTree to listview stack display_tree = self.shell.props.display_page_tree self.display_tree_parent = display_tree.get_parent() self.display_tree_parent.remove(display_tree) self.stack = Gtk.Stack() self.stack.set_transition_type( Gtk.StackTransitionType.SLIDE_LEFT_RIGHT) self.stack.set_transition_duration(1000) image_name = 'view-list-symbolic' box_listview = Gtk.Box() box_listview.pack_start(display_tree, True, True, 0) # box_listview.show_all() self.stack.add_named(box_listview, "listview") self.stack.child_set_property(box_listview, "icon-name", image_name) self.stack.show_all() self.display_tree_parent.pack1(self.stack, True, True) #if 1==2: #self.plugin.enhanced_sidebar: toolbar = self.find(display_tree, 'GtkToolbar', 'by_name') #context = toolbar.get_style_context() #context.add_class('toolbar') box = self.find(toolbar, 'GtkBox', 'by_name') #box.props.margin_top = 2 #box.props.margin_bottom = 0 #box.props.margin_left = 5 context = box.get_style_context() context.add_class('linked') #parent = box.get_parent() #parent.remove(box) #parent_toolbar = toolbar.get_parent() #parent_toolbar.remove(toolbar) #display_tree.attach(box, 0, 10, 1 ,1 ) # child, new-parent, old-parent #self._moved_controls.append((box, display_tree, parent)) #self._moved_controls.append((toolbar, None, parent_toolbar)) # find the actual GtkTreeView in the RBDisplayTree and remove it self.rbtree = self.find(display_tree, 'GtkTreeView', 'by_name') self.rbtreeparent = self.rbtree.get_parent() self.rbtreeparent.remove(self.rbtree) self.sidebar = None
def on_programs_needed_clicked(self, b): builder = Gtk.Builder() builder.set_translation_domain(self.config.gettext_domain) builder.add_from_file(os.path.join(self.config.glade, "wneeded.ui")) window = builder.get_object("needed") textbuf = builder.get_object("textbuffer") window.show_all() analizers, players, menuers, converters, burners, mkiso = self.cv.get_supported_programs() analizers_i, players_i, menuers_i, converters_i, burners_i, mkiso_i = self.cv.get_available_programs() text = "" for e in analizers: if analizers_i.count(e.display_name) == 0: text += _("\t%(program_name)s (not installed)\n") % { "program_name": e.display_name} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": e.display_name} text1 = _("Movie identifiers (install at least one of these):\n\n%(program_list)s\n") % { "program_list": text} text = "" for e in players: if players_i.count(e.display_name) == 0: text += _("\t%(program_name)s (not installed)\n") % { "program_name": e.display_name} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": e.display_name} text2 = _("Movie players (install at least one of these):\n\n%(program_list)s\n") % { "program_list": text} text = "" for e in converters: sup = "" for s in e.disc_types: if sup != "": sup += ", " sup += s if converters_i.count(e.display_name) == 0: text += _("\t%(program_name)s (not installed)\n") % { "program_name": e.display_name + " (" + sup + ")"} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": e.display_name + " (" + sup + ")"} text3 = _("Movie Converters (install at least one of these):\n\n%(program_list)s\n") % { "program_list": text} text = "" for e in burners: if burners_i.count(e.display_name) == 0: text += _("\t%(program_name)s (not installed)\n") % { "program_name": e.display_name} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": e.display_name} text4 = _( "CD/DVD burners (install at least one of these):\n\n%(program_list)s\n") % {"program_list": text} text = "" for e in mkiso: if mkiso_i.count(e.display_name) == 0: text += _("\t%(program_name)s (not installed)\n") % { "program_name": e.display_name} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": e.display_name} text5 = _("ISO creators (install at least one of these):\n\n%(program_list)s\n") % { "program_list": text} text = "" if self.check_program(["dvdauthor", "--help"]) == False: text += _("\t%(program_name)s (not installed)\n") % { "program_name": "DVDAUTHOR (dvd)"} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": "DVDAUTHOR (dvd)"} if self.check_program(["vcdimager", "--help"]) == False: text += _("\t%(program_name)s (not installed)\n") % { "program_name": "VCDIMAGER (vcd, svcd, cvd)"} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": "VCDIMAGER (vcd, svcd, cvd)"} if self.check_program(["spumux", "--help"]) == False: text += _("\t%(program_name)s (not installed)\n") % { "program_name": "SPUMUX (dvd, vcd, svcd, cvd)"} else: text += _("\t%(program_name)s (installed)\n") % { "program_name": "SPUMUX (dvd, vcd, svcd, cvd)"} text6 = _("Other programs:\n\n%(program_list)s\n") % { "program_list": text} final_text = text1 + text2 + text3 + text4 + text5 + text6 textbuf.insert_at_cursor(final_text, len(final_text)) window.run() window.destroy()
def __init__(self): """ Init toolbar """ Gtk.Bin.__init__(self) self.set_hexpand(True) self.__search_popover = None self.__devices_popover = None self.__timeout_id = None builder = Gtk.Builder() builder.add_from_resource("/org/gnome/Lollypop/ToolbarEnd.ui") self.__party_submenu = builder.get_object("party_submenu") self.add(builder.get_object("end")) # Map some settings to actions, can't use Gio.Settings.create_action() # because API does not support set_enabled() self.__shuffle_action = Gio.SimpleAction.new_stateful( "shuffle", GLib.VariantType.new("s"), GLib.Variant("s", "none")) self.__shuffle_action.set_state(App().settings.get_value("shuffle")) self.__shuffle_action.connect("change-state", self.__on_shuffle_change_state) self.__repeat_action = Gio.SimpleAction.new_stateful( "repeat", GLib.VariantType.new("s"), GLib.Variant("s", "none")) self.__repeat_action.set_state(App().settings.get_value("repeat")) self.__repeat_action.connect("change-state", self.__on_repeat_change_state) App().add_action(self.__shuffle_action) App().add_action(self.__repeat_action) self.__shuffle_button = builder.get_object("shuffle_button") self.__shuffle_button_image = builder.get_object( "shuffle_button_image") shuffle_button_action = Gio.SimpleAction.new("shuffle-button", None) shuffle_button_action.connect("activate", self.__on_shuffle_button_activate) App().add_action(shuffle_button_action) App().set_accels_for_action("app.shuffle-button", ["<Control>r"]) App().settings.connect("changed::shuffle", self.__on_repeat_changed) App().settings.connect("changed::repeat", self.__on_repeat_changed) party_action = Gio.SimpleAction.new_stateful( "party", None, GLib.Variant.new_boolean(App().player.is_party)) party_action.connect("change-state", self.__on_party_mode_change_state) App().add_action(party_action) App().set_accels_for_action("app.party", ["<Control>p"]) scrobbling_disabled = App().settings.get_value("disable-scrobbling") scrobbling_action = Gio.SimpleAction.new_stateful( "scrobbling", None, GLib.Variant.new_boolean(not scrobbling_disabled)) scrobbling_action.connect("change-state", self.__on_scrobbling_mode_change_state) App().add_action(scrobbling_action) App().set_accels_for_action("app.scrobbling", ["<Control><Shift>s"]) self.__search_button = builder.get_object("search_button") search_action = App().lookup_action("search") search_action.connect("activate", self.__on_search_activate) self.__list_button = builder.get_object("list_button") self.__list_button.set_property("has-tooltip", True) self.__list_button.connect("query-tooltip", self.__on_list_button_query_tooltip) self.__home_button = builder.get_object("home_button") App().player.connect("playlist-changed", self.__on_playlist_changed) self.__set_shuffle_icon() button_progress_bar = ButtonProgressBar() overlay = builder.get_object("overlay") overlay.add_overlay(button_progress_bar) overlay.set_overlay_pass_through(button_progress_bar, True) devices_button = builder.get_object("devices_button") self.__devices_popover = DevicesPopover(button_progress_bar) self.__devices_popover.connect( "closed", self.__on_popover_closed, devices_button) self.__devices_popover.connect("content-changed", self.__on_devices_content_changed, devices_button) self.__devices_popover.populate() builder.connect_signals(self)
def __init__(self): self.config = devedeng.configuration_data.configuration.get_config() builder = Gtk.Builder() builder.set_translation_domain(self.config.gettext_domain) builder.add_from_file(os.path.join( self.config.glade, "wselect_disk.ui")) builder.connect_signals(self) self.wask_window = builder.get_object("wselect_disk") self.cv = devedeng.converter.converter.get_converter() dvd = True vcd = True cvd = True svcd = True divx = True mkv = True analizers, players, converters, menuers, burners, mkiso = self.cv.get_needed_programs() if (analizers is not None) or (converters is not None): dvd = False vcd = False cvd = False svcd = False divx = False mkv = False if menuers is not None: dvd = False if mkiso is not None: dvd = False if self.check_program(["dvdauthor", "--help"]) == False: dvd = False if self.check_program(["vcdimager", "--help"]) == False: vcd = False svcd = False cvd = False if self.check_program(["spumux", "--help"]) == False: dvd = False vcd = False svcd = False cvd = False if self.cv.discs.count("dvd") == 0: dvd = False if self.cv.discs.count("vcd") == 0: vcd = False if self.cv.discs.count("svcd") == 0: svcd = False if self.cv.discs.count("cvd") == 0: cvd = False if self.cv.discs.count("divx") == 0: divx = False if self.cv.discs.count("mkv") == 0: mkv = False builder.get_object("button_dvd").set_sensitive(dvd) builder.get_object("button_vcd").set_sensitive(vcd) builder.get_object("button_svcd").set_sensitive(svcd) builder.get_object("button_cvd").set_sensitive(cvd) builder.get_object("button_divx").set_sensitive(divx) builder.get_object("button_mkv").set_sensitive(mkv) self.wask_window.show_all()
index = 0 found = txt.lower().find(new_mnemonic, start) while found != -1: index = found if index == 0 or txt[index - 1] == ' ': break found = txt.lower().find(new_mnemonic, index + 1) widget.set_text_with_mnemonic(txt[0:index] + '_' + txt[index:]) if __name__ == '__main__': from gourmet import gglobals from gi.repository import Gtk import os.path mm = MnemonicManager() ui = Gtk.Builder() ui.add_from_file(os.path.join(gglobals.uibase, 'app.ui')) mm.add_builder(ui) #tree = ui.get_widget('recTree') #rend = Gtk.CellRendererText() #cols = ['Cuisine','Rating','Preparation Time','Cooking Time','Title','Servings'] #for i,l in enumerate(cols): # col = Gtk.TreeViewColumn('_'+l,text=i) # tree.append_column(col) #mod = Gtk.ListStore(*[str]*(i+1)) #for n in range(10): mod.append(cols) #tree.set_model(mod) #mm.add_treeview(tree) mm.fix_conflicts_peacefully() def show():
def __init__(self, window, player): """Initialize :param GtkWidget window: The main window :param player: The main player object """ self._sidebar = Gtk.ListBox() sidebar_container = Gtk.ScrolledWindow() sidebar_container.add(self._sidebar) super().__init__('playlists', _("Playlists"), window, None, True, sidebar_container) self._window = window self.player = player self._view.get_style_context().add_class('songs-list') self._add_list_renderers() builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Music/PlaylistControls.ui') headerbar = builder.get_object('grid') self._name_stack = builder.get_object('stack') self._name_label = builder.get_object('playlist_name') self._rename_entry = builder.get_object('playlist_rename_entry') self._rename_entry.connect('changed', self._on_rename_entry_changed) self._rename_done_button = builder.get_object( 'playlist_rename_done_button') self._songs_count_label = builder.get_object('songs_count') self._menubutton = builder.get_object('playlist_menubutton') builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Music/PlaylistContextMenu.ui') self._popover_menu = builder.get_object('song_menu') self._song_popover = Gtk.Popover.new_from_model( self._view, self._popover_menu) self._song_popover.set_position(Gtk.PositionType.BOTTOM) play_song = Gio.SimpleAction.new('play_song', None) play_song.connect('activate', self._play_song) self._window.add_action(play_song) add_song_to_playlist = Gio.SimpleAction.new('add_song_to_playlist', None) add_song_to_playlist.connect('activate', self._add_song_to_playlist) self._window.add_action(add_song_to_playlist) self._remove_song_action = Gio.SimpleAction.new('remove_song', None) self._remove_song_action.connect('activate', self._stage_song_for_deletion) self._window.add_action(self._remove_song_action) playlist_play_action = Gio.SimpleAction.new('playlist_play', None) playlist_play_action.connect('activate', self._on_play_activate) self._window.add_action(playlist_play_action) self._playlist_delete_action = Gio.SimpleAction.new( 'playlist_delete', None) self._playlist_delete_action.connect('activate', self._stage_playlist_for_deletion) self._window.add_action(self._playlist_delete_action) self._playlist_rename_action = Gio.SimpleAction.new( 'playlist_rename', None) self._playlist_rename_action.connect('activate', self._stage_playlist_for_renaming) self._window.add_action(self._playlist_rename_action) self._grid.insert_row(0) self._grid.attach(headerbar, 1, 0, 1, 1) sidebar_container.set_size_request(220, -1) sidebar_container.get_style_context().add_class('side-panel') self._sidebar.get_style_context().add_class('view') self._sidebar.set_selection_mode(Gtk.SelectionMode.SINGLE) self._sidebar.connect('row-activated', self._on_playlist_activated) self._grid.insert_column(0) self._grid.child_set_property(self.stack, 'top-attach', 0) self._grid.child_set_property(self.stack, 'height', 2) self._iter_to_clean = None self._iter_to_clean_model = None self._current_playlist = None self._current_playlist_index = None self.pls_todelete = {} self._songs_todelete = {} self._songs_count = 0 self._handler_rename_done_button = 0 self._handler_rename_entry = 0 self._update_songs_count() self.model.connect('row-inserted', self._on_song_inserted) self.model.connect('row-deleted', self._on_song_deleted) self.player.connect('playlist-item-changed', self._update_model) playlists.connect('playlist-created', self._on_playlist_created) playlists.connect('playlist-updated', self._on_playlist_update) playlists.connect('song-added-to-playlist', self._on_song_added_to_playlist) playlists.connect('song-position-changed', self._on_song_position_changed) self.show_all()