def _apply_css(config): if OSDWindow.css_provider: Gtk.StyleContext.remove_provider_for_screen( Gdk.Screen.get_default(), OSDWindow.css_provider) colors = {} for x in config['osk_colors'] : colors["osk_%s" % (x,)] = config['osk_colors'][x] for x in config['osd_colors'] : colors[x] = config['osd_colors'][x] colors = OSDCssMagic(colors) try: css_file = os.path.join(get_share_path(), "osd-styles", config["osd_style"]) css = file(css_file, "r").read() if ((Gtk.get_major_version(), Gtk.get_minor_version()) > (3, 20)): css += OSDWindow.CSS_3_20 OSDWindow.css_provider = Gtk.CssProvider() OSDWindow.css_provider.load_from_data((css % colors).encode("utf-8")) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), OSDWindow.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) except GLib.Error, e: log.error("Failed to apply css with user settings:") log.error(e) log.error("Retrying with default values") OSDWindow.css_provider = Gtk.CssProvider() css_file = os.path.join(get_share_path(), "osd-styles", "Classic.gtkstyle.css") css = file(css_file, "r").read() if ((Gtk.get_major_version(), Gtk.get_minor_version()) > (3, 20)): css += OSDWindow.CSS_3_20 OSDWindow.css_provider.load_from_data((css % colors).encode("utf-8")) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), OSDWindow.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
def init(self): """ Init main application """ self.__is_fs = False if Gtk.get_minor_version() > 18: cssProviderFile = Gio.File.new_for_uri( 'resource:///org/gnome/Lollypop/application.css') else: cssProviderFile = Gio.File.new_for_uri( 'resource:///org/gnome/Lollypop/application-legacy.css') cssProvider = Gtk.CssProvider() cssProvider.load_from_file(cssProviderFile) screen = Gdk.Screen.get_default() styleContext = Gtk.StyleContext() styleContext.add_provider_for_screen(screen, cssProvider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.settings = Settings.new() self.db = Database() self.playlists = Playlists() # We store cursors for main thread SqlCursor.add(self.db) SqlCursor.add(self.playlists) self.albums = AlbumsDatabase() self.artists = ArtistsDatabase() self.genres = GenresDatabase() self.tracks = TracksDatabase() self.player = Player() self.scanner = CollectionScanner() self.art = Art() self.art.update_art_size() if self.settings.get_value('artist-artwork'): GLib.timeout_add(5000, self.art.cache_artists_info) if LastFM is not None: self.lastfm = LastFM() if not self.settings.get_value('disable-mpris'): # Ubuntu > 16.04 if Gtk.get_minor_version() > 18: from lollypop.mpris import MPRIS # Ubuntu <= 16.04, Debian Jessie, ElementaryOS else: from lollypop.mpris_legacy import MPRIS MPRIS(self) if not self.settings.get_value('disable-notifications'): from lollypop.notification import NotificationManager self.notify = NotificationManager() settings = Gtk.Settings.get_default() dark = self.settings.get_value('dark-ui') settings.set_property('gtk-application-prefer-dark-theme', dark) self.add_action(self.settings.create_action('playback')) self.add_action(self.settings.create_action('shuffle')) self.db.upgrade()
def apply_gtk_css(): gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) if Gtk.get_major_version() == 3 and Gtk.get_minor_version() == 22: print "Gtk version is " + gtk_version + ", Flowblade theme is available." else: print "Gtk version is " + gtk_version + ", Flowblade theme only available for Gtk 3.22" return provider = Gtk.CssProvider.new() display = Gdk.Display.get_default() screen = display.get_default_screen() Gtk.StyleContext.add_provider_for_screen (screen, provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) provider.load_from_path(respaths.ROOT_PATH + "/res/css/gtk-dark-fix.css")
def __init__(self, parent): self.ui = Gtk.Builder() self.ui.add_from_resource('/org/gnome/Music/PlaylistDialog.ui') self.dialog_box = self.ui.get_object('dialog1') self.dialog_box.set_transient_for(parent) self.view = self.ui.get_object('treeview1') self.selection = self.ui.get_object('treeview-selection1') self._add_list_renderers() self.view.connect('row-activated', self._on_item_activated) self.model = self.ui.get_object('liststore1') playlist_names = playlist.get_playlists() self.populate(playlist_names) self.title_bar = self.ui.get_object('headerbar1') if Gtk.get_minor_version() > 8: self.dialog_box.set_titlebar(self.title_bar) else: self.dialog_box.get_content_area().add(self.title_bar) self.dialog_box.get_content_area().reorder_child(self.title_bar, 0) self._cancel_button = self.ui.get_object('cancel-button') self._select_button = self.ui.get_object('select-button') self._cancel_button.connect('clicked', self._on_cancel_button_clicked) self._select_button.connect('clicked', self._on_selection)
def get_workarea_dimensions(window=None): """ Returns the x-offset, y-offset, width and height of the work area for a given window or for the default screen if no window is given. Falls back to the screen dimensions if not available. :param window: class: `Gtk.Window`, optional :returns: :class:`CairoRectangleInt` """ if window is None: screen = Gdk.Screen.get_default() default_monitor = screen.get_primary_monitor() return screen.get_monitor_workarea(default_monitor) elif ( Gtk.get_major_version() > 3 or Gtk.get_major_version() == 3 and Gtk.get_minor_version() >= 22 ): # Gdk.Monitor was introduced in Gtk+ 3.22 display = window.get_window().get_display() work_area = display.get_monitor_at_window(window.get_window()).get_workarea() else: screen = window.get_screen() monitor_nr = screen.get_monitor_at_window(window.get_window()) work_area = screen.get_monitor_workarea(monitor_nr) return work_area
def do_draw(self, context, background_area, cell_area, start, end, state): GtkSource.GutterRendererPixbuf.do_draw( self, context, background_area, cell_area, start, end, state) if self.is_action: if Gtk.get_minor_version() < 20: style_context = get_style(None, "GtkButton.flat.image-button") style_context.add_class(Gtk.STYLE_CLASS_BUTTON) style_context.add_class(Gtk.STYLE_CLASS_FLAT) else: # TODO: Fix padding and min-height in CSS and use # draw_style_common style_context = get_style(None, "button.flat.image-button") style_context.set_state(renderer_to_gtk_state(state)) x = background_area.x + 1 y = background_area.y + 1 width = background_area.width - 2 height = background_area.height - 2 Gtk.render_background(style_context, context, x, y, width, height) Gtk.render_frame(style_context, context, x, y, width, height) pixbuf = self.props.pixbuf pix_width, pix_height = pixbuf.props.width, pixbuf.props.height Gtk.render_icon( style_context, context, pixbuf, x + (width - pix_width) // 2, y + (height - pix_height) // 2) self.draw_chunks( context, background_area, cell_area, start, end, state)
def do_startup(self): Gtk.Application.do_startup(self) if self.purge_recent: items = recent_manager.get_items() for item in items: uri = item.get_uri() if item.get_application_info("pychess"): recent_manager.remove_item(uri) self.git_rev = "" self.initGlade(self.log_viewer) self.addPerspectives() self.handleArgs(self.chess_file) create_task(checkversion()) self.loaded_cids = {} self.saved_cids = {} self.terminated_cids = {} log.info("PyChess %s %s git %s" % (VERSION_NAME, VERSION, self.git_rev)) log.info("Command line args: '%s'" % self.chess_file) log.info("Platform: %s" % platform.platform()) log.info("Python version: %s.%s.%s" % sys.version_info[0:3]) log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version) log.info("Gtk version: %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
def __init__(self): GObject.GObject.__init__(self) self._stack_switcher = Gtk.StackSwitcher( margin_top=2, margin_bottom=2, can_focus=False, halign="center") self._stack_switcher.show() self._ui = Gtk.Builder() self._ui.add_from_resource('/org/gnome/Music/headerbar.ui') self.header_bar = self._ui.get_object('header-bar') self._search_button = self._ui.get_object('search-button') self.dropdown = DropDown() self.searchbar = Searchbar(self._stack_switcher, self._search_button, self.dropdown) self.dropdown.initialize_filters(self.searchbar) self._select_button = self._ui.get_object('select-button') self._cancel_button = self._ui.get_object('done-button') self._back_button = self._ui.get_object('back-button') self._selection_menu = self._ui.get_object('selection-menu') self._selection_menu_button = self._ui.get_object('selection-menu-button') self._selection_menu_label = self._ui.get_object('selection-menu-button-label') self._selection_menu_button.set_relief(Gtk.ReliefStyle.NONE) if Gtk.get_minor_version() >= 11: self.header_bar.remove(self._select_button) self.header_bar.remove(self._cancel_button) self.header_bar.remove(self._search_button) self.header_bar.pack_end(self._select_button) self.header_bar.pack_end(self._cancel_button) self.header_bar.pack_end(self._search_button) self._back_button.connect('clicked', self.on_back_button_clicked)
def get_libs_version_string(): """Get a string describing the versions of important libs. >>> type(get_libs_version_string()) == str True """ versions = [ ("Python", "{major}.{minor}.{micro}".format( major = sys.version_info.major, minor = sys.version_info.minor, micro = sys.version_info.micro, )), ("GTK", "{major}.{minor}.{micro}".format( major = Gtk.get_major_version(), minor = Gtk.get_minor_version(), micro = Gtk.get_micro_version(), )), ("GdkPixbuf", GdkPixbuf.PIXBUF_VERSION), ("Cairo", cairo.cairo_version_string()), # NOT cairo.version ("GLib", "{major}.{minor}.{micro}".format( major = GLib.MAJOR_VERSION, minor = GLib.MINOR_VERSION, micro = GLib.MICRO_VERSION, )), ] return ", ".join([" ".join(t) for t in versions])
def __init__(self): """ Init toolbar """ Gtk.Bin.__init__(self) InfosController.__init__(self, ArtSize.SMALL) builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Lollypop/ToolbarInfo.ui') builder.connect_signals(self) self._pop_tunein = None self._pop_info = None self._timeout_id = None self._width = 0 self._infobox = builder.get_object('info') self.add(self._infobox) self._labels = builder.get_object('nowplaying_labels') self._title_label = builder.get_object('title') self._artist_label = builder.get_object('artist') self._cover_frame = builder.get_object('frame') self._cover = builder.get_object('cover') self._cover.set_property('has-tooltip', True) # Since GTK 3.20, we can set cover full height if Gtk.get_minor_version() > 18: self._cover.get_style_context().add_class('toolbar-cover-frame') else: self._cover.get_style_context().add_class('small-cover-frame') self.connect('realize', self._on_realize) Lp().art.connect('album-artwork-changed', self._update_cover) Lp().art.connect('radio-artwork-changed', self._update_logo)
def __init__(self, show_menu, show_loved): """ Init row widget and show it @parma show menu as bool @param show loved as bool """ Row.__init__(self, show_loved) self._grid.insert_column(0) self._grid.attach(self._indicator, 0, 0, 1, 1) self.show_all() button = Gtk.Button.new_from_icon_name('open-menu-symbolic', Gtk.IconSize.MENU) button.set_relief(Gtk.ReliefStyle.NONE) button.get_style_context().add_class('menu-button') button.get_style_context().add_class('track-menu-button') button.get_image().set_opacity(0.2) self._grid.add(button) # TODO: Remove this test later if show_menu or Gtk.get_minor_version() > 16: button.show() self._show_menu = True self._row_widget.connect('button-press-event', self._on_button_press) button.connect('clicked', self._on_button_clicked) else: self._show_menu = False button.hide()
def _get_sys_information(self): """ Get relevant system information. """ if hasattr(os, "uname"): operatingsystem = os.uname()[0] distribution = os.uname()[2] else: operatingsystem = sys.platform distribution = " " return "Python version: %s \n"\ "BSDDB version: %s \n"\ "Gramps version: %s \n"\ "LANG: %s\n"\ "OS: %s\n"\ "Distribution: %s\n\n"\ "GTK version : %s\n"\ "gobject version: %s\n"\ "cairo version : %s"\ % (str(sys.version).replace('\n',''), BSDDB_STR, str(VERSION), get_env_var('LANG',''), operatingsystem, distribution, '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), '%d.%d.%d' % GObject.pygobject_version, cairo.version_info)
def do_startup(self): Gtk.Application.do_startup(self) signal.signal(signal.SIGINT, signal.SIG_DFL) action = Gio.SimpleAction.new("stations", None) action.connect("activate", self.stations_cb) self.add_action(action) action = Gio.SimpleAction.new("preferences", None) action.connect("activate", self.prefs_cb) self.add_action(action) action = Gio.SimpleAction.new("about", None) action.connect("activate", self.about_cb) self.add_action(action) action = Gio.SimpleAction.new("quit", None) action.connect("activate", self.quit_cb) self.add_action(action) if Gtk.get_major_version() > 3 or Gtk.get_minor_version() >= 20: menu = self.get_app_menu() it = menu.iterate_item_links(menu.get_n_items() - 1) assert(it.next()) last_section = it.get_value() shortcuts_item = Gio.MenuItem.new(_('Keyboard Shortcuts'), 'win.show-help-overlay') last_section.prepend_item(shortcuts_item)
def send_bugreport(self): """ Return None if successful. Return the urllib2 execption if failure. """ try: windowsversion = str(sys.getwindowsversion()) except AttributeError: windowsversion = "(not running ms windows)" buf = self.g_tw.get_buffer() description = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), False) data = urllib.urlencode({ 'email': self.g_email.get_text(), 'version': buildinfo.VERSION_STRING, 'revision_id': buildinfo.REVISION_ID, #'pygtk_version': "pygi", 'gtk': "(%s.%s.%s)" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), 'sys.version': sys.version, 'sys.platform': sys.platform, 'windowsversion': windowsversion, 'short_description': self.g_description.get_text(), 'description': description, 'traceback': self.m_error_text, }) try: urllib2.urlopen("http://www.solfege.org/crashreport/", data) except urllib2.HTTPError, e: print "HTTPError:", e
def check_gtk_version(): """ Check GTK version """ # Check desired GTK Version major_needed = int(GTK_VERSION_NEEDED.split(".")[0]) minor_needed = int(GTK_VERSION_NEEDED.split(".")[1]) micro_needed = int(GTK_VERSION_NEEDED.split(".")[2]) # Check system GTK Version major = Gtk.get_major_version() minor = Gtk.get_minor_version() micro = Gtk.get_micro_version() # Cnchi will be called from our liveCD that already # has the latest GTK version. This is here just to # help testing Cnchi in our environment. wrong_gtk_version = False if major_needed > major: wrong_gtk_version = True if major_needed == major and minor_needed > minor: wrong_gtk_version = True if major_needed == major and minor_needed == minor and micro_needed > micro: wrong_gtk_version = True if wrong_gtk_version: text = "Detected GTK version {0}.{1}.{2} but version>={3} is needed." text = text.format(major, minor, micro, GTK_VERSION_NEEDED) logging.info(text) return False else: logging.info("Using GTK v{0}.{1}.{2}".format(major, minor, micro)) return True
def _get_sys_information(self): """ Get relevant system information. """ distribution = "" # print nothing if there's nothing to print if hasattr(os, "uname"): distribution = "Distribution: %s\n" % os.uname()[2] sqlite = "sqlite version: %s (%s) \n" % (sqlite3_version_str, sqlite3_py_version_str) return "Gramps version: %s \n"\ "Python version: %s \n"\ "BSDDB version: %s \n"\ "%s"\ "LANG: %s\n"\ "OS: %s\n"\ "%s\n"\ "GTK version : %s\n"\ "gobject version: %s\n"\ "cairo version : %s"\ % (str(VERSION), str(sys.version).replace('\n',''), BSDDB_STR, sqlite, get_env_var('LANG',''), platform.system(), distribution, '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), '%d.%d.%d' % GObject.pygobject_version, cairo.version_info)
def prepare_content_display(item, textview=None): if textview is None: text_view = Gtk.TextView() else: text_view = textview text_view.set_name('storyview') # For CSS # Border sizes if Gtk.get_major_version() == 3 and Gtk.get_minor_version() >= 20: text_view.set_left_margin(12) text_view.set_right_margin(12) text_view.set_bottom_margin(5) text_view.set_top_margin(5) else: text_view.set_border_window_size(Gtk.TextWindowType.LEFT, 10) text_view.set_border_window_size(Gtk.TextWindowType.RIGHT, 12) # Slightly more than left due to scroll bar text_view.set_border_window_size(Gtk.TextWindowType.TOP, 5) text_view.set_border_window_size(Gtk.TextWindowType.TOP, 5) text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR) text_view.set_editable(False) text_view.set_cursor_visible(False) text_buffer = Gtk.TextBuffer() text_view.set_buffer(text_buffer) if item: TextFormat.headline(item.title, text_buffer) TextFormat.description(item.description, text_buffer) TextFormat.article(item.article, text_buffer) return text_view
def _build_app_menu(self): builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Lollypop/app-menu.ui') menu = builder.get_object('app-menu') self.set_app_menu(menu) #TODO: Remove this test later if Gtk.get_minor_version() > 12: settingsAction = Gio.SimpleAction.new('settings', None) settingsAction.connect('activate', self._edit_settings) self.add_action(settingsAction) partyAction = Gio.SimpleAction.new('party', None) partyAction.connect('activate', self._edit_party) self.add_action(partyAction) updateAction = Gio.SimpleAction.new('update_db', None) updateAction.connect('activate', self._update_db) self.add_action(updateAction) aboutAction = Gio.SimpleAction.new('about', None) aboutAction.connect('activate', self._about) self.add_action(aboutAction) quitAction = Gio.SimpleAction.new('quit', None) quitAction.connect('activate', self.quit) self.add_action(quitAction)
def main(): """ Main function that starts everything """ if is_wayland() and gdk_backend().lower() != 'x11' and not is_wayland_compatibility_on(): warn = """ [!] Looks like you are in Wayland session Please run Ulauncher with env var GDK_BACKEND set to 'x11' like this: GDK_BACKEND=x11 ulauncher """ print(warn, file=sys.stderr) sys.exit(1) # start DBus loop DBusGMainLoop(set_as_default=True) bus = dbus.SessionBus() instance = bus.request_name(DBUS_SERVICE) if instance != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER: toggle_window = dbus.SessionBus().get_object(DBUS_SERVICE, DBUS_PATH).get_dbus_method("toggle_window") toggle_window() return _create_dirs() options = get_options() setup_logging(options) logger = logging.getLogger('ulauncher') logger.info('Ulauncher version %s' % get_version()) logger.info("GTK+ %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())) logger.info("Is Wayland: %s" % is_wayland()) logger.info("Wayland compatibility: %s" % ('on' if is_wayland_compatibility_on() else 'off')) # log uncaught exceptions def except_hook(exctype, value, tb): logger.error("Uncaught exception", exc_info=(exctype, value, tb)) sys.excepthook = except_hook window = UlauncherWindow.get_instance() UlauncherDbusService(window) if not options.hide_window: window.show() if Settings.get_instance().get_property('show-indicator-icon'): AppIndicator.get_instance().show() # workaround to make Ctrl+C quiting the app signal_handler = SignalHandler(window) gtk_thread = run_async(Gtk.main)() try: while gtk_thread.is_alive() and not signal_handler.killed(): time.sleep(0.5) except KeyboardInterrupt: logger.warn('On KeyboardInterrupt') finally: Gtk.main_quit()
def _init_window(self): Gtk.Window.__init__(self, title="Oo-mox GUI") self.set_default_size(500, 300) self.set_border_width(6) win_style_context = self.get_style_context() css_provider = Gtk.CssProvider() try: if Gtk.get_minor_version() == 20: css_provider.load_from_path( os.path.join(script_dir, "theme20.css") ) else: css_provider.load_from_path( os.path.join(script_dir, "theme.css") ) except GLib.Error as e: print(e) screen = Gdk.Screen.get_default() win_style_context.add_provider_for_screen( screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) self._init_headerbar() self.box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6) self.add(self.box)
def _setup_app_menu(self): builder = Gtk.Builder() builder.add_from_resource('/org/gnome/Lollypop/app-menu.ui') menu = builder.get_object('app-menu') # TODO: Remove this test later if Gtk.get_minor_version() > 12: settingsAction = Gio.SimpleAction.new('settings', None) settingsAction.connect('activate', self._settings_dialog) self.add_action(settingsAction) updateAction = Gio.SimpleAction.new('update_db', None) updateAction.connect('activate', self._update_db) self.add_action(updateAction) fsAction = Gio.SimpleAction.new('fullscreen', None) fsAction.connect('activate', self._fullscreen) self.add_action(fsAction) aboutAction = Gio.SimpleAction.new('about', None) aboutAction.connect('activate', self._about) self.add_action(aboutAction) quitAction = Gio.SimpleAction.new('quit', None) quitAction.connect('activate', self.quit) self.add_action(quitAction) return menu
def _on_row_activated(self, widget, row): """ Play searched item when selected @param widget as Gtk.ListBox @param row as SearchRow """ if Lp().player.is_party() or Lp().player.locked or Lp().player.queued: if row.is_track(): if Lp().player.locked or Lp().player.queued: if row.get_id() in Lp().player.get_queue(): Lp().player.del_from_queue(row.get_id()) else: Lp().player.append_to_queue(row.get_id()) row.destroy() else: Lp().player.load(Track(row.get_id())) elif Gtk.get_minor_version() > 16: popover = AlbumPopover(row.get_id(), [], []) popover.set_relative_to(row) popover.show() else: t = Thread(target=self._play_search, args=(row.get_id(), row.is_track())) t.daemon = True t.start() else: t = Thread(target=self._play_search, args=(row.get_id(), row.is_track())) t.daemon = True t.start()
def update_preview_carets(self, colorscheme): css_provider_caret = Gtk.CssProvider() css_provider_caret.load_from_data(( (Gtk.get_minor_version() >= 20 and """ * {{ caret-color: #{primary_caret_color}; -gtk-secondary-caret-color: #{secondary_caret_color}; -GtkWidget-cursor-aspect-ratio: {caret_aspect_ratio}; }} """ or """ * {{ -GtkWidget-cursor-color: #{primary_caret_color}; -GtkWidget-secondary-cursor-color: #{secondary_caret_color}; -GtkWidget-cursor-aspect-ratio: {caret_aspect_ratio}; }} """).format( primary_caret_color=colorscheme['CARET1_FG'], secondary_caret_color=colorscheme['CARET2_FG'], caret_aspect_ratio=colorscheme['CARET_SIZE'] ) ).encode('ascii')) Gtk.StyleContext.add_provider( self.entry.get_style_context(), css_provider_caret, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION )
def _override_css_style(self): css_provider = Gtk.CssProvider() try: if Gtk.get_minor_version() >= 20: css_provider.load_from_path( os.path.join(script_dir, "theme20.css") ) else: css_provider.load_from_path( os.path.join(script_dir, "theme.css") ) except GLib.Error as e: print(e) for widget in [ self, self.label, self.sel_label, self.entry, self.button, self.headerbar, self.headerbar_button ] + self.get_menu_widgets(self.menubar): Gtk.StyleContext.add_provider( widget.get_style_context(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION )
def get_link_at_location(self, view, x, y): """ Get the link under a specified x,y coordinate. If no link exists then None is returned. """ # get the offset within the buffer from the x,y coordinates buff_x, buff_y = view.window_to_buffer_coords(Gtk.TextWindowType.TEXT, x, y) # usual API breakage in GTK+3, nothing new... # see https://bugzilla.gnome.org/768793 if Gtk.get_minor_version() >= 20: (over_text, iter_at_xy) = view.get_iter_at_location(buff_x, buff_y) if not over_text: return None else: iter_at_xy = view.get_iter_at_location(buff_x, buff_y) offset = iter_at_xy.get_offset() # find the first link that contains the offset for lnk in self.links: if offset >= lnk.start and offset <= lnk.end: return lnk # no link was found at x,y return None
def gtk_version(): ''' returns float of the major and minor parts of the GTK version e.g. return float(3.10) ''' return float(str(Gtk.get_major_version()) + "." + str(Gtk.get_minor_version()))
def __init__(self): GObject.GObject.__init__(self) self._stack_switcher = Gtk.StackSwitcher(margin_top=2, margin_bottom=2, can_focus=False) self._stack_switcher.show() self._ui = Gtk.Builder() self._ui.add_from_resource('/org/gnome/Music/headerbar.ui') self.header_bar = self._ui.get_object('header-bar') self._search_button = self._ui.get_object('search-button') self.searchbar = Searchbar(self._stack_switcher, self._search_button) self._select_button = self._ui.get_object('select-button') self._cancel_button = self._ui.get_object('done-button') self._back_button = self._ui.get_object('back-button') self._selection_menu = self._ui.get_object('selection-menu') self._selection_menu_button = self._ui.get_object('selection-menu-button') self._selection_menu_label = self._ui.get_object('selection-menu-button-label') self._selection_menu_button.set_relief(Gtk.ReliefStyle.NONE) if Gtk.Widget.get_default_direction() is Gtk.TextDirection.RTL: _back_button_image = self._ui.get_object('back-button-image') _back_button_image.set_property('icon-name', 'go-previous-rtl-symbolic') if Gtk.get_minor_version() >= 11: self.header_bar.remove(self._select_button) self.header_bar.remove(self._cancel_button) self.header_bar.remove(self._search_button) self.header_bar.pack_end(self._select_button) self.header_bar.pack_end(self._cancel_button) self.header_bar.pack_end(self._search_button) self._back_button.connect('clicked', self.on_back_button_clicked)
def undock(self, widget): """ remove the widget from the leaf-notebook if this was the only widget, remove this leaf from its owner """ gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version()) if gtk_version >= (3, 16): self.book.detach_tab(widget) else: # To not destroy accidentally our panel widget we need to add a reference to it # https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/Container.html#Gtk.Container.remove widget._ref() self.book.remove(widget) for i, (widget_, title, id) in enumerate(self.panels): if widget_ == widget: break else: raise KeyError("No %s in %s" % (widget, self)) del self.panels[i] if self.book.get_n_pages() == 0: parent = self.get_parent() while not isinstance(parent, PyDockComposite): parent = parent.get_parent() parent.removeComponent(self) self._del() return title, id
def shortcuts_dialog(): if Gtk.get_major_version() >= 3 and Gtk.get_minor_version() >= 20: builder = Gtk.Builder() builder.add_from_resource('/org/gnome/TwoFactorAuth/shortcuts.ui') shortcuts = builder.get_object("shortcuts") return shortcuts return None
def dark_mode_toggled(self, widget, data=None): if widget.get_active(): # Dark Mode is on # Hack for f*****g unico-shit if Gtk.get_minor_version() == 4: css = open(helpers.get_media_path('style_dark_old.css'), 'rb') else: css = open(helpers.get_media_path('style_dark.css'), 'rb') css_data = css.read() css.close() self.style_provider.load_from_data(css_data) self.background_image = helpers.get_media_path('bg_dark.png') self.MarkupBuffer.dark_mode(True) else: # Dark mode off css = open(helpers.get_media_path('style.css'), 'rb') css_data = css.read() css.close() self.style_provider.load_from_data(css_data) self.background_image = helpers.get_media_path('bg_light.png') self.MarkupBuffer.dark_mode(False) surface = cairo.ImageSurface.create_from_png(self.background_image) self.background_pattern = cairo.SurfacePattern(surface) self.background_pattern.set_extend(cairo.EXTEND_REPEAT) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER ) (w, h) = self.get_size() self.resize(w+1, h+1)
def on_dbus_name_appeared(_connection, name, owner): logging.info("%s %s" % (name, owner)) setup_icon_path() try: self.Applet = AppletService() except DBusProxyFailed: print("Blueman applet needs to be running") exit() check_bluetooth_status( _("Bluetooth needs to be turned on for the device manager to function" ), lambda: Gtk.main_quit()) manager = Manager() try: manager.get_adapter(self.Config['last-adapter']) except DBusNoSuchAdapterError: logging.error( 'Default adapter not found, trying first available.') try: manager.get_adapter(None) except DBusNoSuchAdapterError: logging.error('No adapter(s) found, exiting') exit(1) self.Applet.connect('g-signal', on_applet_signal) self.connect("delete-event", on_window_delete) self.props.icon_name = "blueman" w, h, x, y = self.Config["window-properties"] if w and h: self.resize(w, h) if x and y: self.move(x, y) sw = self.Builder.get_object("scrollview") # Disable overlay scrolling if Gtk.get_minor_version() >= 16: sw.props.overlay_scrolling = False self.List = ManagerDeviceList(adapter=self.Config["last-adapter"], inst=self) self.List.show() sw.add(self.List) self.Toolbar = ManagerToolbar(self) self.Menu = ManagerMenu(self) self.Stats = ManagerStats(self) if self.List.is_valid_adapter(): self.List.display_known_devices(autoselect=True) self.List.connect("adapter-changed", self.on_adapter_changed) toolbar = self.Builder.get_object("toolbar") statusbar = self.Builder.get_object("statusbar") self.Config.bind_to_widget("show-toolbar", toolbar, "visible") self.Config.bind_to_widget("show-statusbar", statusbar, "visible") self.show()
def have_gtk_version(version_string): [major, minor, micro] = version_string.split(".", 3) return Gtk.get_major_version() >= eval(major) and \ Gtk.get_minor_version() >= eval(minor) and \ Gtk.get_micro_version() >= eval(micro)
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 self.__duration_label = builder.get_object('duration') self.__set_duration() 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')
from matplotlib._pylab_helpers import Gcf from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \ FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase from matplotlib.backend_bases import ShowBase from matplotlib.cbook import is_string_like, is_writable_file_like from matplotlib.colors import colorConverter from matplotlib.figure import Figure from matplotlib.widgets import SubplotTool from matplotlib import lines from matplotlib import cbook from matplotlib import verbose from matplotlib import rcParams backend_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version()) _debug = False #_debug = True # the true dots per inch on the screen; should be display dependent # see http://groups.google.com/groups?q=screen+dpi+x11&hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=7077.26e81ad5%40swift.cs.tcd.ie&rnum=5 for some info about screen dpi PIXELS_PER_INCH = 96 cursord = { cursors.MOVE : Gdk.Cursor.new(Gdk.CursorType.FLEUR), cursors.HAND : Gdk.Cursor.new(Gdk.CursorType.HAND2), cursors.POINTER : Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR), cursors.SELECT_REGION : Gdk.Cursor.new(Gdk.CursorType.TCROSS), }
def reconfigure(self): """Update configuration for the whole application""" if self.style_providers: for style_provider in self.style_providers: Gtk.StyleContext.remove_provider_for_screen( Gdk.Screen.get_default(), style_provider) self.style_providers = [] # Force the window background to be transparent for newer versions of # GTK3. We then have to fix all the widget backgrounds because the # widgets theming may not render it's own background. css = """ .terminator-terminal-window { background-color: alpha(@theme_bg_color,0); } .terminator-terminal-window .notebook.header, .terminator-terminal-window notebook header { background-color: @theme_bg_color; } .terminator-terminal-window .pane-separator { background-color: @theme_bg_color; } .terminator-terminal-window .terminator-terminal-searchbar { background-color: @theme_bg_color; } """ # Fix several themes that put a borders, corners, or backgrounds around # viewports, making the titlebar look bad. css += """ .terminator-terminal-window GtkViewport, .terminator-terminal-window viewport { border-width: 0px; border-radius: 0px; background-color: transparent; } """ # Add per profile snippets for setting the background of the HBox template = """ .terminator-profile-%s { background-color: alpha(%s, %s); } """ profiles = self.config.base.profiles bgcolor = None for profile in profiles.keys(): if not profiles[profile]['use_theme_colors']: bgcolor = profiles[profile]['background_color'] if profiles[profile]['background_type'] == 'transparent': bgalpha = profiles[profile]['background_darkness'] else: bgalpha = '1' munged_profile = ''.join( [c if c.isalnum() else '-' for c in profile]) css += template % (munged_profile, bgcolor, bgalpha) style_provider = Gtk.CssProvider() style_provider.load_from_data(css.encode('utf8')) self.style_providers.append(style_provider) # Attempt to load some theme specific stylistic tweaks for appearances usr_theme_dir = os.path.join(os.getenv('XDG_DATA_HOME'), 'themes') (head, _tail) = os.path.split(borg.__file__) app_theme_dir = os.path.join(head, 'themes') theme_name = self.gtk_settings.get_property('gtk-theme-name') theme_part_list = ['terminator.css'] if self.config[ 'extra_styling']: # checkbox_style - needs adding to prefs theme_part_list.append('terminator_styling.css') for theme_part_file in theme_part_list: for theme_dir in [usr_theme_dir, app_theme_dir]: path_to_theme_specific_css = os.path.join( theme_dir, theme_name, 'gtk-3.0/apps', theme_part_file) if os.path.isfile(path_to_theme_specific_css): style_provider = Gtk.CssProvider() style_provider.connect('parsing-error', self.on_css_parsing_error) try: style_provider.load_from_path( path_to_theme_specific_css) except GError: # Hmmm. Should we try to provide GTK version specific files here on failure? gtk_version_string = '.'.join([ str(Gtk.get_major_version()), str(Gtk.get_minor_version()), str(Gtk.get_micro_version()) ]) err(f'Error(s) loading css from {path_to_theme_specific_css} into Gtk {gtk_version_string}' ) self.style_providers.append(style_provider) break # Size the GtkPaned splitter handle size. if self.config['handle_size'] in range(0, 21): hsize = self.config['handle_size'] css = f'''.terminator-terminal-window GtkPaned, .terminator-terminal-window paned {{min-width: {hsize}px;min-height: {hsize}px;}}''' style_provider = Gtk.CssProvider() style_provider.load_from_data(css.encode()) self.style_providers.append(style_provider) # Apply the providers, incrementing priority so they don't cancel out # each other for idx in range(0, len(self.style_providers)): Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_providers[idx], Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION + idx) # Cause all the terminals to reconfigure for terminal in self.terminals: terminal.reconfigure() # Reparse our keybindings self.keybindings.configure(self.config['keybindings']) # Update tab position if appropriate maker = Factory() for window in self.windows: child = window.get_child() if maker.isinstance(child, 'Notebook'): child.configure()
try: # :raises ValueError: If module/version is already loaded, already # required, or unavailable. gi.require_version("Gtk", "3.0") except ValueError as e: # in this case we want to re-raise as ImportError so the # auto-backend selection logic correctly skips. raise ImportError from e from gi.repository import GLib, GObject, Gtk, Gdk _log = logging.getLogger(__name__) backend_version = "%s.%s.%s" % ( Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version()) try: cursord = { cursors.MOVE: Gdk.Cursor.new(Gdk.CursorType.FLEUR), cursors.HAND: Gdk.Cursor.new(Gdk.CursorType.HAND2), cursors.POINTER: Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR), cursors.SELECT_REGION: Gdk.Cursor.new(Gdk.CursorType.TCROSS), cursors.WAIT: Gdk.Cursor.new(Gdk.CursorType.WATCH), } except TypeError as exc: # Happens when running headless. Convert to ImportError to cooperate with # backend switching. raise ImportError(exc)
def show_settings(): """ Shows settings of all of the major components. """ py_str = '%d.%d.%d' % sys.version_info[:3] try: import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk try: gtkver_str = '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) except: # any failure to 'get' the version gtkver_str = 'unknown version' except (ImportError, ValueError): gtkver_str = 'not found' # no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14) except RuntimeError: gtkver_str = 'DISPLAY not set' # exept TypeError: To handle back formatting on version split try: from gi.repository import GObject try: pygobjectver_str = '%d.%d.%d' % GObject.pygobject_version except: # any failure to 'get' the version pygobjectver_str = 'unknown version' except ImportError: pygobjectver_str = 'not found' try: from gi.repository import Pango try: pangover_str = Pango.version_string() except: # any failure to 'get' the version pangover_str = 'unknown version' except ImportError: pangover_str = 'not found' try: import cairo try: pycairover_str = '%d.%d.%d' % cairo.version_info cairover_str = cairo.cairo_version_string() except: # any failure to 'get' the version pycairover_str = 'unknown version' cairover_str = 'unknown version' except ImportError: pycairover_str = 'not found' cairover_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("OsmGpsMap"): import gi gi.require_version('OsmGpsMap', '1.0') from gi.repository import OsmGpsMap as osmgpsmap try: osmgpsmap_str = osmgpsmap._version except: # any failure to 'get' the version osmgpsmap_str = 'unknown version' else: osmgpsmap_str = 'not found' except ImportError: osmgpsmap_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("GExiv2"): import gi gi.require_version('GExiv2', '0.10') from gi.repository import GExiv2 try: gexiv2_str = GExiv2._version except: # any failure to 'get' the version gexiv2_str = 'unknown version' else: gexiv2_str = 'not found' except ImportError: gexiv2_str = 'not found' except ValueError: gexiv2_str = 'not new enough' try: import PyICU try: pyicu_str = PyICU.VERSION icu_str = PyICU.ICU_VERSION except: # any failure to 'get' the version pyicu_str = 'unknown version' icu_str = 'unknown version' except ImportError: pyicu_str = 'not found' icu_str = 'not found' try: import bsddb3 as bsddb bsddb_str = bsddb.__version__ bsddb_db_str = str(bsddb.db.version()).replace(', ', '.')\ .replace('(', '').replace(')', '') bsddb_location_str = bsddb.__file__ except: bsddb_str = 'not found' bsddb_db_str = 'not found' bsddb_location_str = 'not found' try: import sqlite3 sqlite3_py_version_str = sqlite3.version sqlite3_version_str = sqlite3.sqlite_version sqlite3_location_str = sqlite3.__file__ except: sqlite3_version_str = 'not found' sqlite3_py_version_str = 'not found' sqlite3_location_str = 'not found' try: from .gen.const import VERSION gramps_str = VERSION except: gramps_str = 'not found' if hasattr(os, "uname"): kernel = os.uname()[2] else: kernel = None lang_str = get_env_var('LANG', 'not set') language_str = get_env_var('LANGUAGE', 'not set') grampsi18n_str = get_env_var('GRAMPSI18N', 'not set') grampshome_str = get_env_var('GRAMPSHOME', 'not set') grampsdir_str = get_env_var('GRAMPSDIR', 'not set') gramps_resources_str = get_env_var('GRAMPS_RESOURCES', 'not set') try: dotversion_str = Popen(['dot', '-V'], stderr=PIPE).communicate(input=None)[1] if isinstance(dotversion_str, bytes) and sys.stdin.encoding: dotversion_str = dotversion_str.decode(sys.stdin.encoding) if dotversion_str: dotversion_str = dotversion_str.replace('\n', '')[23:27] except: dotversion_str = 'Graphviz not in system PATH' try: if win(): try: gsversion_str = Popen(['gswin32c', '--version'], stdout=PIPE).communicate(input=None)[0] except: gsversion_str = Popen(['gswin64c', '--version'], stdout=PIPE).communicate(input=None)[0] else: gsversion_str = Popen(['gs', '--version'], stdout=PIPE).communicate(input=None)[0] if isinstance(gsversion_str, bytes) and sys.stdin.encoding: gsversion_str = gsversion_str.decode(sys.stdin.encoding) if gsversion_str: gsversion_str = gsversion_str.replace('\n', '') except: gsversion_str = 'Ghostscript not in system PATH' os_path = get_env_var('PATH', 'not set') os_path = os_path.split(os.pathsep) print("Gramps Settings:") print("----------------") print(' python : %s' % py_str) print(' gramps : %s' % gramps_str) print(' gtk++ : %s' % gtkver_str) print(' pygobject : %s' % pygobjectver_str) print(' pango : %s' % pangover_str) print(' cairo : %s' % cairover_str) print(' pycairo : %s' % pycairover_str) print(' osmgpsmap : %s' % osmgpsmap_str) print(' GExiv2 : %s' % gexiv2_str) print(' ICU : %s' % icu_str) print(' PyICU : %s' % pyicu_str) print(' o.s. : %s' % sys.platform) if kernel: print(' kernel : %s' % kernel) print('') print("Environment settings:") print("---------------------") print(' LANG : %s' % lang_str) print(' LANGUAGE : %s' % language_str) print(' GRAMPSI18N: %s' % grampsi18n_str) print(' GRAMPSHOME: %s' % grampshome_str) print(' GRAMPSDIR : %s' % grampsdir_str) if __debug__: print(' GRAMPS_RESOURCES : %s' % gramps_resources_str) print(' PYTHONPATH:') for folder in sys.path: print(" ", folder) print('') print("Non-python dependencies:") print("------------------------") print(' Graphviz : %s' % dotversion_str) print(' Ghostscr. : %s' % gsversion_str) print('') print("System PATH env variable:") print("-------------------------") for folder in os_path: print(" ", folder) print('') print("Databases:") print("-------------------------") print(' bsddb :') print(' version : %s' % bsddb_str) print(' db version : %s' % bsddb_db_str) print(' location : %s' % bsddb_location_str) print(' sqlite3 :') print(' version : %s' % sqlite3_version_str) print(' py version : %s' % sqlite3_py_version_str) print(' location : %s' % sqlite3_location_str) print('')
def close(self, object=None): if Gtk.get_minor_version() < 22: self.popover.hide() else: self.popover.popdown()
def __init_window(self): """ Add fields for all ui objects we need to access from code. Initialize everything we can't do from glade like events and other stuff. """ log.info("Initialize main window") self.window = self.window_builder.get_object("app_window") self.window.set_default_size(1100, 700) self.window.set_application(self.app) self.window.show_all() self.window.present() self.window.connect("delete-event", self.on_close) self.window.connect("drag_data_received", self.__on_drag_data_received) self.window.drag_dest_set( Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY) # resizing the progress bar for older gtk versions if not Gtk.get_minor_version() > 18: self.window.connect("check-resize", self.__window_resized) self.author_box = self.window_builder.get_object("author_box") self.reader_box = self.window_builder.get_object("reader_box") self.book_box = self.window_builder.get_object("book_box") self.book_scroller = self.window_builder.get_object("book_scroller") self.sort_stack = self.window_builder.get_object("sort_stack") self.sort_box = self.window_builder.get_object("sort_box") self.import_box = self.window_builder.get_object("import_box") self.position_box = self.window_builder.get_object("position_box") self.main_stack = self.window_builder.get_object("main_stack") self.author_toggle_button = self.window_builder.get_object( "author_toggle_button") self.reader_toggle_button = self.window_builder.get_object( "reader_toggle_button") self.no_media_file_chooser = self.window_builder.get_object( "no_media_file_chooser") self.no_media_file_chooser.connect("file-set", self.__on_no_media_folder_changed) self.auto_scan_switch = self.window_builder.get_object( "auto_scan_switch") # get about dialog self.about_dialog = self.about_builder.get_object("about_dialog") self.about_dialog.set_transient_for(self.window) self.about_dialog.connect("delete-event", self.hide_window) self.about_dialog.set_version(self.version) # shortcuts self.accel = Gtk.AccelGroup() # sorting and filtering self.author_box.connect("row-activated", self.__on_listbox_changed) self.reader_box.connect("row-activated", self.__on_listbox_changed) self.book_box.set_sort_func(self.__sort_books, None, False) self.book_box.set_filter_func(self.__filter_books, None, False) self.book_box.connect("selected-children-changed", self.__on_book_selec_changed) # button actions self.author_toggle_button.connect("toggled", self.__toggle_author) self.reader_toggle_button.connect("toggled", self.__toggle_reader) try: about_close_button = self.about_builder.get_object( "button_box").get_children()[2] if about_close_button is not None: about_close_button.connect("clicked", self.__about_close_clicked) except Exception as e: log.info("Not connecting about close button.") player.add_player_listener(self.__player_changed)
def get_backend_name(): """The GDK backend name""" display = Gdk.Display.get_default() if display is not None: name = display.__gtype__.name if name.startswith("Gdk"): name = name[3:] if name.endswith("Display"): name = name[:-7] return name return u"Unknown" gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) pygobject_version = gi.version_info def io_add_watch(fd, prio, condition, func, *args, **kwargs): try: # The new gir bindings don't fail with an invalid fd, # and we can't do the same with the static ones (return a valid # source ID..) so fail with newer pygobject as well. if isinstance(fd, int) and fd < 0: raise ValueError("invalid fd") elif hasattr(fd, "fileno") and fd.fileno() < 0: raise ValueError("invalid fd") return GLib.io_add_watch(fd, prio, condition, func, *args, **kwargs)
everyThing = [] everyThing.sort() count = 0 for theFile in everyThing: fileName , extension = os.path.splitext(theFile) extension = extension.lower() if True: count += 1 iterFiles = liststoreFiles.append() liststoreFiles.set(iterFiles, 0, theFile) treeviewcolumnFilename = self.builder.get_object('treeviewcolumnFilename') treeviewcolumnFilename.set_title('Files ({})'.format(count)) if __name__ == '__main__': # An initial message. print('Operating System is "{}". Desktop is "{}".'.format(platform.system(), os.environ.get('DESKTOP_SESSION'))) print('GTK+ Version {}.{}.{} (expecting GTK+3).'.format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())) # Main GTK loop. mainWindow = MainWindow(args) mainWindow.window.show_all() Gtk.main() # A final message print('Goodbye from the \033[1;31mGTK+ Treeview Test\033[0;m program.')
def __init__(self, album_id, genre_id, pop_allowed, size_group): """ Init detailed album widget @param album id as int @param genre id as int @param parent width as int @param pop_allowed as bool if widget can show popovers @param size group as Gtk.SizeGroup """ Gtk.Bin.__init__(self) AlbumWidget.__init__(self, album_id, genre_id=genre_id) self._pop_allowed = pop_allowed 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') label = builder.get_object('duration') duration = Lp().albums.get_duration(album_id, genre_id) 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(pop_allowed, True) self._tracks_right[index] = TracksWidget(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 pop_allowed or Gtk.get_minor_version() > 16: self._menu = builder.get_object('menu') self._menu.connect('clicked', self._pop_menu) self._menu.show()
def reconfigure(self): """Update configuration for the whole application""" if self.style_providers != []: for style_provider in self.style_providers: Gtk.StyleContext.remove_provider_for_screen( Gdk.Screen.get_default(), style_provider) self.style_providers = [] # Force the window background to be transparent for newer versions of # GTK3. We then have to fix all the widget backgrounds because the # widgets theming may not render it's own background. css = """ .terminator-terminal-window { background-color: alpha(@theme_bg_color,0); } .terminator-terminal-window .notebook.header, .terminator-terminal-window notebook header { background-color: @theme_bg_color; } .terminator-terminal-window .pane-separator { background-color: @theme_bg_color; } .terminator-terminal-window .terminator-terminal-searchbar { background-color: @theme_bg_color; } """ # Fix several themes that put a borders, corners, or backgrounds around # viewports, making the titlebar look bad. css += """ .terminator-terminal-window GtkViewport, .terminator-terminal-window viewport { border-width: 0px; border-radius: 0px; background-color: transparent; } """ # Add per profile snippets for setting the background of the HBox template = """ .terminator-profile-%s { background-color: alpha(%s, %s); } """ profiles = self.config.base.profiles for profile in profiles.keys(): if profiles[profile]['use_theme_colors']: # Create a dummy window/vte and realise it so it has correct # values to read from tmp_win = Gtk.Window() tmp_vte = Vte.Terminal() tmp_win.add(tmp_vte) tmp_win.realize() bgcolor = tmp_vte.get_style_context().get_background_color( Gtk.StateType.NORMAL) bgcolor = "#{0:02x}{1:02x}{2:02x}".format( int(bgcolor.red * 255), int(bgcolor.green * 255), int(bgcolor.blue * 255)) tmp_win.remove(tmp_vte) del (tmp_vte) del (tmp_win) else: bgcolor = Gdk.RGBA() bgcolor = profiles[profile]['background_color'] if profiles[profile]['background_type'] == 'transparent': bgalpha = profiles[profile]['background_darkness'] else: bgalpha = "1" munged_profile = "".join( [c if c.isalnum() else "-" for c in profile]) css += template % (munged_profile, bgcolor, bgalpha) style_provider = Gtk.CssProvider() style_provider.load_from_data(css) self.style_providers.append(style_provider) # Attempt to load some theme specific stylistic tweaks for appearances usr_theme_dir = os.path.expanduser('~/.local/share/themes') (head, _tail) = os.path.split(borg.__file__) app_theme_dir = os.path.join(head, 'themes') theme_name = self.gtk_settings.get_property('gtk-theme-name') theme_part_list = ['terminator.css'] if self.config[ 'extra_styling']: # checkbox_style - needs adding to prefs theme_part_list.append('terminator_styling.css') for theme_part_file in theme_part_list: for theme_dir in [usr_theme_dir, app_theme_dir]: path_to_theme_specific_css = os.path.join( theme_dir, theme_name, 'gtk-3.0/apps', theme_part_file) if os.path.isfile(path_to_theme_specific_css): style_provider = Gtk.CssProvider() style_provider.connect('parsing-error', self.on_css_parsing_error) try: style_provider.load_from_path( path_to_theme_specific_css) except GError: # Hmmm. Should we try to provide GTK version specific files here on failure? gtk_version_string = '.'.join([ str(Gtk.get_major_version()), str(Gtk.get_minor_version()), str(Gtk.get_micro_version()) ]) err('Error(s) loading css from %s into Gtk %s' % (path_to_theme_specific_css, gtk_version_string)) self.style_providers.append(style_provider) break # Size the GtkPaned splitter handle size. css = "" if self.config['handle_size'] in xrange(0, 21): css += """ .terminator-terminal-window GtkPaned, .terminator-terminal-window paned { -GtkPaned-handle-size: %s; } """ % self.config['handle_size'] style_provider = Gtk.CssProvider() style_provider.load_from_data(css) self.style_providers.append(style_provider) # Apply the providers, incrementing priority so they don't cancel out # each other for idx in xrange(0, len(self.style_providers)): Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), self.style_providers[idx], Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION + idx) # Cause all the terminals to reconfigure for terminal in self.terminals: terminal.reconfigure() # Reparse our keybindings self.keybindings.configure(self.config['keybindings']) # Update tab position if appropriate maker = Factory() for window in self.windows: child = window.get_child() if maker.isinstance(child, 'Notebook'): child.configure()
def main(root_path): """ Called at application start. Initializes application with a default project. """ # DEBUG: Direct output to log file if log file set if _log_file != None: log_print_output_to_file() print "Application version: " + editorstate.appversion # Print OS, Python version and GTK+ version try: os_release_file = open("/etc/os-release", "r") os_text = os_release_file.read() s_index = os_text.find("PRETTY_NAME=") e_index = os_text.find("\n", s_index) print "OS: " + os_text[s_index + 13:e_index - 1] except: pass print "Python", sys.version gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) print "GTK+ version:", gtk_version editorstate.gtk_version = gtk_version try: editorstate.mlt_version = mlt.LIBMLT_VERSION except: editorstate.mlt_version = "0.0.99" # magic string for "not found" #print "SDL version:", str(editorstate.get_sdl_version()) # passing -xdg as a flag will change the user_dir location with XDG_CONFIG_HOME # For full xdg-app support all the launch processes need to add this too, currently not impl. for arg in sys.argv: if arg.lower() == "-xdg": editorstate.use_xdg = True # Create hidden folders if not present user_dir = utils.get_hidden_user_dir_path() print "User dir:", user_dir if not os.path.exists(user_dir): os.mkdir(user_dir) if not os.path.exists(user_dir + mltprofiles.USER_PROFILES_DIR): os.mkdir(user_dir + mltprofiles.USER_PROFILES_DIR) if not os.path.exists(user_dir + AUTOSAVE_DIR): os.mkdir(user_dir + AUTOSAVE_DIR) if not os.path.exists(user_dir + BATCH_DIR): os.mkdir(user_dir + BATCH_DIR) if not os.path.exists(user_dir + appconsts.AUDIO_LEVELS_DIR): os.mkdir(user_dir + appconsts.AUDIO_LEVELS_DIR) if not os.path.exists(utils.get_hidden_screenshot_dir_path()): os.mkdir(utils.get_hidden_screenshot_dir_path()) if not os.path.exists(user_dir + appconsts.GMIC_DIR): os.mkdir(user_dir + appconsts.GMIC_DIR) if not os.path.exists(user_dir + appconsts.MATCH_FRAME_DIR): os.mkdir(user_dir + appconsts.MATCH_FRAME_DIR) if not os.path.exists(user_dir + appconsts.TRIM_VIEW_DIR): os.mkdir(user_dir + appconsts.TRIM_VIEW_DIR) if not os.path.exists(user_dir + appconsts.NATRON_DIR): os.mkdir(user_dir + appconsts.NATRON_DIR) # Set paths. respaths.set_paths(root_path) # Load editor prefs and list of recent projects editorpersistance.load() if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: respaths.apply_dark_theme() if editorpersistance.prefs.display_all_audio_levels == False: editorstate.display_all_audio_levels = False editorpersistance.create_thumbs_folder_if_needed(user_dir) editorpersistance.create_rendered_clips_folder_if_needed(user_dir) editorpersistance.save() # Init translations module with translations data translations.init_languages() translations.load_filters_translations() mlttransitions.init_module() # Apr-2017 - SvdB - Keyboard shortcuts shortcuts.load_shortcut_files() shortcuts.load_shortcuts() # We respaths and translations data available so we need to init in a function. workflow.init_data() # RHEL7/CentOS compatibility fix if gtk_version == "3.8.8": GObject.threads_init() # Init gtk threads Gdk.threads_init() Gdk.threads_enter() # Themes if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: Gtk.Settings.get_default().set_property( "gtk-application-prefer-dark-theme", True) if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME: gui.apply_gtk_css() # Load drag'n'drop images dnd.init() # Adjust gui parameters for smaller screens scr_w = Gdk.Screen.width() scr_h = Gdk.Screen.height() editorstate.SCREEN_WIDTH = scr_w editorstate.SCREEN_HEIGHT = scr_h print "Screen size:", scr_w, "x", scr_h print "Small height:", editorstate.screen_size_small_height() print "Small width:", editorstate.screen_size_small_width() _set_draw_params() # Refuse to run on too small screen. if scr_w < 1151 or scr_h < 767: _too_small_screen_exit() return # Splash screen if editorpersistance.prefs.display_splash_screen == True: show_splash_screen() # Init MLT framework repo = mlt.Factory().init() repo.producers().set('qimage', None, 0) repo.producers().set('qtext', None, 0) repo.producers().set('kdenlivetitle', None, 0) # Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs. locale.setlocale(locale.LC_NUMERIC, 'C') # Check for codecs and formats on the system. mltenv.check_available_features(repo) renderconsumer.load_render_profiles() # Load filter and compositor descriptions from xml files. mltfilters.load_filters_xml(mltenv.services) mlttransitions.load_compositors_xml(mltenv.transitions) # Replace some services if better replacements available. mltfilters.replace_services(mltenv.services) # Create list of available mlt profiles. mltprofiles.load_profile_list() # Save assoc file path if found in arguments. global assoc_file_path assoc_file_path = get_assoc_file_path() # There is always a project open, so at startup we create a default project. # Set default project as the project being edited. editorstate.project = projectdata.get_default_project() check_crash = True # Audiomonitoring being available needs to be known before GUI creation. audiomonitoring.init(editorstate.project.profile) # Set trim view mode to current default value. editorstate.show_trim_view = editorpersistance.prefs.trim_view_default # Check for tools and init tools integration. gmic.test_availablity() toolnatron.init() toolsintegration.init() #toolsintegration.test() # Create player object. create_player() # Create main window and set widget handles in gui.py for more convenient reference. create_gui() # Inits widgets with project data. init_project_gui() # Inits widgets with current sequence data. init_sequence_gui() # Launch player now that data and gui exist launch_player() # Editor and modules need some more initializing. init_editor_state() # Tracks need to be recentered if window is resized. # Connect listener for this now that the tline panel size allocation is sure to be available. global window_resize_id, window_state_id window_resize_id = gui.editor_window.window.connect( "size-allocate", lambda w, e: updater.window_resized()) window_state_id = gui.editor_window.window.connect( "window-state-event", lambda w, e: updater.window_resized()) # Get existing autosave files autosave_files = get_autosave_files() # Show splash if ((editorpersistance.prefs.display_splash_screen == True) and len(autosave_files) == 0 ) and not editorstate.runtime_version_greater_then_test_version( editorpersistance.prefs.workflow_dialog_last_version_shown, editorstate.appversion): global splash_timeout_id splash_timeout_id = GLib.timeout_add(2600, destroy_splash_screen) splash_screen.show_all() appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION # THIS IS A QUESTIONABLE IDEA TO SIMPLIFY IMPORTS, NOT DRY. WHEN DOING TOOLS THAT RUN IN ANOTHER PROCESSES AND SAVE PROJECTS, THIS LINE NEEDS TO BE THERE ALSO. # Every running instance has unique autosave file which is deleted at exit set_instance_autosave_id() # Existance of autosave file hints that program was exited abnormally. if check_crash == True and len(autosave_files) > 0: if len(autosave_files) == 1: GObject.timeout_add(10, autosave_recovery_dialog) else: GObject.timeout_add(10, autosaves_many_recovery_dialog) else: start_autosave() # We prefer to monkeypatch some callbacks into some modules, usually to # maintain a simpler and/or non-circular import structure. monkeypatch_callbacks() # File in assoc_file_path is opened after very short delay. if not (check_crash == True and len(autosave_files) > 0): if assoc_file_path != None: print "Launch assoc file:", assoc_file_path global assoc_timeout_id assoc_timeout_id = GObject.timeout_add(10, open_assoc_file) # SDL 2 consumer needs to created after Gtk.main() has run enough for window to be visble #if editorstate.get_sdl_version() == editorstate.SDL_2: # needs more state considerion still # print "SDL2 timeout launch" # global sdl2_timeout_id # sdl2_timeout_id = GObject.timeout_add(1500, create_sdl_2_consumer) # In PositionNumericalEntries we are using Gtk.Entry objects in a way that works for us nicely, but is somehow "error" for Gtk, so we just kill this. Gtk.Settings.get_default().set_property("gtk-error-bell", False) # Show first run worflow info dialog if not shown for this version of application. if editorstate.runtime_version_greater_then_test_version( editorpersistance.prefs.workflow_dialog_last_version_shown, editorstate.appversion): GObject.timeout_add(500, show_worflow_info_dialog) # Launch gtk+ main loop Gtk.main() Gdk.threads_leave()
def __init__(self, config, language, languages, able_to_lock_screen, on_save_settings, glade_file): self.config = config self.on_save_settings = on_save_settings self.languages = [] builder = Gtk.Builder() builder.add_from_file(glade_file) builder.connect_signals(self) # Get the UI components self.window = builder.get_object('window_settings') self.spin_short_break_duration = builder.get_object('spin_short_break_duration') self.spin_long_break_duration = builder.get_object('spin_long_break_duration') self.spin_interval_between_two_breaks = builder.get_object('spin_interval_between_two_breaks') self.spin_short_between_long = builder.get_object('spin_short_between_long') self.spin_time_to_prepare = builder.get_object('spin_time_to_prepare') self.spin_idle_time_to_pause = builder.get_object('spin_idle_time_to_pause') self.spin_postpone_duration = builder.get_object('spin_postpone_duration') self.switch_strict_break = builder.get_object('switch_strict_break') self.switch_postpone = builder.get_object('switch_postpone') self.switch_audible_alert = builder.get_object('switch_audible_alert') self.cmb_language = builder.get_object('cmb_language') self.switch_screen_lock = builder.get_object('switch_screen_lock') self.spin_time_to_screen_lock = builder.get_object('spin_time_to_screen_lock') # Translate the UI labels builder.get_object('lbl_short_break').set_label(language['ui_controls']['short_break_duration']) builder.get_object('lbl_long_break').set_label(language['ui_controls']['long_break_duration']) builder.get_object('lbl_interval_bettween_breaks').set_label(language['ui_controls']['interval_between_two_breaks']) builder.get_object('lbl_short_per_long').set_label(language['ui_controls']['no_of_short_breaks_between_two_long_breaks']) builder.get_object('lbl_time_to_prepare').set_label(language['ui_controls']['time_to_prepare_for_break']) builder.get_object('lbl_idle_time_to_pause').set_label(language['ui_controls']['idle_time']) builder.get_object('lbl_postpone_duration').set_label(language['ui_controls']['postpone_duration']) builder.get_object('lbl_allow_postpone').set_label(language['ui_controls']['allow_postpone']) builder.get_object('lbl_strict_break').set_label(language['ui_controls']['strict_break']) builder.get_object('lbl_audible_alert').set_label(language['ui_controls']['audible_alert']) builder.get_object('lbl_language').set_label(language['ui_controls']['language']) builder.get_object('lbl_enable_screen_lock').set_label(language['ui_controls']['enable_screen_lock']) builder.get_object('lbl_lock_screen_after').set_label(language['ui_controls']['time_to_screen_lock']) builder.get_object('btn_cancel').set_label(language['ui_controls']['cancel']) builder.get_object('btn_save').set_label(language['ui_controls']['save']) # Set the current values of input fields self.spin_short_break_duration.set_value(config['short_break_duration']) self.spin_long_break_duration.set_value(config['long_break_duration']) self.spin_interval_between_two_breaks.set_value(config['break_interval']) self.spin_short_between_long.set_value(config['no_of_short_breaks_per_long_break']) self.spin_time_to_prepare.set_value(config['pre_break_warning_time']) self.spin_idle_time_to_pause.set_value(config['idle_time']) self.spin_postpone_duration.set_value(config['postpone_duration']) self.switch_strict_break.set_active(config['strict_break']) self.switch_audible_alert.set_active(config['audible_alert']) self.spin_time_to_screen_lock.set_value(config['time_to_screen_lock']) # Enable idle_time_to_pause only if xprintidle is available self.spin_idle_time_to_pause.set_sensitive(Utility.command_exist('xprintidle')) self.switch_screen_lock.set_sensitive(able_to_lock_screen) self.switch_screen_lock.set_active(able_to_lock_screen and config['enable_screen_lock']) self.switch_postpone.set_active(config['allow_postpone'] and not config['strict_break']) # Update relative states # GtkSwitch state-set signal is available only from 3.14 if Gtk.get_minor_version() >= 14: self.switch_strict_break.connect('state-set', self.on_switch_strict_break_activate) self.switch_screen_lock.connect('state-set', self.on_switch_screen_lock_activate) self.switch_postpone.connect('state-set', self.on_switch_postpone_activate) self.on_switch_strict_break_activate(self.switch_strict_break, self.switch_strict_break.get_active()) self.on_switch_screen_lock_activate(self.switch_screen_lock, self.switch_screen_lock.get_active()) self.on_switch_postpone_activate(self.switch_postpone, self.switch_postpone.get_active()) # Initialize the language combobox language_list_store = Gtk.ListStore(GObject.TYPE_STRING) language_index = 2 lang_code = config['language'] # Add 'System Language' as the first option language_list_store.append([language['ui_controls']['system_language']]) language_list_store.append(['-']) self.languages.append('system') self.languages.append('system') # Dummy record for row separator if 'system' == lang_code: self.cmb_language.set_active(0) for key in sorted(languages.keys()): language_list_store.append([languages[key]]) self.languages.append(key) if key == lang_code: self.cmb_language.set_active(language_index) language_index += 1 self.cmb_language.set_model(language_list_store) self.cmb_language.set_row_separator_func(lambda m,i: m.get_value(i, 0) == '-') cell = Gtk.CellRendererText() self.cmb_language.pack_start(cell, True) self.cmb_language.add_attribute(cell, 'text', 0)
def main(): (options, leftovers) = parse_commandline() cli.setupLogging("virt-manager", options.debug, False, False) log.debug("virt-manager version: %s", BuildConfig.version) log.debug("virtManager import: %s", os.path.dirname(__file__)) if BuildConfig.running_from_srcdir: _setup_gsettings_path(BuildConfig.gsettings_dir) if options.trace_libvirt: log.debug("Libvirt tracing requested") from .lib import module_trace import libvirt module_trace.wrap_module(libvirt, mainloop=(options.trace_libvirt == "mainloop"), regex=None) CLITestOptions = CLITestOptionsClass(options.test_options) # With F27 gnome+wayland we need to set these before GTK import os.environ["GSETTINGS_SCHEMA_DIR"] = BuildConfig.gsettings_dir # Now we've got basic environment up & running we can fork do_drop_stdio = False if not options.no_fork and not options.debug: drop_tty() do_drop_stdio = True # Ignore SIGHUP, otherwise a serial console closing drops the whole app signal.signal(signal.SIGHUP, signal.SIG_IGN) leftovers = _import_gtk(leftovers) Gtk = globals()["Gtk"] # Do this after the Gtk import so the user has a chance of seeing any error if do_drop_stdio: drop_stdio() if leftovers: raise RuntimeError("Unhandled command line options '%s'" % leftovers) log.debug("PyGObject version: %d.%d.%d", gi.version_info[0], gi.version_info[1], gi.version_info[2]) log.debug("GTK version: %d.%d.%d", Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) # Prime the vmmConfig cache from . import config config.vmmConfig.get_instance(BuildConfig, CLITestOptions) # Add our icon dir to icon theme icon_theme = Gtk.IconTheme.get_default() icon_theme.prepend_search_path(BuildConfig.icon_dir) from .engine import vmmEngine Gtk.Window.set_default_icon_name("virt-manager") show_window = None domain = None if options.show_domain_creator: show_window = vmmEngine.CLI_SHOW_DOMAIN_CREATOR elif options.show_host_summary: show_window = vmmEngine.CLI_SHOW_HOST_SUMMARY elif options.show_domain_editor: show_window = vmmEngine.CLI_SHOW_DOMAIN_EDITOR domain = options.show_domain_editor elif options.show_domain_performance: show_window = vmmEngine.CLI_SHOW_DOMAIN_PERFORMANCE domain = options.show_domain_performance elif options.show_domain_console: show_window = vmmEngine.CLI_SHOW_DOMAIN_CONSOLE domain = options.show_domain_console elif options.show_domain_delete: show_window = vmmEngine.CLI_SHOW_DOMAIN_DELETE domain = options.show_domain_delete if show_window and options.uri is None: # pragma: no cover raise RuntimeError("can't use --show-* options without --connect") skip_autostart = False if show_window: skip_autostart = True # Hook libvirt events into glib main loop LibvirtGLib.init(None) LibvirtGLib.event_register() engine = vmmEngine.get_instance() # Actually exit when we receive ctrl-c from gi.repository import GLib def _sigint_handler(user_data): ignore = user_data log.debug("Received KeyboardInterrupt. Exiting application.") engine.exit_app() GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, _sigint_handler, None) engine.start(options.uri, show_window, domain, skip_autostart)
def do_startup(self): Gtk.Application.do_startup(self) # where do we get started srcdir = Path(__file__).parent # local installation, for development if Path(srcdir, 'data').exists(): LOGGER.warning('Running from source tree, using local ui-files') LOGGER.debug('srcdir: %s', srcdir) # look for ui-files pkgdatadir = Path(srcdir, 'data') # look for settings schema_source = Gio.SettingsSchemaSource.new_from_directory( str(Path(srcdir, 'data')), Gio.SettingsSchemaSource.get_default(), False) schema = Gio.SettingsSchemaSource.lookup(schema_source, 'org.gge-em.MindEd', False) LOGGER.debug('Gsettings schema: %s', schema.get_path()) if not schema: raise Exception("Cannot get GSettings schema") self.settings = Gio.Settings.new_full(schema, None, None) # Translation stuff # older versions want str not PosixPath locale.bindtextdomain('minded', str(srcdir.resolve())) locale.textdomain('minded') gettext.bindtextdomain('minded', str(srcdir.resolve())) gettext.textdomain('minded') # systemwide installation else: pkgdatadir = Path('/usr/share/minded') self.settings = Gio.Settings('org.gge-em.MindEd') locale.bindtextdomain('minded', '/usr/share/locale') locale.textdomain('minded') gettext.bindtextdomain('minded') gettext.textdomain('minded') resource_path = Path(pkgdatadir, 'minded.gresource') resource = Gio.Resource.load(str(resource_path)) Gio.Resource._register(resource) action = Gio.SimpleAction.new('preferences', None) action.connect("activate", self.on_preferences) self.add_action(action) action = Gio.SimpleAction.new('about', None) action.connect('activate', self.on_about) self.add_action(action) action = Gio.SimpleAction.new('quit', None) action.connect("activate", self.on_quit) self.add_action(action) self.set_accels_for_action('app.quit', ['<Control>Q']) builder = Gtk.Builder() if Gtk.get_minor_version() > 18: # use GtkShortcutsWindow action = Gio.SimpleAction.new('shortcuts', None) action.connect('activate', self.on_shortcuts) self.add_action(action) builder.add_from_resource('/org/gge-em/MindEd/minded-app-menu.ui') else: builder.add_from_resource( '/org/gge-em/MindEd/minded-app-menu-traditional.ui') self.set_app_menu(builder.get_object("appmenu"))
class MindEdApp(Gtk.Application): ''' The main application ''' def __init__(self, *args, **kwargs): super().__init__( *args, application_id="org.gge-em.MindEd", #flags=Gio.ApplicationFlags.FLAGS_NONE, # argparse in main flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, # do_commandline **kwargs) # For Gio.Application 2.40 -> Trusty self.win = None self.version = "0.7.14 - Heinz" GLib.set_application_name("minded") self.args = () self.filelist = [] self.settings = '' # USB client self.client = None self.nxt_brick = None self.ev3_brick = None # windows self.brickfiler = None self.brickinfo = None self.apiviewer = None self.add_main_option_entries([ make_option("debug", description="Show debug information on the console"), make_option("version", description="Print the version number and exit") ]) def do_startup(self): Gtk.Application.do_startup(self) # where do we get started srcdir = Path(__file__).parent # local installation, for development if Path(srcdir, 'data').exists(): LOGGER.warning('Running from source tree, using local ui-files') LOGGER.debug('srcdir: %s', srcdir) # look for ui-files pkgdatadir = Path(srcdir, 'data') # look for settings schema_source = Gio.SettingsSchemaSource.new_from_directory( str(Path(srcdir, 'data')), Gio.SettingsSchemaSource.get_default(), False) schema = Gio.SettingsSchemaSource.lookup(schema_source, 'org.gge-em.MindEd', False) LOGGER.debug('Gsettings schema: %s', schema.get_path()) if not schema: raise Exception("Cannot get GSettings schema") self.settings = Gio.Settings.new_full(schema, None, None) # Translation stuff # older versions want str not PosixPath locale.bindtextdomain('minded', str(srcdir.resolve())) locale.textdomain('minded') gettext.bindtextdomain('minded', str(srcdir.resolve())) gettext.textdomain('minded') # systemwide installation else: pkgdatadir = Path('/usr/share/minded') self.settings = Gio.Settings('org.gge-em.MindEd') locale.bindtextdomain('minded', '/usr/share/locale') locale.textdomain('minded') gettext.bindtextdomain('minded') gettext.textdomain('minded') resource_path = Path(pkgdatadir, 'minded.gresource') resource = Gio.Resource.load(str(resource_path)) Gio.Resource._register(resource) action = Gio.SimpleAction.new('preferences', None) action.connect("activate", self.on_preferences) self.add_action(action) action = Gio.SimpleAction.new('about', None) action.connect('activate', self.on_about) self.add_action(action) action = Gio.SimpleAction.new('quit', None) action.connect("activate", self.on_quit) self.add_action(action) self.set_accels_for_action('app.quit', ['<Control>Q']) builder = Gtk.Builder() if Gtk.get_minor_version() > 18: # use GtkShortcutsWindow action = Gio.SimpleAction.new('shortcuts', None) action.connect('activate', self.on_shortcuts) self.add_action(action) builder.add_from_resource('/org/gge-em/MindEd/minded-app-menu.ui') else: builder.add_from_resource( '/org/gge-em/MindEd/minded-app-menu-traditional.ui') self.set_app_menu(builder.get_object("appmenu")) def do_activate(self): # Listen to uevent self.client = GUdev.Client(subsystems=["usb"]) self.client.connect("uevent", self.on_uevent) for device in self.client.query_by_subsystem("usb"): if self.look_for_brick(device): break #self.look_for_settings(self.settings) look_for_settings(self.settings) if not self.win: self.win = MindEdAppWin(self.filelist, application=self) else: # MindEd already running, brick file in file browser clicked for nth_file in self.filelist[1:]: if Path(nth_file).is_file(): # check is file already open document_uri = Path(nth_file).resolve().as_uri() pagecount = document_is_open(self.win, document_uri) LOGGER.debug('pagecount {}'.format(pagecount)) if pagecount: self.win.notebook.set_current_page(pagecount - 1) else: self.win.load_file_in_editor(document_uri) self.win.present() def do_command_line(self, command_line): options = command_line.get_options_dict() if options.contains("version"): print("MindEd {}".format(self.version)) return 0 if options.contains("debug"): self.args += ("debug", ) logging.basicConfig(format='%(levelname)s:%(name)s:%(message)s', level=logging.DEBUG) else: logging.basicConfig(format='%(levelname)s:%(name)s:%(message)s', level=logging.WARN) self.filelist = command_line.get_arguments() LOGGER.debug("Filelist: %s", self.filelist) self.activate() return 0 def look_for_brick(self, device): ''' look for LEGO-brick and initialize it ''' if '694/2' in device.get_property('PRODUCT'): LOGGER.debug('found NXT') #if LOGGER.isEnabledFor(logging.DEBUG): # for device_key in device.get_property_keys(): # LOGGER.debug(" device property %s: %s", device_key, # device.get_property(device_key)) try: #LOGGER.debug("NXT-lib: %s", nxt.locator.__file__) self.nxt_brick = nxt.locator.find_one_brick() return 'nxt' except Exception as e: LOGGER.warning('nxt-python failure: %s' % e) elif '694/5' in device.get_property('PRODUCT'): LOGGER.debug('found EV3') #if LOGGER.isEnabledFor(logging.DEBUG): # for device_key in device.get_property_keys(): # LOGGER.debug(" device property %s: %s", device_key, # device.get_property(device_key)) try: self.ev3_brick = ev3.EV3() #self.ev3_brick.do_nothing() return 'ev3' except Exception as e: LOGGER.warning('ev3-python failure: %s' % e) return None def on_uevent(self, client, action, device): ''' report plugin-event to application''' if LOGGER.isEnabledFor(logging.DEBUG): for device_key in device.get_property_keys(): LOGGER.debug(' device property %s: %s', device_key, device.get_property(device_key)) if action == "add": # only LEGO-devices if self.look_for_brick(device) == 'nxt': LOGGER.debug(' uevent: added NXT') self.win.brick_status.push(self.win.brick_status_id, "NXT") self.win.transmit_action.set_enabled(True) elif self.look_for_brick(device) == 'ev3': LOGGER.debug(' uevent: added EV3') self.win.brick_status.push(self.win.brick_status_id, "EV3") self.win.transmit_action.set_enabled(True) else: pass # newer libgudev returns on remove ID_VENDOR None if action == 'remove': if '694/5' in device.get_property('PRODUCT'): # EV3 PRODUCT 694/5/216 LOGGER.debug(' uevent: removed EV3') self.win.brick_status.pop(self.win.brick_status_id) self.win.transmit_action.set_enabled(False) self.ev3_brick = None if '694/2' in device.get_property('PRODUCT'): # NXT PRODUCT 694/2/0 LOGGER.debug(' uevent: removed NXT') self.win.brick_status.pop(self.win.brick_status_id) self.win.transmit_action.set_enabled(False) self.nxt_brick = None def on_preferences(self, action, param): ''' Gio.SimpleAction preferences ''' dlg = PreferencesDialog(self.win.get_application()) dlg.window.set_transient_for(self.win) dlg.window.set_modal(True) dlg.window.present() if Gtk.get_minor_version() > 18: def on_shortcuts(self, action, param): ''' Gio.SimpleAction shortcuts ''' builder = Gtk.Builder() builder.add_from_resource('/org/gge-em/MindEd/minded-shortcuts.ui') shortcuts_win = builder.get_object('shortcuts-minded') shortcuts_win.set_transient_for(self.win) shortcuts_win.show_all() def on_about(self, action, param): ''' Gio.SimpleAction about ''' builder = Gtk.Builder() builder.add_from_resource('/org/gge-em/MindEd/minded-about.ui') about_win = builder.get_object('about-dlg') about_win.set_version(self.version) about_win.set_transient_for(self.win) about_win.show_all() def on_quit(self, action, param): ''' quit application ''' self.win.gtk_main_quit()
import re import sys import time import tempfile import urllib.error import urllib.parse import urllib.request from gettext import gettext as _ import gi gi.require_version('Gst', '1.0') gi.require_version('GstPbutils', '1.0') from gi.repository import Gst, GstPbutils, GObject, Gtk, Gdk, Pango, GdkPixbuf, Gio, GLib from .gi_composites import GtkTemplate if Gtk.get_major_version() < 3 or Gtk.get_minor_version() < 14: sys.exit('Gtk 3.14 is required') from . import AboutPithosDialog, PreferencesPithosDialog, StationsDialog from .StationsPopover import StationsPopover from .gobject_worker import GObjectWorker from .pandora import * from .pandora.data import * from .plugin import load_plugins from .util import parse_proxy, open_browser, get_account_password try: import pacparser except ImportError: pacparser = None
def __init__(self, config_file=None, use_plugins=True, use_style=True): super(KingPhisherClientApplication, self).__init__() if use_style: gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version()) if gtk_version > (3, 18): self._theme_file = 'theme.v2.css' else: self._theme_file = 'theme.v1.css' else: self._theme_file = DISABLED self.logger = logging.getLogger('KingPhisher.Client.Application') # log version information for debugging purposes self.logger.debug("gi.repository GLib version: {0}".format('.'.join( map(str, GLib.glib_version)))) self.logger.debug("gi.repository GObject version: {0}".format('.'.join( map(str, GObject.pygobject_version)))) self.logger.debug("gi.repository Gtk version: {0}.{1}.{2}".format( Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())) if rpc_terminal.has_vte: self.logger.debug("gi.repository VTE version: {0}".format( rpc_terminal.Vte._version)) if graphs.has_matplotlib: self.logger.debug("matplotlib version: {0}".format( graphs.matplotlib.__version__)) # do not negotiate a single instance application # https://developer.gnome.org/gio/unstable/GApplication.html#G-APPLICATION-NON-UNIQUE:CAPS self.set_flags(Gio.ApplicationFlags.NON_UNIQUE) self.set_property('application-id', 'org.king-phisher.client') self.set_property('register-session', True) self.config_file = config_file or os.path.join(USER_DATA_PATH, 'config.json') """The file containing the King Phisher client configuration.""" if not os.path.isfile(self.config_file): self._create_config() self.config = None """The primary King Phisher client configuration.""" self.main_window = None """The primary top-level :py:class:`~.MainAppWindow` instance.""" self.references = [] """A list to store references to arbitrary objects in for avoiding garbage collection.""" self.rpc = None """The :py:class:`~.KingPhisherRPCClient` instance for the application.""" self._rpc_ping_event = None # this will be populated when the RPC object is authenticated to ping # the server periodically and keep the session alive self.server_events = None """The :py:class:`~.ServerEventSubscriber` instance for the application to receive server events.""" self._ssh_forwarder = None """The SSH forwarder responsible for tunneling RPC communications.""" self.style_provider = None try: self.emit('config-load', True) except IOError: self.logger.critical('failed to load the client configuration') raise self.connect('window-added', self.signal_window_added) self.actions = {} self._create_actions() if not use_plugins: self.logger.info('disabling all plugins') self.config['plugins.enabled'] = [] self.plugin_manager = plugins.ClientPluginManager([ os.path.join(USER_DATA_PATH, 'plugins'), find.data_directory('plugins') ], self) if use_plugins: self.plugin_manager.load_all()
def __init_window(self): """ Add fields for all ui objects we need to access from code. Initialize everything we can't do from glade like events and other stuff. """ log.info("Initialize main window") self.window: Gtk.Window = self.window_builder.get_object("app_window") self.window.set_default_size(1100, 700) self.window.set_application(self.app) self.window.show_all() self.window.present() self.window.connect("delete-event", self.on_close) self.window.connect("drag_data_received", self.__on_drag_data_received) self.window.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP, [Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY) self.window.title = "Cozy" # resizing the progress bar for older gtk versions if not Gtk.get_minor_version() > 18: self.window.connect("check-resize", self.__window_resized) self.author_box = self.window_builder.get_object("author_box") self.reader_box = self.window_builder.get_object("reader_box") self.book_box = self.window_builder.get_object("book_box") self.book_scroller = self.window_builder.get_object("book_scroller") self.sort_stack = self.window_builder.get_object("sort_stack") self.sort_stack.connect("notify::visible-child", self.__on_sort_stack_changed) self.sort_box = self.window_builder.get_object("sort_box") self.import_box = self.window_builder.get_object("import_box") self.position_box = self.window_builder.get_object("position_box") self.main_stack = self.window_builder.get_object("main_stack") self.toolbar_revealer = self.window_builder.get_object("toolbar_revealer") self.back_button = self.window_builder.get_object("back_button") self.back_button.connect("clicked", self.__on_back_clicked) self.category_toolbar = self.window_builder.get_object( "category_toolbar") self.sort_stack_revealer = self.window_builder.get_object( "sort_stack_revealer") # This fixes a bug where otherwise expand is # somehow set to true internally # but is still showing false in the inspector self.sort_stack_revealer.props.expand = True self.sort_stack_revealer.props.expand = False self.sort_stack_switcher = self.window_builder.get_object( "sort_stack_switcher") self.no_media_file_chooser = self.window_builder.get_object( "no_media_file_chooser") self.no_media_file_chooser.connect( "file-set", self.__on_no_media_folder_changed) self.external_switch = self.window_builder.get_object( "external_switch") self.auto_scan_switch = self.window_builder.get_object( "auto_scan_switch") # some visual stuff self.category_toolbar_separator = self.window_builder.get_object("category_toolbar_separator") if tools.is_elementary(): self.category_toolbar.set_visible(False) # get about dialog self.about_dialog = self.about_builder.get_object("about_dialog") self.about_dialog.set_transient_for(self.window) self.about_dialog.connect("delete-event", self.hide_window) self.about_dialog.set_version(self.version) # shortcuts self.accel = Gtk.AccelGroup() # sorting and filtering self.author_box.connect("row-selected", self.__on_listbox_changed) self.reader_box.connect("row-selected", self.__on_listbox_changed) self.book_box.set_sort_func(self.__sort_books, None, False) self.book_box.set_filter_func(self.__filter_books, None, False) try: about_close_button = self.about_builder.get_object( "button_box").get_children()[2] if about_close_button: about_close_button.connect( "clicked", self.__about_close_clicked) except Exception as e: log.info("Not connecting about close button.") player.add_player_listener(self.__player_changed)
# Perform the GTK UI dependency check here import ui.dependency_check as dependency_check dependency_check.check_all() # Now that I know that I have them, import them! from gi.repository import Gtk from gi.repository import GObject from gi.repository import GtkSource # This is just general info, to help people knowing their system print("Starting bokken {}, running on:".format(glob.version)) print(" Python version:") print("\n".join(" " + x for x in sys.version.split("\n"))) print(" GTK version: " + str(Gtk.get_major_version()) + '.' + str(Gtk.get_minor_version())) import ui.gtk3.common import ui.textviews as textviews import ui.statusbar as statusbar import ui.file_dialog as file_dialog MAINTITLE = "Bokken " class BokkenGTKClient: '''Main GTK application''' def __init__(self, target, backend): import time
def main(root_path, force_launch=False): gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) editorstate.gtk_version = gtk_version try: editorstate.mlt_version = mlt.LIBMLT_VERSION except: editorstate.mlt_version = "0.0.99" # magic string for "not found" global _session_id _session_id = md5.new(os.urandom(16)).hexdigest() # Set paths. respaths.set_paths(root_path) # Init session folders if os.path.exists(get_session_folder()): shutil.rmtree(get_session_folder()) os.mkdir(get_session_folder()) # Load editor prefs and list of recent projects editorpersistance.load() # Init translations module with translations data translations.init_languages() translations.load_filters_translations() mlttransitions.init_module() # Load aniamtions data natronanimations.load_animations_projects_xml() # Init gtk threads Gdk.threads_init() Gdk.threads_enter() # Set monitor sizes """ scr_w = Gdk.Screen.width() scr_h = Gdk.Screen.height() editorstate.SCREEN_WIDTH = scr_w editorstate.SCREEN_HEIGHT = scr_h if editorstate.screen_size_large_height() == True and editorstate.screen_size_small_width() == False: global MONITOR_WIDTH, MONITOR_HEIGHT MONITOR_WIDTH = 650 MONITOR_HEIGHT = 400 # initial value, this gets changed when material is loaded """ # Request dark theme if so desired if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", True) if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME: gui.apply_gtk_css() # We need mlt fpr profiles handling repo = mlt.Factory().init() # Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs locale.setlocale(locale.LC_NUMERIC, 'C') # Check for codecs and formats on the system mltenv.check_available_features(repo) renderconsumer.load_render_profiles() # Load filter and compositor descriptions from xml files. mltfilters.load_filters_xml(mltenv.services) mlttransitions.load_compositors_xml(mltenv.transitions) # Create list of available mlt profiles mltprofiles.load_profile_list() gui.load_current_colors() # Set launch profile profile_name = sys.argv[1].replace("_", " ") # we had underscores put in to pass as single arg print profile_name global _profile _profile = mltprofiles.get_profile(profile_name) global _animation_instance _animation_instance = natronanimations.get_default_animation_instance(_profile) global _window _window = NatronAnimatationsToolWindow() _window.pos_bar.set_dark_bg_color() Gtk.main() Gdk.threads_leave()
def init(self): """ Init main application """ self.settings = Settings.new() # Mount enclosing volume as soon as possible uris = self.settings.get_music_uris() try: for uri in uris: if uri.startswith("file:/"): continue f = Gio.File.new_for_uri(uri) f.mount_enclosing_volume(Gio.MountMountFlags.NONE, None, None, None) except Exception as e: print("Application::init():", e) self.__is_fs = False if Gtk.get_minor_version() > 18: cssProviderFile = Lio.File.new_for_uri( "resource:///org/gnome/Lollypop/application.css") else: cssProviderFile = Lio.File.new_for_uri( "resource:///org/gnome/Lollypop/application-legacy.css") cssProvider = Gtk.CssProvider() cssProvider.load_from_file(cssProviderFile) screen = Gdk.Screen.get_default() styleContext = Gtk.StyleContext() styleContext.add_provider_for_screen(screen, cssProvider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.db = Database() self.playlists = Playlists() # We store cursors for main thread SqlCursor.add(self.db) SqlCursor.add(self.playlists) self.albums = AlbumsDatabase() self.artists = ArtistsDatabase() self.genres = GenresDatabase() self.tracks = TracksDatabase() self.player = Player() self.scanner = CollectionScanner() self.art = Art() self.art.update_art_size() if self.settings.get_value("artist-artwork"): GLib.timeout_add(5000, self.art.cache_artists_info) if LastFM is not None: self.lastfm = LastFM() if not self.settings.get_value("disable-mpris"): # Ubuntu > 16.04 if Gtk.get_minor_version() > 18: from lollypop.mpris import MPRIS # Ubuntu <= 16.04, Debian Jessie, ElementaryOS else: from lollypop.mpris_legacy import MPRIS MPRIS(self) if not self.settings.get_value("disable-notifications"): from lollypop.notification import NotificationManager self.notify = NotificationManager() settings = Gtk.Settings.get_default() self.__gtk_dark = settings.get_property( "gtk-application-prefer-dark-theme") if not self.__gtk_dark: dark = self.settings.get_value("dark-ui") settings.set_property("gtk-application-prefer-dark-theme", dark) # Map some settings to actions self.add_action(self.settings.create_action("playback")) self.add_action(self.settings.create_action("shuffle")) self.db.upgrade()
def main(root_path): """ Called at application start. Initializes application with a default project. """ # DEBUG: Direct output to log file if log file set if _log_file != None: log_print_output_to_file() set_quiet_if_requested() print("Application version: " + editorstate.appversion) # Print OS, Python version and GTK+ version try: os_release_file = open("/etc/os-release", "r") os_text = os_release_file.read() s_index = os_text.find("PRETTY_NAME=") e_index = os_text.find("\n", s_index) print("OS: " + os_text[s_index + 13:e_index - 1]) except: pass print("Python", sys.version) gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) print("GTK+ version:", gtk_version) editorstate.gtk_version = gtk_version try: editorstate.mlt_version = mlt.LIBMLT_VERSION except: editorstate.mlt_version = "0.0.99" # magic string for "not found" # Create user folders if needed and determine if we're using xdg or dotfile userf folders. userfolders.init() # Set paths. respaths.set_paths(root_path) # Load editor prefs and list of recent projects editorpersistance.load() if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: respaths.apply_dark_theme() if editorpersistance.prefs.display_all_audio_levels == False: editorstate.display_all_audio_levels = False editorpersistance.save() # Init translations module with translations data translations.init_languages() translations.load_filters_translations() mlttransitions.init_module() # Apr-2017 - SvdB - Keyboard shortcuts shortcuts.load_shortcut_files() shortcuts.load_shortcuts() # Aug-2019 - SvdB - AS # The test for len != 4 is to make sure that if we change the number of values below the prefs are reset to the correct list # So when we add or remove a value, make sure we also change the len test # Only use positive numbers. if (not editorpersistance.prefs.AUTO_SAVE_OPTS or len(editorpersistance.prefs.AUTO_SAVE_OPTS) != 4): print("Initializing Auto Save Options") editorpersistance.prefs.AUTO_SAVE_OPTS = ((0, _("No Autosave")), (1, _("1 min")), (2, _("2 min")), (5, _("5 min"))) # We respaths and translations data available so we need to init in a function. workflow.init_data() # RHEL7/CentOS compatibility fix if gtk_version == "3.8.8": GObject.threads_init() # Init gtk threads Gdk.threads_init() Gdk.threads_enter() # Themes if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME: success = gui.apply_gtk_css() if not success: editorpersistance.prefs.theme = appconsts.LIGHT_THEME editorpersistance.save() if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: Gtk.Settings.get_default().set_property( "gtk-application-prefer-dark-theme", True) # Load drag'n'drop images dnd.init() # Save screen size data and modify rendering based on screen size/s and number of monitors. scr_w, scr_h = _set_screen_size_data() _set_draw_params() # Refuse to run on too small screen. if scr_w < 1151 or scr_h < 767: _too_small_screen_exit() return # Splash screen if editorpersistance.prefs.display_splash_screen == True: show_splash_screen() # Init MLT framework repo = mlt.Factory().init() processutils.prepare_mlt_repo(repo) # Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs. locale.setlocale(locale.LC_NUMERIC, 'C') # Check for codecs and formats on the system. mltenv.check_available_features(repo) renderconsumer.load_render_profiles() # Load filter and compositor descriptions from xml files. mltfilters.load_filters_xml(mltenv.services) mlttransitions.load_compositors_xml(mltenv.transitions) # Replace some services if better replacements available. mltfilters.replace_services(mltenv.services) # Create list of available mlt profiles. mltprofiles.load_profile_list() # If we have crashed we could have large amount of disk space wasted unless we delete all files here. tlinerender.app_launch_clean_up() # Save assoc file path if found in arguments. global assoc_file_path assoc_file_path = get_assoc_file_path() # There is always a project open, so at startup we create a default project. # Set default project as the project being edited. editorstate.project = projectdata.get_default_project() check_crash = True # Audiomonitoring being available needs to be known before GUI creation. audiomonitoring.init(editorstate.project.profile) # Set trim view mode to current default value. editorstate.show_trim_view = editorpersistance.prefs.trim_view_default # Check for tools and init tools integration. gmic.test_availablity() toolsintegration.init() # Create player object. create_player() # Create main window and set widget handles in gui.py for more convenient reference. create_gui() # Inits widgets with project data. init_project_gui() # Inits widgets with current sequence data. init_sequence_gui() # Launch player now that data and gui exist launch_player() # Editor and modules need some more initializing. init_editor_state() # Tracks need to be recentered if window is resized. # Connect listener for this now that the tline panel size allocation is sure to be available. global window_resize_id, window_state_id window_resize_id = gui.editor_window.window.connect( "size-allocate", lambda w, e: updater.window_resized()) window_state_id = gui.editor_window.window.connect( "window-state-event", lambda w, e: updater.window_resized()) # Get existing autosave files autosave_files = get_autosave_files() # Show splash if ((editorpersistance.prefs.display_splash_screen == True) and len(autosave_files) == 0 ) and not editorstate.runtime_version_greater_then_test_version( editorpersistance.prefs.workflow_dialog_last_version_shown, editorstate.appversion): global splash_timeout_id splash_timeout_id = GLib.timeout_add(2600, destroy_splash_screen) splash_screen.show_all() appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION # THIS IS A QUESTIONABLE IDEA TO SIMPLIFY IMPORTS, NOT DRY. WHEN DOING TOOLS THAT RUN IN ANOTHER PROCESSES AND SAVE PROJECTS, THIS LINE NEEDS TO BE THERE ALSO. # Every running instance has unique autosave file which is deleted at exit set_instance_autosave_id() # Existance of autosave file hints that program was exited abnormally. if check_crash == True and len(autosave_files) > 0: if len(autosave_files) == 1: GObject.timeout_add(10, autosave_recovery_dialog) else: GObject.timeout_add(10, autosaves_many_recovery_dialog) else: tlinerender.init_session() start_autosave() projectaction.clear_changed_since_last_save_flags() # We prefer to monkeypatch some callbacks into some modules, usually to # maintain a simpler and/or non-circular import structure. monkeypatch_callbacks() # File in assoc_file_path is opened after very short delay. if not (check_crash == True and len(autosave_files) > 0): if assoc_file_path != None: print("Launch assoc file:", assoc_file_path) global assoc_timeout_id assoc_timeout_id = GObject.timeout_add(10, open_assoc_file) if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME: gui.apply_flowblade_theme_fixes() # SDL 2 consumer needs to created after Gtk.main() has run enough for window to be visble #if editorstate.get_sdl_version() == editorstate.SDL_2: # needs more state considerion still # print "SDL2 timeout launch" # global sdl2_timeout_id # sdl2_timeout_id = GObject.timeout_add(1500, create_sdl_2_consumer) # In PositionNumericalEntries we are using Gtk.Entry objects in a way that works for us nicely, but is somehow "error" for Gtk, so we just kill this. Gtk.Settings.get_default().set_property("gtk-error-bell", False) # Show first run worflow info dialog if not shown for this version of application. if editorstate.runtime_version_greater_then_test_version( editorpersistance.prefs.workflow_dialog_last_version_shown, editorstate.appversion): GObject.timeout_add(500, show_worflow_info_dialog) # Handle userfolders init error and data copy. if userfolders.get_init_error() != None: GObject.timeout_add(500, show_user_folders_init_error_dialog, userfolders.get_init_error()) elif userfolders.data_copy_needed(): GObject.timeout_add(500, show_user_folders_copy_dialog) else: print("No user folders actions needed.") # Launch gtk+ main loop Gtk.main() Gdk.threads_leave()
def __init__(self, applet): super().__init__(title=_("Plugins"), icon_name="blueman", name="PluginDialog", border_width=6, default_width=490, default_height=380, resizable=False, visible=False) self.applet = applet self.Builder = Gtk.Builder(translation_domain="blueman") self.Builder.add_from_file(UI_PATH + "/applet-plugins-widget.ui") self.description = self.Builder.get_object("description") self.icon = self.Builder.get_object("icon") self.author_txt = self.Builder.get_object("author_txt") self.depends_hdr = self.Builder.get_object("depends_hdr") self.depends_txt = self.Builder.get_object("depends_txt") self.conflicts_hdr = self.Builder.get_object("conflicts_hdr") self.conflicts_txt = self.Builder.get_object("conflicts_txt") self.plugin_name = self.Builder.get_object("name") self.main_container = self.Builder.get_object("main_container") self.content_grid = self.Builder.get_object("content") self.b_prefs = self.Builder.get_object("b_prefs") self.b_prefs.connect("toggled", self.on_prefs_toggled) self.add(self.Builder.get_object("all")) cr = Gtk.CellRendererToggle() cr.connect("toggled", self.on_toggled) data = [ { "id": "active", "type": bool, "renderer": cr, "render_attrs": { "active": 0, "activatable": 1, "visible": 1 } }, { "id": "activatable", "type": bool }, { "id": "icon", "type": str, "renderer": Gtk.CellRendererPixbuf(), "render_attrs": { "icon-name": 2 } }, # device caption { "id": "desc", "type": str, "renderer": Gtk.CellRendererText(), "render_attrs": { "markup": 3 }, "view_props": { "expand": True } }, { "id": "name", "type": str }, ] self.list = GenericList(data, headers_visible=False, visible=True) self.list.liststore.set_sort_column_id(3, Gtk.SortType.ASCENDING) self.list.liststore.set_sort_func(3, self.list_compare_func) self.list.selection.connect("changed", self.on_selection_changed) plugin_list = self.Builder.get_object("plugin_list") plugin_info = self.Builder.get_object("main_scrolled_window") plugin_list.add(self.list) # Disable overlay scrolling if Gtk.get_minor_version() >= 16: plugin_list.props.overlay_scrolling = False plugin_info.props.overlay_scrolling = False self.populate() self.sig_a: int = self.applet.Plugins.connect( "plugin-loaded", self.plugin_state_changed, True) self.sig_b: int = self.applet.Plugins.connect( "plugin-unloaded", self.plugin_state_changed, False) self.connect("delete-event", self._on_close) self.list.set_cursor(0)
def main(root_path, filename): gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) print("GTK+ version:", gtk_version) editorstate.gtk_version = gtk_version try: editorstate.mlt_version = mlt.LIBMLT_VERSION except: editorstate.mlt_version = "0.0.99" # magic string for "not found" # Create user folders if needed and determine if we are using xdg or dotfile userf folders. userfolders.init() # Set paths. respaths.set_paths(root_path) # Load editor prefs and list of recent projects editorpersistance.load() # Init translations module with translations data translations.init_languages() translations.load_filters_translations() mlttransitions.init_module() # Init gtk threads Gdk.threads_init() Gdk.threads_enter() # Themes if editorpersistance.prefs.theme != appconsts.LIGHT_THEME: Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", True) if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME \ or editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME_GRAY \ or editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME_NEUTRAL: gui.apply_gtk_css(editorpersistance.prefs.theme) repo = mlt.Factory().init() processutils.prepare_mlt_repo(repo) # Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs locale.setlocale(locale.LC_NUMERIC, 'C') # Check for codecs and formats on the system mltenv.check_available_features(repo) renderconsumer.load_render_profiles() # Load filter and compositor descriptions from xml files. mltfilters.load_filters_xml(mltenv.services) mlttransitions.load_compositors_xml(mltenv.transitions) # Create list of available mlt profiles mltprofiles.load_profile_list() appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION global linker_window linker_window = MediaLinkerWindow() if filename != NO_PROJECT_AT_LAUNCH: linker_window.load_project(filename) Gtk.main() Gdk.threads_leave()
def column_clicked(self, obj, data): """ Called when a column is clicked. obj A TreeViewColumn object of the column clicked data The column index """ self.uistate.set_busy_cursor(True) self.uistate.push_message(self.dbstate, _("Column clicked, sorting...")) cput = time.clock() same_col = False if self.sort_col != data: order = Gtk.SortType.ASCENDING else: same_col = True if (self.columns[data].get_sort_order() == Gtk.SortType.DESCENDING or not self.columns[data].get_sort_indicator()): order = Gtk.SortType.ASCENDING else: order = Gtk.SortType.DESCENDING self.sort_col = data self.sort_order = order handle = self.first_selected() if not self.search_bar.is_visible(): filter_info = (True, self.generic_filter, False) else: value = self.search_bar.get_value() filter_info = (False, value, value[0] in self.exact_search()) if same_col: # activate when https://bugzilla.gnome.org/show_bug.cgi?id=684558 # is resolved if False and (Gtk.get_major_version(), Gtk.get_minor_version()) >= (3, 8): self.model.reverse_order() else: ## GTK 3.6 rows_reordered not exposed by gi, we need to reconnect ## model to obtain desired effect, but this collapses nodes ... self.list.set_model(None) self.model.reverse_order() self.list.set_model(self.model) else: self.model = self.make_model(self.dbstate.db, self.sort_col, self.sort_order, search=filter_info, sort_map=self.column_order()) self.list.set_model(self.model) self.__display_column_sort() if handle: self.goto_handle(handle) # set the search column to be the sorted column search_col = self.column_order()[data][1] self.list.set_search_column(search_col) self.uistate.set_busy_cursor(False) LOG.debug(' ' + self.__class__.__name__ + ' column_clicked ' + str(time.clock() - cput) + ' sec')
def __init__(self, break_config, is_short, parent_config, plugin_map, on_close, on_add, on_remove): self.break_config = break_config self.parent_config = parent_config self.plugin_check_buttons = {} self.on_close = on_close self.is_short = is_short self.on_add = on_add self.on_remove = on_remove builder = utility.create_gtk_builder(SETTINGS_DIALOG_BREAK_GLADE) builder.connect_signals(self) self.window = builder.get_object('dialog_settings_break') self.txt_break = builder.get_object('txt_break') self.switch_override_interval = builder.get_object( 'switch_override_interval') self.switch_override_duration = builder.get_object( 'switch_override_duration') self.switch_override_plugins = builder.get_object( 'switch_override_plugins') self.spin_interval = builder.get_object('spin_interval') self.spin_duration = builder.get_object('spin_duration') self.img_break = builder.get_object('img_break') self.cmb_type = builder.get_object('cmb_type') grid_plugins = builder.get_object('grid_plugins') list_types = builder.get_object('lst_break_types') interval_overriden = break_config.get('interval', None) is not None duration_overriden = break_config.get('duration', None) is not None plugins_overriden = break_config.get('plugins', None) is not None # Set the values self.window.set_title(_('Break Settings')) self.txt_break.set_text(_(break_config['name'])) self.switch_override_interval.set_active(interval_overriden) self.switch_override_duration.set_active(duration_overriden) self.switch_override_plugins.set_active(plugins_overriden) self.cmb_type.set_active(0 if is_short else 1) list_types[0][0] = _(list_types[0][0]) list_types[1][0] = _(list_types[1][0]) if interval_overriden: self.spin_interval.set_value(break_config['interval']) else: if is_short: self.spin_interval.set_value( parent_config.get('short_break_interval')) else: self.spin_interval.set_value( parent_config.get('long_break_interval')) if duration_overriden: self.spin_duration.set_value(break_config['duration']) else: if is_short: self.spin_duration.set_value( parent_config.get('short_break_duration')) else: self.spin_duration.set_value( parent_config.get('long_break_duration')) row = 0 col = 0 for plugin_id in plugin_map.keys(): chk_button = Gtk.CheckButton(_(plugin_map[plugin_id])) self.plugin_check_buttons[plugin_id] = chk_button grid_plugins.attach(chk_button, row, col, 1, 1) if plugins_overriden: chk_button.set_active(plugin_id in break_config['plugins']) else: chk_button.set_active(True) row += 1 if row > 2: col += 1 row = 0 # GtkSwitch state-set signal is available only from 3.14 if Gtk.get_minor_version() >= 14: self.switch_override_interval.connect( 'state-set', self.on_switch_override_interval_activate) self.switch_override_duration.connect( 'state-set', self.on_switch_override_duration_activate) self.switch_override_plugins.connect( 'state-set', self.on_switch_override_plugins_activate) self.on_switch_override_interval_activate( self.switch_override_interval, self.switch_override_interval.get_active()) self.on_switch_override_duration_activate( self.switch_override_duration, self.switch_override_duration.get_active()) self.on_switch_override_plugins_activate( self.switch_override_plugins, self.switch_override_plugins.get_active())
def format_exception_details(exc_type, exc_value, exc_traceback, error_uid=None): """ Format exception details to be show to a human. This should include enough information about the type of error that occurred and the system on which it was triggered to allow someone to attempt to debug and fix it. The first three parameters to this function directly correspond to the values returned from the :py:func:`sys.exc_info` function. :param exc_type: The type of the exception. :param exc_value: The exception instance. :param exc_traceback: The traceback object corresponding to the exception. :param error_uid: A unique identifier for this exception. :type error_uid: str, :py:class:`uuid.UUID` :return: A formatted message containing the details about the exception and environment. :rtype: str """ if isinstance(error_uid, uuid.UUID): error_uid = str(error_uid) elif error_uid is None: error_uid = 'N/A' elif not isinstance(error_uid, str): raise TypeError( 'error_uid must be an instance of either str, uuid.UUID or None') pversion = 'UNKNOWN' if its.on_linux: pversion = 'Linux: ' + ' '.join(platform.linux_distribution()) elif its.on_windows: pversion = 'Windows: ' + ' '.join(platform.win32_ver()) if its.frozen: pversion += ' (Frozen=True)' else: pversion += ' (Frozen=False)' exc_name = format_exception_name(exc_type) rpc_error_details = 'N/A (Not a remote RPC error)' if isinstance( exc_value, advancedhttpserver.RPCError) and exc_value.is_remote_exception: rpc_error_details = "Name: {0}".format( exc_value.remote_exception['name']) if exc_value.remote_exception.get('message'): rpc_error_details += " Message: '{0}'".format( exc_value.remote_exception['message']) current_tid = threading.current_thread().ident thread_info = ("{0: >4}{1} (alive={2} daemon={3})".format( ('=> ' if thread.ident == current_tid else ''), thread.name, thread.is_alive(), thread.daemon) for thread in threading.enumerate()) thread_info = '\n'.join(thread_info) details = EXCEPTION_DETAILS_TEMPLATE.format( error_details=repr(exc_value), error_type=exc_name, error_uid=error_uid, rpc_error_details=rpc_error_details, king_phisher_version=version.version, platform_version=pversion, python_version="{0}.{1}.{2}".format(*sys.version_info), gtk_version="{0}.{1}.{2}".format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), stack_trace=''.join( traceback.format_exception(exc_type, exc_value, exc_traceback)), thread_info=thread_info, timezone=tzlocal.get_localzone().zone) details = details.strip() + '\n' # add on additional details for context as necessary if isinstance(exc_value, errors.KingPhisherGraphQLQueryError): details += '\nGraphQL Exception Information:\n=============================\n\n' if exc_value.errors: details += 'GraphQL Errors:\n---------------\n' details += '\n'.join(error.strip() for error in exc_value.errors) + '\n\n' details += 'GraphQL Query:\n--------------\n' details += textwrap.dedent(exc_value.query) + '\n' return details