def __init__(self): Gtk.init_check(sys.argv) # create empty dialog self.dia_xml = Gtk.Builder() self.dia_xml.set_translation_domain("apturl") self.dia_xml.add_from_file('/usr/share/apturl/apturl-gtk.ui') self.dia = self.dia_xml.get_object('confirmation_dialog') self.dia.realize() self.backend = get_backend(self.dia) self.backend.connect("action-done", self._on_backend_done)
def __init__(self): Gtk.init_check(sys.argv) # create empty dialog self.dia_xml = Gtk.Builder() self.dia_xml.set_translation_domain("apturl") self.dia_xml.add_from_file(APTURL_UI_FILE) self.dia = self.dia_xml.get_object('confirmation_dialog') self.dia.start_available = lambda: Gtk.main_quit() self.dia.start_error = lambda: Gtk.main_quit() self.dia.exit = lambda: Gtk.main_quit() self.dia.realize() self.require_update = False
def main(options, indicator_class): exitcode = constants.EXCODE_GENERAL_ERROR dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) gtk_avail = True try: Gtk.init_check() except RuntimeError as error: gtk_avail = False print(_("Initialization of GTK+ failed: %s") % error) if gtk_avail: sbdgui = SBackupdIndicatorApp(options) exitcode = sbdgui.main(indicator_class) return exitcode
def __init__(self, shutdown): threading.Thread.__init__(self) self.setDaemon(True) self.shutdown = shutdown if not Gtk.init_check()[0]: sys.stderr.write("Gtk+ init failed. Make sure DISPLAY variable is set.\n") gtkthread.quit.set()
def require_Gtk(): """ Make sure Gtk is properly initialized. :raises RuntimeError: if Gtk can not be properly initialized """ # if we attempt to create any GUI elements with no X server running the # program will just crash, so let's make a way to catch this case: if not Gtk.init_check(None)[0]: raise RuntimeError(_("X server not connected!"))
def run(self): (success, args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") if Gtk.main_level() > 0: # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") while Gtk.main_level() > 0: time.sleep(2) sys.exit(0) while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) #nkwin7 add by yuwan #self._currentAction.window.set_property("distribution", self._distributionText().upper()) self._currentAction.window.set_property("distribution", self._distributionText()) #nkwin7 done # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") settings.set_property("gtk-icon-theme-name", "gnome") # nkwin7 add by yuwan # Apply the application stylesheet provider = Gtk.CssProvider() provider.load_from_path("/usr/share/anaconda/anaconda-gtk.css") Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) #nkwin7 done self._currentAction.window.show_all() # Do this at the last possible minute. unbusyCursor() Gtk.main()
def run(self): (success, args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") if Gtk.main_level() > 0: # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") while Gtk.main_level() > 0: time.sleep(2) sys.exit(0) while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.entry_logger() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) self._currentAction.window.set_property( "distribution", self._distributionText().upper()) # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") settings.set_property("gtk-icon-theme-name", "gnome") # Apply the application stylesheet provider = Gtk.CssProvider() provider.load_from_path("/usr/share/anaconda/anaconda-gtk.css") Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) self._currentAction.window.show_all() # Do this at the last possible minute. unbusyCursor() Gtk.main()
def main(argv): code = 1 use_gui, _ = Gtk.init_check(argv) # insert display device parameters as first arguments # this controls the format of the pixbuf that ghostscript will deliver # see display_sync for details # fast CAIRO_FORMAT_RGB24 = gs.DISPLAY_COLORS_RGB | gs.DISPLAY_UNUSED_LAST | \ gs.DISPLAY_DEPTH_8 | gs.DISPLAY_LITTLEENDIAN # interesting SEPARATION_FORMAT = gs.DISPLAY_COLORS_SEPARATION | gs.DISPLAY_ALPHA_NONE | \ gs.DISPLAY_DEPTH_8 | gs.DISPLAY_BIGENDIAN # if there are spot colors they are mixed into the cmyk values CMYK_FORMAT = gs.DISPLAY_COLORS_CMYK | gs.DISPLAY_ALPHA_NONE | \ gs.DISPLAY_DEPTH_8 | gs.DISPLAY_BIGENDIAN dformat = "-dDisplayFormat=%d" % \ ( CAIRO_FORMAT_RGB24 | gs.DISPLAY_TOPFIRST ) nargv = [argv[0], dformat] + argv[1:] #run Ghostscript try: instance = gs.new_instance() gs.set_stdio(instance, gsdll_stdin, gsdll_stdout, gsdll_stderr) if use_gui: gs.set_display_callback(instance, c.byref(display)) code = gs.init_with_args(instance, nargv) if code == 0: code = gs.run_string(instance, start_string) code1 = gs.exit(instance) if code == 0 or code == gs.e_Quit: code = code1 if code == gs.e_Quit: code = 0 # user executed 'quit' gs.delete_instance(instance) except gs.GhostscriptError as e: code = e.code sys.stderr.write(e.message) finally: exit_status = 0; if code in [0, gs.e_Info, gs.e_Quit]: pass elif code == gs.e_Fatal: exit_status = 1 else: exit_status = 255 return exit_status
def require_Gtk(min_version=2): """ Make sure Gtk is properly initialized. :raises RuntimeError: if Gtk can not be properly initialized """ if _has_Gtk < min_version: raise RuntimeError('Module gi.repository.Gtk not available!') if _has_Gtk == 2: logging.getLogger(__name__).warn( _("Missing runtime dependency GTK 3. Falling back to GTK 2 " "for password prompt")) from gi.repository import Gtk # if we attempt to create any GUI elements with no X server running the # program will just crash, so let's make a way to catch this case: if not Gtk.init_check(None)[0]: raise RuntimeError(_("X server not connected!")) return Gtk
def main(): ''' Indeed: main program. ''' if len(sys.argv) > 2: print("Usage: lpf-gui [package]") sys.exit(2) elif len(sys.argv) == 2: try: subprocess.call([here('lpf'), 'update', sys.argv[1]]) except subprocess.CalledProcessError: pass if not Gtk.init_check()[0]: print( "Unable to init xserver, so we can't start graphic interface, you can try using lpf from command line" ) return builder = Gtk.Builder() builder.add_from_file(here("lpf-gui.ui")) Handler(builder) Gtk.main()
def require_Gtk(min_version=2): """ Make sure Gtk is properly initialized. :raises RuntimeError: if Gtk can not be properly initialized """ if not (_in_X or _in_Wayland): raise RuntimeError('Not in X or Wayland session.') if _has_Gtk < min_version: raise RuntimeError('Module gi.repository.Gtk not available!') if _has_Gtk == 2: logging.getLogger(__name__).warn( _("Missing runtime dependency GTK 3. Falling back to GTK 2 " "for password prompt")) from gi.repository import Gtk # if we attempt to create any GUI elements with no X server running the # program will just crash, so let's make a way to catch this case: if not Gtk.init_check(None)[0]: raise RuntimeError(_("X server not connected!")) return Gtk
def has_display(): """ Tests to see if Python is currently running with gtk """ # FIXME: currently, Gtk.init_check() requires all strings # in argv, and we might have unicode. temp, sys.argv = sys.argv, sys.argv[:1] try: from gi.repository import Gtk from gi.repository import Gdk except: return False try: test = Gtk.init_check(temp) and \ Gdk.Display.get_default() sys.argv = temp return bool(test) except: sys.argv = temp return False
def getByGUI(): from gi.repository import Gtk ok,eh = Gtk.init_check() if not ok: return False win = Gtk.Window() vbox = Gtk.VBox(False,2) win.add(vbox) def lbl(s): vbox.pack_start(Gtk.Label(s),True,True,2) lbl(bit) lbl(data.name) lbl(badtype) lbl("What type is that?") ent = Gtk.Entry() vbox.pack_start(ent,True,True,2) btn = Gtk.Button.new_with_label("OK") fail = Gtk.Button.new_with_label("Fail") fail.connect('clicked',Gtk.main_quit) def yay(*a): nonlocal mimetype test = ent.get_text() if '/' in test: mimetype = test Gtk.main_quit() else: Gtk.MessageDialog(win, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.CLOSE, "The type "+repr(test)+" wasn't good.").show_all() ent.connect('activate',yay) btn.connect('clicked',yay) win.show_all() Gtk.main() return True
def __init__(self): #-- Check gtk --# if not Gtk.init_check()[0]: script_name = os.path.basename(__file__) print("[{}]: Failed to initialize gtk".format(script_name)) sys.exit() #-- Create Window --# Gtk.Window.__init__(self, title="AlterISO GUI Helper") #-- Set window icon --# _window_icon = "images/icon/color/AlterV5-Icon-Colored-vector.svg" self.set_icon_from_file(os.path.join(root_dir, _window_icon)) #-- Create Dict --# self.dict = {} arch_list = Gtk.ListStore(int, str) arch_list_num = 0 for arch in "x86_64", "i686": dict = {} for value in "kernel", "locale": liststore = Gtk.ListStore(int, str) liststore_num = 0 with open("{}/system/{}-{}".format(root_dir, value, arch)) as f: for i in [value.strip().split()[-1] for value in f.readlines() if not "#" in value and value != "\n"]: liststore.append([liststore_num, i]) liststore_num += 1 dict[value] = liststore liststore = Gtk.ListStore(int, str) liststore_num = 0 command = "{}/channel.sh --nobuiltin --arch {} show".format(script_dir, arch) command_obj = shlex.split(command) proc = subprocess.Popen(command_obj, stdout=subprocess.PIPE, text=True) for values in sorted(proc.stdout.read().strip().split()): liststore.append([liststore_num, values]) liststore_num += 1 dict["channel"] = liststore self.dict[arch] = dict arch_list.append([arch_list_num, arch]) arch_list_num += 1 #-- Create Widget --# # arch arch_label = Gtk.Label(label="Architecture") self.arch_combo = Gtk.ComboBox.new_with_model_and_entry(arch_list) self.arch_combo.set_entry_text_column(1) self.arch_combo.set_active(0) self.arch_combo.connect("changed", self.on_arch_combo_changed) self.default_arch = self.arch_combo.get_model()[self.arch_combo.get_active_iter()][1] arch_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) arch_box.set_homogeneous(True) arch_box.pack_start(arch_label, True, True, 0) arch_box.pack_start(self.arch_combo, True, True, 0) # kernel kernel_label = Gtk.Label(label="Kernel") kernel_list = self.dict[self.default_arch]["kernel"] self.kernel_combo = Gtk.ComboBox.new_with_model_and_entry(kernel_list) self.kernel_combo.set_entry_text_column(1) self.kernel_combo.set_active(0) kernel_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) kernel_box.set_homogeneous(True) kernel_box.pack_start(kernel_label, True, True, 0) kernel_box.pack_start(self.kernel_combo, True, True, 0) # locale locale_label = Gtk.Label(label="Locale") locale_list = self.dict[self.default_arch]["locale"] self.locale_combo = Gtk.ComboBox.new_with_model_and_entry(locale_list) self.locale_combo.set_entry_text_column(1) self.locale_combo.set_active(0) locale_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) locale_box.set_homogeneous(True) locale_box.pack_start(locale_label, True, True, 0) locale_box.pack_start(self.locale_combo, True, True, 0) # channel channel_label = Gtk.Label(label="Channel") channel_list = self.dict[self.default_arch]["channel"] self.channel_combo = Gtk.ComboBox.new_with_model_and_entry(channel_list) self.channel_combo.set_entry_text_column(1) for i in range(len(self.channel_combo.get_model())): if "xfce" == self.channel_combo.get_model()[i][1]: self.channel_combo.set_active(i) break else: self.channel_combo.set_active(0) channel_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) channel_box.set_homogeneous(True) channel_box.pack_start(channel_label, True, True, 0) channel_box.pack_start(self.channel_combo, True, True, 0) # compression comp_label = Gtk.Label(label="Compression") comp_list = Gtk.ListStore(int, str) comp_list_num = 0 for i in "gzip", "lz4", "lzma", "lzo", "xz", "zstd": comp_list.append([comp_list_num, i]) comp_list_num += 1 self.comp_combo = Gtk.ComboBox.new_with_model_and_entry(comp_list) self.comp_combo.set_entry_text_column(1) self.comp_combo.set_active(5) comp_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) comp_box.set_homogeneous(True) comp_box.pack_start(comp_label, True, True, 0) comp_box.pack_start(self.comp_combo, True, True, 0) # boot splash boot_splash_label = Gtk.Label(label="Boot Splash") self.boot_splash_button_enable = Gtk.RadioButton.new_with_label_from_widget(None, "Enable") self.boot_splash_button_disable = Gtk.RadioButton.new_with_mnemonic_from_widget(self.boot_splash_button_enable, "Disable") sub_boot_splash_box = Gtk.Box(spacing=5) sub_boot_splash_box.set_homogeneous(True) sub_boot_splash_box.pack_start(self.boot_splash_button_enable, True, True, 0) sub_boot_splash_box.pack_start(self.boot_splash_button_disable, True, True, 0) boot_splash_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) boot_splash_box.set_homogeneous(True) boot_splash_box.pack_start(boot_splash_label, True, True, 0) boot_splash_box.pack_start(sub_boot_splash_box, True, True, 0) # username username_label = Gtk.Label(label="Username") self.username_entry = Gtk.Entry() self.username_entry.set_text("alter") username_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) username_box.set_homogeneous(True) username_box.pack_start(username_label, True, True, 0) username_box.pack_start(self.username_entry, True, True, 0) # password password_label = Gtk.Label(label="Password") self.password_entry = Gtk.Entry() self.password_entry.set_visibility(False) self.password_entry.set_text("alter") self.password_button = Gtk.Button.new_with_label("Show Password") self.password_button.connect("clicked", self.on_password_clicked) password_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) password_box.set_homogeneous(True) password_box.pack_start(password_label, True, True, 0) password_box.pack_start(self.password_entry, True, True, 0) password_box.pack_start(self.password_button, True, True, 0) # extra_option extra_option_label = Gtk.Label(label="Extra build options: Additional command line options") self.extra_option_entry = Gtk.Entry() self.extra_option_entry.set_text("") extra_option_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) extra_option_box.set_homogeneous(True) extra_option_box.pack_start(extra_option_label, True, True, 0) extra_option_box.pack_start(self.extra_option_entry, True, True, 0) # reset reset_button = Gtk.Button.new_with_label("Reset") reset_button.connect("clicked", self.on_reset_clicked) # build build_button = Gtk.Button.new_with_label("Build") build_button.connect("clicked", self.on_build_clicked) # exit exit_button = Gtk.Button.new_with_label("Exit") exit_button.connect("clicked", self.on_exit_clicked) util_box = Gtk.Box(spacing=5) util_box.set_homogeneous(True) util_box.pack_start(reset_button, True, True, 0) util_box.pack_start(build_button, True, True, 0) util_box.pack_start(exit_button, True, True, 0) #-- Create Layout --# # layout 1 layout_1 = Gtk.Box(spacing=5) layout_1.pack_start(arch_box, True, True, 0) layout_1.pack_start(kernel_box, True, True, 0) layout_1.pack_start(locale_box, True, True, 0) layout_1.pack_start(channel_box, True, True, 0) # layout 2 layout_2 = Gtk.Grid() layout_2.set_column_spacing(5) layout_2.set_column_homogeneous(True) layout_2.attach(comp_box, 0, 0, 1, 2) layout_2.attach(boot_splash_box, 1, 0, 1, 2) layout_2.attach(username_box, 2, 0, 1, 2) layout_2.attach(password_box, 3, 0, 1, 3) # layout 3 layout_3 = Gtk.Grid() layout_3.set_column_spacing(5) layout_3.set_column_homogeneous(True) layout_3.attach(extra_option_box, 4, 0, 1, 3) # sub layout sub_layout = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) sub_layout.pack_start(layout_1, True, True, 5) sub_layout.pack_start(layout_2, True, True, 5) sub_layout.pack_start(layout_3, True, True, 5) sub_layout.pack_start(util_box, True, True, 5) # main layout main_layout = Gtk.Box(spacing=5) main_layout.pack_start(sub_layout, True, True, 5) self.add(main_layout)
def run(receivers, args, find_receiver, find_device): assert receivers assert args.device device_name = args.device.lower() dev = None for dev in find_device(receivers, device_name): if dev.ping(): break dev = None if not dev: raise Exception("no online device found matching '%s'" % device_name) if not args.setting: # print all settings, so first set them all up if not dev.settings: raise Exception('no settings for %s' % dev.name) _configuration.attach_to(dev) _settings.apply_all_settings(dev) print(dev.name, '(%s) [%s:%s]' % (dev.codename, dev.wpid, dev.serial)) for s in dev.settings: print('') _print_setting(s) return setting_name = args.setting.lower() setting = _settings_templates.check_feature_setting(dev, setting_name) if not setting and dev.descriptor and dev.descriptor.settings: for sclass in dev.descriptor.settings: if sclass.register and sclass.name == setting_name: try: setting = sclass.build(dev) except Exception: setting = None if setting is None: raise Exception("no setting '%s' for %s" % (args.setting, dev.name)) if args.value_key is None: setting.apply() _print_setting(setting) return remote = False if Gtk.init_check()[0]: # can Gtk be initialized? APP_ID = 'io.github.pwr_solaar.solaar' application = Gtk.Application.new( APP_ID, Gio.ApplicationFlags.HANDLES_COMMAND_LINE) application.register() remote = application.get_is_remote() # if the Solaar UI is running don't save configuration here result, message, value = set(dev, setting, args, not remote) if message is not None: print(message) if result is None: raise Exception("%s: failed to set value '%s' [%r]" % (setting.name, str(value), value)) # if the Solaar UI is running tell it to also perform the set if remote: argl = ['config', dev.serial or dev.unitId, setting.name] argl.extend([ a for a in [args.value_key, args.extra_subkey, args.extra2] if a is not None ]) application.run(_yaml.safe_dump(argl))
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") ty = dump_info.exc_info.type value = dump_info.exc_info.value if (issubclass(ty, blivet.errors.StorageError) and value.hardware_fault) \ or (issubclass(ty, OSError) and value.errno == errno.EIO): # hardware fault or '[Errno 5] Input/Output error' hw_error_msg = _("The installation was stopped due to what " "seems to be a problem with your hardware. " "The exact error message is:\n\n%s.\n\n " "The installer will now terminate.") % str(value) self.intf.messageWindow(_("Hardware error occured"), hw_error_msg) sys.exit(0) else: try: from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() if Gtk.main_level() > 0: # main loop is running, don't crash it by running another one # potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self.run_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") super(AnacondaExceptionHandler, self).handleException(dump_info) except RuntimeError: log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") print "An unknown error has occured, look at the "\ "/tmp/anaconda-tb* file(s) for more details" # in the main thread, run exception handler super(AnacondaExceptionHandler, self).handleException(dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception( (exc_info.type, exc_info.value, exc_info.stack))
def __init__(self, datadir=None, logdir=None): DistUpgradeView.__init__(self) self.logdir = logdir if not datadir or datadir == '.': localedir=os.path.join(os.getcwd(),"mo") gladedir=os.getcwd() else: localedir="/usr/share/locale/" gladedir=os.path.join(datadir, "gtkbuilder") # check if we have a display etc Gtk.init_check(sys.argv) try: locale.bindtextdomain("ubuntu-release-upgrader",localedir) gettext.textdomain("ubuntu-release-upgrader") except Exception as e: logging.warning("Error setting locales (%s)" % e) SimpleGtkbuilderApp.__init__(self, gladedir+"/DistUpgrade.ui", "ubuntu-release-upgrader") icons = Gtk.IconTheme.get_default() try: self.window_main.set_default_icon(icons.load_icon("system-software-update", 32, 0)) except GObject.GError as e: logging.debug("error setting default icon, ignoring (%s)" % e) pass # terminal stuff self.create_terminal() self.prev_step = 0 # keep a record of the latest step # we don't use this currently #self.window_main.set_keep_above(True) self.icontheme = Gtk.IconTheme.get_default() self._webkit_view = None self.window_main.realize() self.window_main.get_window().set_functions(Gdk.WMFunction.MOVE) self._opCacheProgress = GtkOpProgress(self.progressbar_cache) self._acquireProgress = GtkAcquireProgressAdapter(self) self._cdromProgress = GtkCdromProgressAdapter(self) self._installProgress = GtkInstallProgressAdapter(self) # details dialog self.details_list = Gtk.TreeStore(GObject.TYPE_STRING) column = Gtk.TreeViewColumn("") render = Gtk.CellRendererText() column.pack_start(render, True) column.add_attribute(render, "markup", 0) self.treeview_details.append_column(column) self.details_list.set_sort_column_id(0, Gtk.SortType.ASCENDING) self.treeview_details.set_model(self.details_list) # lp: #1072460 self.dialog_changes.set_resizable(False) def _activated(w): # the *current* expanded state which will change after the signal expanded = self.expander_details.get_expanded() self.dialog_changes.set_resizable(not expanded) self.expander_details.connect("activate", _activated) # FIXME: portme # Use italic style in the status labels #attrlist=Pango.AttrList() #attr = Pango.AttrStyle(Pango.Style.ITALIC, 0, -1) #attr = Pango.AttrScale(Pango.SCALE_SMALL, 0, -1) #attrlist.insert(attr) #self.label_status.set_property("attributes", attrlist) # reasonable fault handler sys.excepthook = self._handleException
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # pygiaio 3.14rev16 switched to fontconfig for PangoCairo. As this results # in 100% CPU under win7 revert it. Maybe we need to update the # cache in the windows installer for it to work... but for now revert. if is_windows(): os.environ['PANGOCAIRO_BACKEND'] = 'win32' os.environ["GTK_CSD"] = "0" # disable for consistency and trigger events seem a bit flaky here if is_osx(): os.environ["GTK_OVERLAY_SCROLLING"] = "0" # make sure GdkX11 doesn't get used under Windows if os.name == "nt": sys.modules["gi.repository.GdkX11"] = None try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") gi.require_version('Soup', '2.4') from gi.repository import Gtk, Soup from quodlibet.qltk import ThemeOverrider, gtk_version # Work around missing annotation in older libsoup (Ubuntu 14.04 at least) message = Soup.Message() try: message.set_request(None, Soup.MemoryUse.COPY, b"") except TypeError: orig = Soup.Message.set_request def new_set_request(self, content_type, req_use, req_body): return orig(self, content_type, req_use, req_body, len(req_body)) Soup.Message.set_request = new_set_request # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv = Gtk.init_check(sys.argv) if not initialized: raise SystemExit("Gtk.init failed") sys.argv = list(argv) # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings( 'ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings( 'ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', '.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except AttributeError: # older pygobject pass except ImportError: print_e("PyGObject is missing cairo support") exit(1) css_override = ThemeOverrider() # CSS overrides if os.name == "nt": # somehow borders are missing under Windows & Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" .menu { border: 1px solid @borders; } """) css_override.register_provider("", style_provider) if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) css_override.register_provider("", style_provider) if gtk_version[:2] >= (3, 20): # https://bugzilla.gnome.org/show_bug.cgi?id=761435 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" spinbutton, button { min-height: 1.8rem; } .view button { min-height: 2.0rem; } entry { min-height: 2.4rem; } """) css_override.register_provider("Adwaita", style_provider) css_override.register_provider("HighContrast", style_provider) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") exception_lines = traceback.format_exception(*dump_info.exc_info) log.debug("\n".join(exception_lines)) ty = dump_info.exc_info.type value = dump_info.exc_info.value if (issubclass(ty, blivet.errors.StorageError) and value.hardware_fault) \ or (issubclass(ty, OSError) and value.errno == errno.EIO): # hardware fault or '[Errno 5] Input/Output error' hw_error_msg = _("The installation was stopped due to what " "seems to be a problem with your hardware. " "The exact error message is:\n\n%s.\n\n " "The installer will now terminate.") % str(value) self.intf.messageWindow(_("Hardware error occured"), hw_error_msg) sys.exit(0) else: try: from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() if Gtk.main_level() > 0: # main loop is running, don't crash it by running another one # potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self.run_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") super(AnacondaExceptionHandler, self).handleException( dump_info) except (RuntimeError, ImportError): log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") if (issubclass (ty, CmdlineError)): cmdline_error_msg = _("\nThe installation was stopped due to " "incomplete spokes detected while running " "in non-interactive cmdline mode. Since there " "can not be any questions in cmdline mode, " "edit your kickstart file and retry " "installation.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate.") % str(value) # since there is no UI in cmdline mode and it is completely # non-interactive, we can't show a message window asking the user # to acknowledge the error; instead, print the error out and sleep # for a few seconds before exiting the installer print(cmdline_error_msg) time.sleep(10) sys.exit(0) else: print("\nAn unknown error has occured, look at the " "/tmp/anaconda-tb* file(s) for more details") # in the main thread, run exception handler super(AnacondaExceptionHandler, self).handleException( dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception((exc_info.type, exc_info.value, exc_info.stack))
import functools import os import signal import tempfile import gi gi.require_version('Gtk', '3.0') from gi.repository import GLib, GObject, Gtk from pystray import _base from . import notify_dbus # Make sure Gtk works if not Gtk.init_check()[0]: raise ImportError('Gtk could not be initialised') def mainloop(f): """Marks a function to be executed in the main loop. The function will be scheduled to be executed later in the mainloop. :param callable f: The function to execute. Its return value is discarded. """ @functools.wraps(f) def inner(*args, **kwargs): def callback(*args, **kwargs): """A callback that executes ``f`` and then returns ``False``. """
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # pygiaio 3.14rev16 switched to fontconfig for PangoCairo. As this results # in 100% CPU under win7 revert it. Maybe we need to update the # cache in the windows installer for it to work... but for now revert. if is_windows(): environ['PANGOCAIRO_BACKEND'] = 'win32' environ["GTK_CSD"] = "0" # disable for consistency and trigger events seem a bit flaky here if config.getboolean("settings", "scrollbar_always_visible"): environ["GTK_OVERLAY_SCROLLING"] = "0" try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") gi.require_version('Soup', '2.4') from gi.repository import Gtk from quodlibet.qltk import ThemeOverrider, gtk_version # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv[:] = Gtk.init_check(argv) if not initialized: raise SystemExit("Gtk.init failed") # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings( 'ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings( 'ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', '.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except ImportError: print_e("PyGObject is missing cairo support") exit(1) css_override = ThemeOverrider() if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) css_override.register_provider("", style_provider) if gtk_version[:2] >= (3, 20): # https://bugzilla.gnome.org/show_bug.cgi?id=761435 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" spinbutton, button { min-height: 1.8rem; } .view button { min-height: 2.0rem; } entry { min-height: 2.4rem; } entry.cell { min-height: 0; } """) css_override.register_provider("Adwaita", style_provider) css_override.register_provider("HighContrast", style_provider) # https://github.com/quodlibet/quodlibet/issues/2541 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" treeview.view.separator { min-height: 2px; color: @borders; } """) css_override.register_provider("Ambiance", style_provider) css_override.register_provider("Radiance", style_provider) # https://github.com/quodlibet/quodlibet/issues/2677 css_override.register_provider("Clearlooks-Phenix", style_provider) if gtk_version[:2] >= (3, 18): # Hack to get some grab handle like thing for panes style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkPaned.vertical, paned.vertical >separator { -gtk-icon-source: -gtk-icontheme("view-more-symbolic"); -gtk-icon-transform: rotate(90deg) scaleX(0.1) scaleY(3); } GtkPaned.horizontal, paned.horizontal >separator { -gtk-icon-source: -gtk-icontheme("view-more-symbolic"); -gtk-icon-transform: rotate(0deg) scaleX(0.1) scaleY(3); } """) css_override.register_provider("", style_provider) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # pygiaio 3.14rev16 switched to fontconfig for PangoCairo. As this results # in 100% CPU under win7 revert it. Maybe we need to update the # cache in the windows installer for it to work... but for now revert. if is_windows(): os.environ['PANGOCAIRO_BACKEND'] = 'win32' # disable for consistency and trigger events seem a bit flaky here if is_osx(): os.environ["GTK_OVERLAY_SCROLLING"] = "0" # make sure GdkX11 doesn't get used under Windows if os.name == "nt": sys.modules["gi.repository.GdkX11"] = None try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") gi.require_version('Soup', '2.4') from gi.repository import Gtk, Gdk # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv = Gtk.init_check(sys.argv) if not initialized: raise SystemExit("Gtk.init failed") sys.argv = list(argv) # add Gtk.TreePath.__getitem__/__len__ for PyGObject 3.2 try: Gtk.TreePath()[0] except TypeError: Gtk.TreePath.__getitem__ = lambda self, index: list(self)[index] Gtk.TreePath.__len__ = lambda self: self.get_depth() # GTK+ 3.4+ constants if not hasattr(Gdk, "BUTTON_PRIMARY"): Gdk.BUTTON_PRIMARY = 1 Gdk.BUTTON_MIDDLE = 2 Gdk.BUTTON_SECONDARY = 3 if not hasattr(Gdk, "EVENT_PROPAGATE"): Gdk.EVENT_PROPAGATE = 0 Gdk.EVENT_STOP = 1 # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings( 'ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings( 'ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', '.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except AttributeError: # older pygobject pass except ImportError: print_e("PyGObject is missing cairo support") exit(1) # CSS overrides if os.name == "nt": # somehow borders are missing under Windows & Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(""" .menu { border: 1px solid @borders; } """) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") ty = dump_info.exc_info.type value = dump_info.exc_info.value if (issubclass(ty, blivet.errors.StorageError) and value.hardware_fault) \ or (issubclass(ty, OSError) and value.errno == errno.EIO): # hardware fault or '[Errno 5] Input/Output error' hw_error_msg = _("The installation was stopped due to what " "seems to be a problem with your hardware. " "The exact error message is:\n\n%s.\n\n " "The installer will now terminate.") % str(value) self.intf.messageWindow(_("Hardware error occured"), hw_error_msg) sys.exit(0) else: try: from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() if Gtk.main_level() > 0: # main loop is running, don't crash it by running another one # potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self.run_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") super(AnacondaExceptionHandler, self).handleException( dump_info) except RuntimeError: log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") print "An unknown error has occured, look at the "\ "/tmp/anaconda-tb* file(s) for more details" # in the main thread, run exception handler super(AnacondaExceptionHandler, self).handleException( dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception((exc_info.type, exc_info.value, exc_info.stack))
def _init_gtk(): """Call before using Gtk/Gdk""" import gi if config.getboolean("settings", "pangocairo_force_fontconfig") and \ "PANGOCAIRO_BACKEND" not in environ: environ["PANGOCAIRO_BACKEND"] = "fontconfig" # disable for consistency and trigger events seem a bit flaky here if config.getboolean("settings", "scrollbar_always_visible"): environ["GTK_OVERLAY_SCROLLING"] = "0" try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") gi.require_version('Soup', '2.4') gi.require_version('PangoCairo', "1.0") from gi.repository import Gtk from quodlibet.qltk import ThemeOverrider, gtk_version # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv[:] = Gtk.init_check(argv) if not initialized: raise SystemExit("Gtk.init failed") # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings('ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings('ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', r'.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except ImportError: print_e("PyGObject is missing cairo support") exit(1) css_override = ThemeOverrider() if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) css_override.register_provider("", style_provider) if gtk_version[:2] >= (3, 20): # https://bugzilla.gnome.org/show_bug.cgi?id=761435 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" spinbutton, button { min-height: 22px; } .view button { min-height: 24px; } entry { min-height: 28px; } entry.cell { min-height: 0; } """) css_override.register_provider("Adwaita", style_provider) css_override.register_provider("HighContrast", style_provider) # https://github.com/quodlibet/quodlibet/issues/2541 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" treeview.view.separator { min-height: 2px; color: @borders; } """) css_override.register_provider("Ambiance", style_provider) css_override.register_provider("Radiance", style_provider) # https://github.com/quodlibet/quodlibet/issues/2677 css_override.register_provider("Clearlooks-Phenix", style_provider) # https://github.com/quodlibet/quodlibet/issues/2997 css_override.register_provider("Breeze", style_provider) if gtk_version[:2] >= (3, 18): # Hack to get some grab handle like thing for panes style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkPaned.vertical, paned.vertical >separator { -gtk-icon-source: -gtk-icontheme("view-more-symbolic"); -gtk-icon-transform: rotate(90deg) scaleX(0.1) scaleY(3); } GtkPaned.horizontal, paned.horizontal >separator { -gtk-icon-source: -gtk-icontheme("view-more-symbolic"); -gtk-icon-transform: rotate(0deg) scaleX(0.1) scaleY(3); } """) css_override.register_provider("", style_provider) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") exception_lines = traceback.format_exception(*dump_info.exc_info) log.critical("\n".join(exception_lines)) ty = dump_info.exc_info.type value = dump_info.exc_info.value try: gi.require_version("Gtk", "3.0") from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() # Attempt to grab the GUI initializing lock, do not block if not self._gui_lock.acquire(False): # the graphical interface is running, don't crash it by # running another one potentially from a different thread log.debug( "Gtk running, queuing exception handler to the main loop") run_in_loop(self._main_loop_handleException, dump_info) else: log.debug( "Gtk not running, starting Gtk and running exception handler in it" ) self._main_loop_handleException(dump_info) except (RuntimeError, ImportError, ValueError): log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") if issubclass(ty, NonInteractiveError) or not self._interactive: if issubclass(ty, NonInteractiveError): cmdline_error_msg = _( "\nThe installation was stopped due to an " "error which occurred while running in " "non-interactive cmdline mode. Since there " "cannot be any questions in cmdline mode, edit " "your kickstart file and retry installation. " "\nThe exact error message is: \n\n%s. \n\nThe " "installer will now terminate.") % str(value) else: cmdline_error_msg = _( "\nRunning in cmdline mode, no interactive " "debugging allowed.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate." ) % str(value) # since there is no UI in cmdline mode and it is completely # non-interactive, we can't show a message window asking the user # to acknowledge the error; instead, print the error out and sleep # for a few seconds before exiting the installer print(cmdline_error_msg) time.sleep(180) sys.exit(1) else: print("\nAn unknown error has occured, look at the " "/tmp/anaconda-tb* file(s) for more details") # in the main thread, run exception handler self._main_loop_handleException(dump_info) else: log.debug( "In a non-main thread, sending a message with exception data" ) # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info # new Simpleline package is now used in TUI. Look if Simpleline is # initialized or if this is some fallback from GTK or other stuff. if App.is_initialized(): # if Simpleline is initialized enqueue exception there loop = App.get_event_loop() loop.enqueue_signal( ExceptionSignal(App.get_scheduler(), exception_info=exc_info)) else: hubQ.send_exception( (exc_info.type, exc_info.value, exc_info.stack))
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") exception_lines = traceback.format_exception(*dump_info.exc_info) log.critical("\n".join(exception_lines)) ty = dump_info.exc_info.type value = dump_info.exc_info.value if (issubclass(ty, blivet.errors.StorageError) and value.hardware_fault) \ or (issubclass(ty, OSError) and value.errno == errno.EIO): # hardware fault or '[Errno 5] Input/Output error' hw_error_msg = _("The installation was stopped due to what " "seems to be a problem with your hardware. " "The exact error message is:\n\n%s.\n\n " "The installer will now terminate.") % str(value) self.intf.messageWindow(_("Hardware error occurred"), hw_error_msg) sys.exit(0) else: try: from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() # Attempt to grab the GUI initializing lock, do not block if not self._gui_lock.acquire(False): # the graphical interface is running, don't crash it by # running another one potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self.run_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") super(AnacondaExceptionHandler, self).handleException(dump_info) except (RuntimeError, ImportError): log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") if issubclass(ty, CmdlineError) or not self._interactive: if issubclass(ty, CmdlineError): cmdline_error_msg = _( "\nThe installation was stopped due to " "incomplete spokes detected while running " "in non-interactive cmdline mode. Since there " "cannot be any questions in cmdline mode, " "edit your kickstart file and retry " "installation.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate." ) % str(value) else: cmdline_error_msg = _( "\nRunning in cmdline mode, no interactive debugging " "allowed.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate." ) % str(value) # since there is no UI in cmdline mode and it is completely # non-interactive, we can't show a message window asking the user # to acknowledge the error; instead, print the error out and sleep # for a few seconds before exiting the installer print(cmdline_error_msg) time.sleep(10) sys.exit(1) else: print("\nAn unknown error has occured, look at the " "/tmp/anaconda-tb* file(s) for more details") # in the main thread, run exception handler super(AnacondaExceptionHandler, self).handleException(dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception( (exc_info.type, exc_info.value, exc_info.stack))
def run(self): (success, _args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") # Check if the GUI lock has already been taken if self._gui_lock and not self._gui_lock.acquire(False): # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") anaconda_threading.threadMgr.wait_for_error_threads() sys.exit(1) try: # Apply a widget-scale to hidpi monitors self._widgetScale() while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) self._currentAction.window.set_property("distribution", self._distributionText().upper()) # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") # Get the path to the application data data_path = os.environ.get("ANACONDA_DATA", "/usr/share/anaconda") # Apply the application stylesheet css_path = os.path.join(data_path, "anaconda-gtk.css") provider = Gtk.CssProvider() provider.load_from_path(css_path) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # Add the application icons to the theme icon_path = os.path.join(data_path, "pixmaps") icon_theme = Gtk.IconTheme.get_default() icon_theme.append_search_path(icon_path) # Apply the custom stylesheet if conf.ui.custom_stylesheet: try: provider = Gtk.CssProvider() provider.load_from_path(conf.ui.custom_stylesheet) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_CUSTOM) except GError as e: log.error("Custom stylesheet %s failed to load:\n%s", conf.ui.custom_stylesheet, e) # Look for updates to the stylesheet and apply them at a higher priority for updates_dir in ("updates", "product"): updates_css = "/run/install/%s/anaconda-gtk.css" % updates_dir if os.path.exists(updates_css): provider = Gtk.CssProvider() provider.load_from_path(updates_css) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_UPDATES) self.mainWindow.setCurrentAction(self._currentAction) # the window corresponding to the ection should now be visible to the user self._currentAction.entered.emit(self._currentAction) # Do this at the last possible minute. unbusyCursor() # If anything went wrong before we start the Gtk main loop, release # the gui lock and re-raise the exception so that meh can take over except Exception: self._gui_lock.release() raise Gtk.main()
def run(self): (success, args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") # Check if the GUI lock has already been taken if self._gui_lock and not self._gui_lock.acquire(False): # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") threads.threadMgr.wait_for_error_threads() sys.exit(1) try: # Apply a widget-scale to hidpi monitors self._widgetScale() while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.entry_logger() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) self._currentAction.window.set_property("distribution", self._distributionText().upper()) # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") settings.set_property("gtk-icon-theme-name", "gnome") # Apply the application stylesheet provider = Gtk.CssProvider() provider.load_from_path("/usr/share/anaconda/anaconda-gtk.css") Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # Apply the installclass stylesheet if self.instclass.stylesheet: provider = Gtk.CssProvider() provider.load_from_path(self.instclass.stylesheet) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_INSTALLCLASS) # Look for updates to the stylesheet and apply them at a higher priority for updates_dir in ("updates", "product"): updates_css = "/run/install/%s/anaconda-gtk.css" % updates_dir if os.path.exists(updates_css): provider = Gtk.CssProvider() provider.load_from_path(updates_css) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_UPDATES) self.mainWindow.setCurrentAction(self._currentAction) # Do this at the last possible minute. unbusyCursor() # If anything went wrong before we start the Gtk main loop, release # the gui lock and re-raise the exception so that meh can take over except Exception: self._gui_lock.release() raise Gtk.main()
def init_test_environ(): set_dll_search_path() def dbus_launch_session(): if os.name == "nt" or sys.platform == "darwin": return (-1, "") try: out = subprocess.check_output([ "dbus-daemon", "--session", "--fork", "--print-address=1", "--print-pid=1" ]) except (subprocess.CalledProcessError, OSError): return (-1, "") else: out = out.decode("utf-8") addr, pid = out.splitlines() return int(pid), addr pid, addr = dbus_launch_session() if pid >= 0: os.environ["DBUS_SESSION_BUS_ADDRESS"] = addr atexit.register(os.kill, pid, signal.SIGKILL) else: os.environ["DBUS_SESSION_BUS_ADDRESS"] = "." tests_builddir = os.path.abspath( os.environ.get('TESTS_BUILDDIR', os.path.dirname(__file__))) builddir = os.path.dirname(tests_builddir) tests_srcdir = os.path.abspath(os.path.dirname(__file__)) srcdir = os.path.dirname(tests_srcdir) sys.path.insert(0, os.path.join(builddir, 'gi')) sys.path.insert(0, tests_srcdir) sys.path.insert(0, srcdir) sys.path.insert(0, tests_builddir) sys.path.insert(0, builddir) # force untranslated messages, as we check for them in some tests os.environ['LC_MESSAGES'] = 'C' os.environ['G_DEBUG'] = 'fatal-warnings fatal-criticals' if sys.platform == "darwin" or os.name == "nt": # gtk 3.22 has warnings and ciriticals on OS X, ignore for now. # On Windows glib will create an error dialog which will block tests # so it's never a good idea there to make things fatal. os.environ['G_DEBUG'] = '' # make Gio able to find our gschemas.compiled in tests/. This needs to be set # before importing Gio. Support a separate build tree, so look in build dir # first. os.environ['GSETTINGS_BACKEND'] = 'memory' os.environ['GSETTINGS_SCHEMA_DIR'] = tests_builddir os.environ['G_FILENAME_ENCODING'] = 'UTF-8' # Avoid accessibility dbus warnings os.environ['NO_AT_BRIDGE'] = '1' # A workaround for https://gitlab.gnome.org/GNOME/glib/-/issues/2251 # The gtk4 a11y stack calls get_dbus_object_path() on the default app os.environ['GTK_A11Y'] = 'none' # Force the default theme so broken themes don't affect the tests os.environ['GTK_THEME'] = 'Adwaita' import gi gi.require_version("GIRepository", "2.0") from gi.repository import GIRepository repo = GIRepository.Repository.get_default() repo.prepend_library_path(os.path.join(tests_builddir)) repo.prepend_search_path(tests_builddir) def try_require_version(namespace, version): try: gi.require_version(namespace, version) except ValueError: # prevent tests from running with the wrong version sys.modules["gi.repository." + namespace] = None # Optional try_require_version("Gtk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("Gdk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("GdkPixbuf", "2.0") try_require_version("Pango", "1.0") try_require_version("PangoCairo", "1.0") try_require_version("Atk", "1.0") # Required gi.require_versions({ "GIMarshallingTests": "1.0", "Regress": "1.0", "GLib": "2.0", "Gio": "2.0", "GObject": "2.0", }) # It's disabled for stable releases by default, this makes sure it's # always on for the tests. warnings.simplefilter('default', gi.PyGIDeprecationWarning) # Otherwise we crash on the first gtk use when e.g. DISPLAY isn't set try: from gi.repository import Gtk except ImportError: pass else: if Gtk._version == "4.0": res = Gtk.init_check() else: res = Gtk.init_check([])[0] if not res: raise RuntimeError("Gtk available, but Gtk.init_check() failed")
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # disable for consistency and trigger events seem a bit flaky here if is_osx(): os.environ["GTK_OVERLAY_SCROLLING"] = "0" # make sure GdkX11 doesn't get used under Windows if os.name == "nt": sys.modules["gi.repository.GdkX11"] = None try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("GLib", "2.0") gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("GObject", "2.0") gi.require_version("Pango", "1.0") gi.require_version("GdkPixbuf", "2.0") gi.require_version("Gio", "2.0") from gi.repository import Gtk, GObject, Gdk, GdkPixbuf # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv = Gtk.init_check(sys.argv) if not initialized: raise SystemExit("Gtk.init failed") sys.argv = list(argv) # add Gtk.TreePath.__getitem__/__len__ for PyGObject 3.2 try: Gtk.TreePath()[0] except TypeError: Gtk.TreePath.__getitem__ = lambda self, index: list(self)[index] Gtk.TreePath.__len__ = lambda self: self.get_depth() # GTK+ 3.4+ constants if not hasattr(Gdk, "BUTTON_PRIMARY"): Gdk.BUTTON_PRIMARY = 1 Gdk.BUTTON_MIDDLE = 2 Gdk.BUTTON_SECONDARY = 3 if not hasattr(Gdk, "EVENT_PROPAGATE"): Gdk.EVENT_PROPAGATE = 0 Gdk.EVENT_STOP = 1 # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # On windows the default variants only do ANSI paths, so replace them. # In some typelibs they are replaced by default, in some don't.. if os.name == "nt": for name in ["new_from_file_at_scale", "new_from_file_at_size", "new_from_file"]: cls = GdkPixbuf.Pixbuf setattr(cls, name, getattr(cls, name + "_utf8", name)) # https://bugzilla.gnome.org/show_bug.cgi?id=670372 if not hasattr(GdkPixbuf.Pixbuf, "savev"): GdkPixbuf.Pixbuf.savev = GdkPixbuf.Pixbuf.save # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings("ignore", ".*g_value_get_int.*", Warning) # some day... but not now warnings.filterwarnings("ignore", ".*Stock items are deprecated.*", Warning) warnings.filterwarnings("ignore", ".*:use-stock.*", Warning) warnings.filterwarnings("ignore", ".*The property GtkAlignment:[^\s]+ is deprecated.*", Warning) # Newer glib is noisy regarding deprecated signals/properties # even with stable releases. if is_release(): warnings.filterwarnings("ignore", ".* It will be removed in a future version.", Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except AttributeError: # older pygobject pass except ImportError: print_e("PyGObject is missing cairo support") exit(1) # CSS overrides if os.name == "nt": # somehow borders are missing under Windows & Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data( """ .menu { border: 1px solid @borders; } """ ) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data( """ GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """ ) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings("ignore", ".*g_value_get_int.*", Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["glib"] = None sys.modules["gobject"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version if pygobject_version < (3, 9): GObject.threads_init()
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # disable for consistency and trigger events seem a bit flaky here if is_osx(): os.environ["GTK_OVERLAY_SCROLLING"] = "0" # make sure GdkX11 doesn't get used under Windows if os.name == "nt": sys.modules["gi.repository.GdkX11"] = None try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") from gi.repository import Gtk, Gdk # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv = Gtk.init_check(sys.argv) if not initialized: raise SystemExit("Gtk.init failed") sys.argv = list(argv) # add Gtk.TreePath.__getitem__/__len__ for PyGObject 3.2 try: Gtk.TreePath()[0] except TypeError: Gtk.TreePath.__getitem__ = lambda self, index: list(self)[index] Gtk.TreePath.__len__ = lambda self: self.get_depth() # GTK+ 3.4+ constants if not hasattr(Gdk, "BUTTON_PRIMARY"): Gdk.BUTTON_PRIMARY = 1 Gdk.BUTTON_MIDDLE = 2 Gdk.BUTTON_SECONDARY = 3 if not hasattr(Gdk, "EVENT_PROPAGATE"): Gdk.EVENT_PROPAGATE = 0 Gdk.EVENT_STOP = 1 # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings('ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings('ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', '.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except AttributeError: # older pygobject pass except ImportError: print_e("PyGObject is missing cairo support") exit(1) # CSS overrides if os.name == "nt": # somehow borders are missing under Windows & Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(""" .menu { border: 1px solid @borders; } """) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def run(self): (success, args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") # Check if the GUI lock has already been taken if self._gui_lock and not self._gui_lock.acquire(False): # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") # Loop forever, meh will call sys.exit() when it's done while True: time.sleep(10000) # Apply a widget-scale to hidpi monitors self._widgetScale() while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.entry_logger() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) self._currentAction.window.set_property("distribution", self._distributionText().upper()) # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") settings.set_property("gtk-icon-theme-name", "gnome") # Apply the application stylesheet provider = Gtk.CssProvider() provider.load_from_path("/usr/share/anaconda/anaconda-gtk.css") Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # Look for updates to the stylesheet and apply them at a higher priority for updates_dir in ("updates", "product"): updates_css = "/run/install/%s/anaconda-gtk.css" % updates_dir if os.path.exists(updates_css): provider = Gtk.CssProvider() provider.load_from_path(updates_css) Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_UPDATES) # try to make sure a logo image is present self._assureLogoImage() self.mainWindow.setCurrentAction(self._currentAction) # Do this at the last possible minute. unbusyCursor() Gtk.main()
from pyanaconda.i18n import _ __all__ = ["ERROR_RAISE", "ERROR_CONTINUE", "ERROR_RETRY", "InvalidImageSizeError", "MissingImageError", "MediaUnmountError", "MediaMountError", "ScriptError", "CmdlineError", "errorHandler"] # Only run the pango markup escape if the GUI is available try: from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() # If we don't do the check above this import will fail within _isys from pyanaconda.ui.gui.utils import escape_markup except (RuntimeError, ImportError): escape_markup = lambda x: x class InvalidImageSizeError(Exception): def __init__(self, message, filename): Exception.__init__(self, message) self.filename = filename class MissingImageError(Exception): pass
def init_test_environ(): # this was renamed in Python 3, provide backwards compatible name if sys.version_info[:2] == (2, 7): unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp if sys.version_info[0] == 3: unittest.TestCase.assertRegexpMatches = unittest.TestCase.assertRegex unittest.TestCase.assertRaisesRegexp = unittest.TestCase.assertRaisesRegex def dbus_launch_session(): if os.name == "nt" or sys.platform == "darwin": return (-1, "") try: out = subprocess.check_output([ "dbus-daemon", "--session", "--fork", "--print-address=1", "--print-pid=1"]) except (subprocess.CalledProcessError, OSError): return (-1, "") else: if sys.version_info[0] == 3: out = out.decode("utf-8") addr, pid = out.splitlines() return int(pid), addr pid, addr = dbus_launch_session() if pid >= 0: os.environ["DBUS_SESSION_BUS_ADDRESS"] = addr atexit.register(os.kill, pid, signal.SIGKILL) else: os.environ["DBUS_SESSION_BUS_ADDRESS"] = "." tests_builddir = os.path.abspath(os.environ.get('TESTS_BUILDDIR', os.path.dirname(__file__))) builddir = os.path.dirname(tests_builddir) tests_srcdir = os.path.abspath(os.path.dirname(__file__)) srcdir = os.path.dirname(tests_srcdir) sys.path.insert(0, os.path.join(builddir, 'gi')) sys.path.insert(0, tests_srcdir) sys.path.insert(0, srcdir) sys.path.insert(0, tests_builddir) sys.path.insert(0, builddir) # force untranslated messages, as we check for them in some tests os.environ['LC_MESSAGES'] = 'C' os.environ['G_DEBUG'] = 'fatal-warnings fatal-criticals' if sys.platform == "darwin": # gtk 3.22 has warnings and ciriticals on OS X, ignore for now os.environ['G_DEBUG'] = '' # make Gio able to find our gschemas.compiled in tests/. This needs to be set # before importing Gio. Support a separate build tree, so look in build dir # first. os.environ['GSETTINGS_BACKEND'] = 'memory' os.environ['GSETTINGS_SCHEMA_DIR'] = tests_builddir os.environ['G_FILENAME_ENCODING'] = 'UTF-8' # Force the default theme so broken themes don't affect the tests os.environ['GTK_THEME'] = 'Adwaita' import gi gi.require_version("GIRepository", "2.0") from gi.repository import GIRepository repo = GIRepository.Repository.get_default() repo.prepend_library_path(os.path.join(tests_builddir)) repo.prepend_library_path(os.path.join(tests_builddir, ".libs")) repo.prepend_search_path(tests_builddir) def try_require_version(namespace, version): try: gi.require_version(namespace, version) except ValueError: # prevent tests from running with the wrong version sys.modules["gi.repository." + namespace] = None # Optional try_require_version("Gtk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("Gdk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("GdkPixbuf", "2.0") try_require_version("Pango", "1.0") try_require_version("PangoCairo", "1.0") try_require_version("Atk", "1.0") # Required gi.require_versions({ "GIMarshallingTests": "1.0", "Regress": "1.0", "GLib": "2.0", "Gio": "2.0", "GObject": "2.0", }) # It's disabled for stable releases by default, this makes sure it's # always on for the tests. warnings.simplefilter('default', gi.PyGIDeprecationWarning) # Otherwise we crash on the first gtk use when e.g. DISPLAY isn't set try: from gi.repository import Gtk except ImportError: pass else: if Gtk._version == "4.0": res = Gtk.init_check() else: res = Gtk.init_check([])[0] if not res: raise RuntimeError("Gtk available, but Gtk.init_check() failed")
print('filepath:', filepath) self.button.set_label("Stop") self.player.set_property("uri", "file://" + filepath) self.player.set_state(Gst.State.PLAYING) else: self.player.set_state(Gst.State.NULL) self.button.set_label("Start") def on_message(self, bus, message): ''' ''' # t = message.type # if t == Gst.MessageType.EOS: # self.player.set_state(Gst.State.NULL) # self.button.set_label("Start") # elif t == Gst.MessageType.ERROR: # self.player.set_state(Gst.State.NULL) # err, debug = message.parse_error() # print("Error: %s" % err, debug) # self.button.set_label("Start") Gst.init(None) if Gtk.init_check(): GTK_Main() GObject.threads_init() loop = GObject.MainLoop() loop.run() # Gtk.main() else: print('invalid Gtk.init_check')
def run(self): (success, _args) = Gtk.init_check(None) if not success: raise RuntimeError("Failed to initialize Gtk") # Check if the GUI lock has already been taken if self._gui_lock and not self._gui_lock.acquire(False): # Gtk main loop running. That means python-meh caught exception # and runs its main loop. Do not crash Gtk by running another one # from a different thread and just wait until python-meh is # finished, then quit. unbusyCursor() log.error("Unhandled exception caught, waiting for python-meh to "\ "exit") anaconda_threading.threadMgr.wait_for_error_threads() sys.exit(1) try: # Apply a widget-scale to hidpi monitors self._widgetScale() while not self._currentAction: self._currentAction = self._instantiateAction(self._actions[0]) if not self._currentAction: self._actions.pop(0) if not self._actions: return self._currentAction.initialize() self._currentAction.refresh() self._currentAction.window.set_beta(not self._isFinal) self._currentAction.window.set_property("distribution", self._distributionText()) # Set some program-wide settings. settings = Gtk.Settings.get_default() settings.set_property("gtk-font-name", "Cantarell") # Get the path to the application data data_path = os.environ.get("ANACONDA_DATA", "/usr/share/anaconda") # Apply the application stylesheet css_path = os.path.join(data_path, "anaconda-gtk.css") provider = Gtk.CssProvider() provider.load_from_path(css_path) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # Add the application icons to the theme icon_path = os.path.join(data_path, "pixmaps") icon_theme = Gtk.IconTheme.get_default() icon_theme.append_search_path(icon_path) # Apply the custom stylesheet if conf.ui.custom_stylesheet: try: provider = Gtk.CssProvider() provider.load_from_path(conf.ui.custom_stylesheet) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_CUSTOM) except GError as e: log.error("Custom stylesheet %s failed to load:\n%s", conf.ui.custom_stylesheet, e) # Look for updates to the stylesheet and apply them at a higher priority for updates_dir in ("updates", "product"): updates_css = "/run/install/%s/anaconda-gtk.css" % updates_dir if os.path.exists(updates_css): provider = Gtk.CssProvider() provider.load_from_path(updates_css) Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), provider, STYLE_PROVIDER_PRIORITY_UPDATES) self.mainWindow.setCurrentAction(self._currentAction) # the window corresponding to the ection should now be visible to the user self._currentAction.entered.emit(self._currentAction) # Do this at the last possible minute. unbusyCursor() # If anything went wrong before we start the Gtk main loop, release # the gui lock and re-raise the exception so that meh can take over except Exception: self._gui_lock.release() raise Gtk.main()
def __init__(self, datadir=None, logdir=None): DistUpgradeView.__init__(self) self.logdir = logdir if not datadir or datadir == '.': localedir = os.path.join(os.getcwd(), "mo") gladedir = os.getcwd() else: localedir = "/usr/share/locale/" gladedir = os.path.join(datadir, "gtkbuilder") # check if we have a display etc Gtk.init_check(sys.argv) try: locale.bindtextdomain("ubuntu-release-upgrader", localedir) gettext.textdomain("ubuntu-release-upgrader") except Exception as e: logging.warning("Error setting locales (%s)" % e) SimpleGtkbuilderApp.__init__(self, gladedir + "/DistUpgrade.ui", "ubuntu-release-upgrader") icons = Gtk.IconTheme.get_default() try: self.window_main.set_default_icon( icons.load_icon("system-software-update", 32, 0)) except GObject.GError as e: logging.debug("error setting default icon, ignoring (%s)" % e) pass # terminal stuff self.create_terminal() self.prev_step = 0 # keep a record of the latest step # we don't use this currently #self.window_main.set_keep_above(True) self.icontheme = Gtk.IconTheme.get_default() self._webkit_view = None self.window_main.realize() self.window_main.get_window().set_functions(Gdk.WMFunction.MOVE) self._opCacheProgress = GtkOpProgress(self.progressbar_cache) self._acquireProgress = GtkAcquireProgressAdapter(self) self._cdromProgress = GtkCdromProgressAdapter(self) self._installProgress = GtkInstallProgressAdapter(self) # details dialog self.details_list = Gtk.TreeStore(GObject.TYPE_STRING) column = Gtk.TreeViewColumn("") render = Gtk.CellRendererText() column.pack_start(render, True) column.add_attribute(render, "markup", 0) self.treeview_details.append_column(column) self.details_list.set_sort_column_id(0, Gtk.SortType.ASCENDING) self.treeview_details.set_model(self.details_list) # lp: #1072460 self.dialog_changes.set_resizable(False) def _activated(w): # the *current* expanded state which will change after the signal expanded = self.expander_details.get_expanded() self.dialog_changes.set_resizable(not expanded) self.expander_details.connect("activate", _activated) # FIXME: portme # Use italic style in the status labels #attrlist=Pango.AttrList() #attr = Pango.AttrStyle(Pango.Style.ITALIC, 0, -1) #attr = Pango.AttrScale(Pango.SCALE_SMALL, 0, -1) #attrlist.insert(attr) #self.label_status.set_property("attributes", attrlist) # reasonable fault handler sys.excepthook = self._handleException
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") ty = dump_info.exc_info.type value = dump_info.exc_info.value if issubclass(ty, blivet.errors.StorageError) and value.hardware_fault: hw_error_msg = _("The installation was stopped due to what " "seems to be a problem with your hardware. " "The exact error message is:\n\n%s.\n\n " "The installer will now terminate.") % str(value) self.intf.messageWindow(_("Hardware error occured"), hw_error_msg) sys.exit(0) else: try: # pylint: disable-msg=E0611 from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases (initialized, args) = Gtk.init_check(None) if not initialized: raise RuntimeError() if Gtk.main_level() > 0: # main loop is running, don't crash it by running another one # potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self.run_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") super(AnacondaExceptionHandler, self).handleException(dump_info) except RuntimeError: log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") if (issubclass(ty, CmdlineError)): cmdline_error_msg = _( "\nThe installation was stopped due to an " "error which occurred while running in " "non-interactive cmdline mode. Since there can " "not be any questions in cmdline mode, edit " "your kickstart file and retry installation. " "\nThe exact error message is: \n\n%s. \n\nThe " "installer will now terminate.") % str(value) # since there is no UI in cmdline mode and it is completely # non-interactive, we can't show a message window asking the user # to acknowledge the error; instead, print the error out and sleep # for a few seconds before exiting the installer print(cmdline_error_msg) time.sleep(180) sys.exit() else: print "An unknown error has occured, look at the "\ "/tmp/anaconda-tb* file(s) for more details" # in the main thread, run exception handler super(AnacondaExceptionHandler, self).handleException(dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception( (exc_info.type, exc_info.value, exc_info.stack))
if message: window = self.get_toplevel() show_message(window, *message) def action_help_about_handler(self, widget): window = self.get_toplevel() show_about_dialog(window) if __name__ == '__main__': """ bootstrap the application """ import sys import os from gi.repository import GObject, GdkPixbuf GObject.threads_init() use_gui, __ = Gtk.init_check(sys.argv) window = Gtk.Window() window.set_title(_('Multitoner')) multitoner_icon_filename = os.path.join(DIRECTORY, 'assets', 'images', 'multitoner_icon.svg') multitoner_icon = GdkPixbuf.Pixbuf.new_from_file(multitoner_icon_filename) window.set_icon(multitoner_icon) window.set_position(Gtk.WindowPosition.CENTER) window.set_default_size(640, 480) window.set_has_resize_grip(True) # the theme should do so window.set_border_width(5)
def animate_graph(graph, pos, offscreen, new_burst_halo, dpi): """Animates the bursts of an SVO network over time. The `new_burst_halo` and `dpi` arguments are not used. """ frame = 0 g = graph # counter to make sure Gtk exits max_count = len(interval_list) - 1 current_interval = 0 # make sure there is a directory to dump frames to if offscreen and not os.path.exists(r"./data/frames"): os.makedirs(r"./data/frames") # for machines without video cards, emulate a display to allow saving frames to disk if Gtk.init_check()[0] == False: print('Display not found. Starting virtual display.') _xvfb = Xvfb(width=1920, height=1080) _xvfb.start() # light grey for default states, edges black when bursting no_burst = [0.5, 0.5, 0.5, 0.25] # Grey e_burst = [0, 0, 0, 1] # Black e_no_burst = [0.5, 0.5, 0.5, 0.25] # Grey # heatmap for burst hierarchies, from seaborn color palettes: https://seaborn.pydata.org/tutorial/color_palettes.html blue_heatmap = { **dict.fromkeys([0], [0.5, 0.5, 0.5, 0.25]), **dict.fromkeys([1, 2, 3], [ 0.8978854286812764, 0.939038831218762, 0.977362552864283, 1 ]), **dict.fromkeys([4, 5, 6], [ 0.828881199538639, 0.8937639369473279, 0.954725105728566, 1 ]), **dict.fromkeys([7, 8, 9], [ 0.7506343713956171, 0.8478431372549019, 0.9282122260668974, 1 ]), **dict.fromkeys([10, 11, 12], [ 0.6325259515570935, 0.7976470588235294, 0.8868742791234141, 1 ]), **dict.fromkeys([13, 14, 15], [ 0.491764705882353, 0.7219684736639754, 0.8547789311803152, 1 ]), **dict.fromkeys([16, 17, 18], [ 0.36159938485198, 0.6427374086889658, 0.8165782391387928, 1 ]), **dict.fromkeys([19, 20, 21], [ 0.24816608996539793, 0.5618915801614763, 0.7709803921568628, 1 ]), **dict.fromkeys([22, 23, 24], [ 0.15072664359861593, 0.4644521337946943, 0.7207843137254902, 1 ]), **dict.fromkeys([25, 26, 27], [ 0.07481737793156479, 0.3732564398308343, 0.6552095347943099, 1 ]), **dict.fromkeys([28, 29, 30, 31, 32], [ 0.03137254901960784, 0.28161476355247983, 0.5582622068435218, 1 ]) } # initialize all vertices and edges to the not_bursting state state = g.new_vertex_property("vector<double>") for v in g.vertices(): state[v] = no_burst e_state = g.new_edge_property("vector<double>") for e in g.edges(): e_state[e] = e_no_burst # initialize graph properties for current state currently_new = g.new_vertex_property("bool") currently_new.a = False # assigns False to all vertices current_v_name = g.new_vertex_property('string') current_edge_weight = g.new_edge_property("int") # gather properties from imported graph bursting = g.vertex_properties["bursting"] max_hierarchy = g.vertex_properties["max_hierarchy"] hierarchies = g.vertex_properties["hierarchies"] new_burst = g.vertex_properties["new_burst"] # check if a different graph layout has been supplied, otherwise collect default layout from graph object if pos: pos = pos else: pos = g.vertex_properties["pos"] e_bursting = g.edge_properties["e_bursting"] e_weights = g.edge_properties['e_weights'] times = g.graph_properties["times"] interval_list = g.graph_properties["interval_list"] # make sure graph is not filtered g.set_vertex_filter(None) g.set_edge_filter(None) # this creates a GTK+ window with the initial graph layout if not offscreen: # creates pop-up interactive Gtk window win = GraphWindow( g, pos, geometry=(800, 800), edge_color=e_state, vertex_fill_color=state, vertex_halo=currently_new, vertex_halo_color=[0.8, 0, 0, 0.6], vertex_text=current_v_name, #edge_pen_width = g.edge_properties['current_edge_weight'], vertex_text_position=2, vertex_font_size=13, vertex_text_color='black', vertex_shape=g.vertex_properties['vertex_shape']) else: # for dumping frames to disk frame = 0 win = Gtk.OffscreenWindow() win.set_default_size(800, 800) win.graph = GraphWidget( g, pos, edge_color=e_state, vertex_fill_color=state, vertex_halo=currently_new, vertex_halo_color=[0.8, 0, 0, 0.6], vertex_text=current_v_name, #edge_pen_width = g.edge_properties['current_edge_weight'], vertex_text_position=2, vertex_font_size=13, vertex_text_color='black', vertex_shape=g.vertex_properties['vertex_shape']) win.add(win.graph) # This function will be called repeatedly by the GTK+ main loop, updating vertex and edge states # according to their bursting status. def update_state(): # Gtk needs these variables to be global global max_count, current_interval, g, frame, _xvfb # check for failed virtual display if Gtk.init_check()[0] == False: print('Virtual display failed, quitting.') Gtk.main_quit() return False # check if we've exhausted all timepoints if current_interval > max_count: Gtk.main_quit() return False # update state of vertices and edges using the index of the current interval to access property map masks for v in g.vertices(): if bursting[v][current_interval] == True: current_v_name[v] = g.vertex_properties.vertex_name[v] if new_burst[v][current_interval] == True: currently_new[v] = True else: currently_new[v] = False # use current burst hierarchy to update state based on heatmap color palette h_colour = blue_heatmap[hierarchies[v][current_interval]] state[v] = h_colour else: state[v] = no_burst current_v_name[ v] = '' # avoid drawing vertex labels if they aren't bursting currently_new[v] = False for e in g.edges(): if e_bursting[e][current_interval] == True: current_edge_weight[e] = e_weights[e][current_interval] e_state[e] = e_burst else: e_state[e] = e_no_burst # slow down the windowed animation if not offscreen: time.sleep(0.5) # the following will force the re-drawing of the graph and issue a # re-drawing of the GTK window. win.graph.regenerate_surface() win.graph.queue_draw() # if doing an offscreen animation, dump frame to disk if offscreen: # names file based on current frame number this_filename = r'./data/frames/graph%06d.png' % frame pixbuf = win.get_pixbuf() pixbuf.savev(this_filename, 'png', ["x-dpi", "y-dpi"], ["300", "300"]) # add datetime to the frame just saved to disk with Image.open(this_filename) as im: try: myfont = ImageFont.truetype("./Arial.ttf", 30) except: myfont = ImageFont.load_default() width, height = im.size try: date = datetime.datetime.fromtimestamp( times[frame - 1]).strftime('%Y-%m-%d') msg = str(date) except KeyError: msg = "No time data for this slice" draw = ImageDraw.Draw(im) w, h = draw.textsize(msg, myfont) draw.text(((width - w) / 2, height / 50), msg, font=myfont, fill="black") im.save(this_filename) frame += 1 # increment frame for file naming and date stamping # exit after dumping the final time interval frame if current_interval == max_count: Gtk.main_quit() return False # need to return True so that the main loop will call this function more # than once. current_interval += 1 return True # bind the function above as an 'idle' callback cid = GLib.idle_add(update_state) # give the user the ability to stop the program by closing the window win.connect("delete_event", Gtk.main_quit) # actually show the window, and start the main loop win.show_all() Gtk.main()
def _init_gtk(): """Call before using Gtk/Gdk""" import gi # pygiaio 3.14rev16 switched to fontconfig for PangoCairo. As this results # in 100% CPU under win7 revert it. Maybe we need to update the # cache in the windows installer for it to work... but for now revert. if is_windows(): environ['PANGOCAIRO_BACKEND'] = 'win32' environ["GTK_CSD"] = "0" # disable for consistency and trigger events seem a bit flaky here if is_osx(): environ["GTK_OVERLAY_SCROLLING"] = "0" # make sure GdkX11 doesn't get used under Windows if os.name == "nt": sys.modules["gi.repository.GdkX11"] = None try: # not sure if this is available under Windows gi.require_version("GdkX11", "3.0") from gi.repository import GdkX11 GdkX11 except (ValueError, ImportError): pass gi.require_version("Gtk", "3.0") gi.require_version("Gdk", "3.0") gi.require_version("Pango", "1.0") gi.require_version('Soup', '2.4') from gi.repository import Gtk, Soup from quodlibet.qltk import ThemeOverrider, gtk_version # Work around missing annotation in older libsoup (Ubuntu 14.04 at least) message = Soup.Message() try: message.set_request(None, Soup.MemoryUse.COPY, b"") except TypeError: orig = Soup.Message.set_request def new_set_request(self, content_type, req_use, req_body): return orig(self, content_type, req_use, req_body, len(req_body)) Soup.Message.set_request = new_set_request # PyGObject doesn't fail anymore when init fails, so do it ourself initialized, argv[:] = Gtk.init_check(argv) if not initialized: raise SystemExit("Gtk.init failed") # include our own icon theme directory theme = Gtk.IconTheme.get_default() theme_search_path = get_image_dir() assert os.path.exists(theme_search_path) theme.append_search_path(theme_search_path) # Force menu/button image related settings. We might show too many atm # but this makes sure we don't miss cases where we forgot to force them # per widget. # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # some day... but not now warnings.filterwarnings( 'ignore', '.*Stock items are deprecated.*', Warning) warnings.filterwarnings( 'ignore', '.*:use-stock.*', Warning) warnings.filterwarnings( 'ignore', '.*The property GtkAlignment:[^\s]+ is deprecated.*', Warning) settings = Gtk.Settings.get_default() with warnings.catch_warnings(): warnings.simplefilter("ignore") settings.set_property("gtk-button-images", True) settings.set_property("gtk-menu-images", True) if hasattr(settings.props, "gtk_primary_button_warps_slider"): # https://bugzilla.gnome.org/show_bug.cgi?id=737843 settings.set_property("gtk-primary-button-warps-slider", True) # Make sure PyGObject includes support for foreign cairo structs try: gi.require_foreign("cairo") except AttributeError: # older pygobject pass except ImportError: print_e("PyGObject is missing cairo support") exit(1) css_override = ThemeOverrider() # CSS overrides if os.name == "nt": # somehow borders are missing under Windows & Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" .menu { border: 1px solid @borders; } """) css_override.register_provider("", style_provider) if sys.platform == "darwin": # fix duplicated shadows for popups with Gtk+3.14 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" GtkWindow { box-shadow: none; } .tooltip { border-radius: 0; padding: 0; } .tooltip.background { background-clip: border-box; } """) css_override.register_provider("", style_provider) if gtk_version[:2] >= (3, 20): # https://bugzilla.gnome.org/show_bug.cgi?id=761435 style_provider = Gtk.CssProvider() style_provider.load_from_data(b""" spinbutton, button { min-height: 1.8rem; } .view button { min-height: 2.0rem; } entry { min-height: 2.4rem; } entry.cell { min-height: 0; } """) css_override.register_provider("Adwaita", style_provider) css_override.register_provider("HighContrast", style_provider) # https://bugzilla.gnome.org/show_bug.cgi?id=708676 warnings.filterwarnings('ignore', '.*g_value_get_int.*', Warning) # blacklist some modules, simply loading can cause segfaults sys.modules["gtk"] = None sys.modules["gpod"] = None sys.modules["gnome"] = None from quodlibet.qltk import pygobject_version, gtk_version MinVersions.GTK.check(gtk_version) MinVersions.PYGOBJECT.check(pygobject_version)
def update_state(): # Gtk needs these variables to be global global max_count, current_interval, g, frame, _xvfb # check for failed virtual display if Gtk.init_check()[0] == False: print('Virtual display failed, quitting.') Gtk.main_quit() return False # check if we've exhausted all timepoints if current_interval > max_count: Gtk.main_quit() return False # update state of vertices and edges using the index of the current interval to access property map masks for v in g.vertices(): if bursting[v][current_interval] == True: current_v_name[v] = g.vertex_properties.vertex_name[v] if new_burst[v][current_interval] == True: currently_new[v] = True else: currently_new[v] = False # use current burst hierarchy to update state based on heatmap color palette h_colour = blue_heatmap[hierarchies[v][current_interval]] state[v] = h_colour else: state[v] = no_burst current_v_name[ v] = '' # avoid drawing vertex labels if they aren't bursting currently_new[v] = False for e in g.edges(): if e_bursting[e][current_interval] == True: current_edge_weight[e] = e_weights[e][current_interval] e_state[e] = e_burst else: e_state[e] = e_no_burst # slow down the windowed animation if not offscreen: time.sleep(0.5) # the following will force the re-drawing of the graph and issue a # re-drawing of the GTK window. win.graph.regenerate_surface() win.graph.queue_draw() # if doing an offscreen animation, dump frame to disk if offscreen: # names file based on current frame number this_filename = r'./data/frames/graph%06d.png' % frame pixbuf = win.get_pixbuf() pixbuf.savev(this_filename, 'png', ["x-dpi", "y-dpi"], ["300", "300"]) # add datetime to the frame just saved to disk with Image.open(this_filename) as im: try: myfont = ImageFont.truetype("./Arial.ttf", 30) except: myfont = ImageFont.load_default() width, height = im.size try: date = datetime.datetime.fromtimestamp( times[frame - 1]).strftime('%Y-%m-%d') msg = str(date) except KeyError: msg = "No time data for this slice" draw = ImageDraw.Draw(im) w, h = draw.textsize(msg, myfont) draw.text(((width - w) / 2, height / 50), msg, font=myfont, fill="black") im.save(this_filename) frame += 1 # increment frame for file naming and date stamping # exit after dumping the final time interval frame if current_interval == max_count: Gtk.main_quit() return False # need to return True so that the main loop will call this function more # than once. current_interval += 1 return True
def handleException(self, dump_info): """ Our own handleException method doing some additional stuff before calling the original python-meh's one. :type dump_info: an instance of the meh.DumpInfo class :see: python-meh's ExceptionHandler.handleException """ log.debug("running handleException") exception_lines = traceback.format_exception(*dump_info.exc_info) log.critical("\n".join(exception_lines)) ty = dump_info.exc_info.type value = dump_info.exc_info.value try: gi.require_version("Gtk", "3.0") from gi.repository import Gtk # XXX: Gtk stopped raising RuntimeError if it fails to # initialize. Horay! But will it stay like this? Let's be # cautious and raise the exception on our own to work in both # cases initialized = Gtk.init_check(None)[0] if not initialized: raise RuntimeError() # Attempt to grab the GUI initializing lock, do not block if not self._gui_lock.acquire(False): # the graphical interface is running, don't crash it by # running another one potentially from a different thread log.debug("Gtk running, queuing exception handler to the " "main loop") GLib.idle_add(self._main_loop_handleException, dump_info) else: log.debug("Gtk not running, starting Gtk and running " "exception handler in it") self._main_loop_handleException(dump_info) except (RuntimeError, ImportError, ValueError): log.debug("Gtk cannot be initialized") # X not running (Gtk cannot be initialized) if threadMgr.in_main_thread(): log.debug("In the main thread, running exception handler") if issubclass(ty, CmdlineError) or not self._interactive: if issubclass(ty, CmdlineError): cmdline_error_msg = _( "\nThe installation was stopped due to " "incomplete spokes detected while running " "in non-interactive cmdline mode. Since there " "cannot be any questions in cmdline mode, " "edit your kickstart file and retry " "installation.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate." ) % str(value) else: cmdline_error_msg = _( "\nRunning in cmdline mode, no interactive debugging " "allowed.\nThe exact error message is: " "\n\n%s.\n\nThe installer will now terminate." ) % str(value) # since there is no UI in cmdline mode and it is completely # non-interactive, we can't show a message window asking the user # to acknowledge the error; instead, print the error out and sleep # for a few seconds before exiting the installer print(cmdline_error_msg) time.sleep(10) sys.exit(1) else: print("\nAn unknown error has occured, look at the " "/tmp/anaconda-tb* file(s) for more details") # in the main thread, run exception handler self._main_loop_handleException(dump_info) else: log.debug("In a non-main thread, sending a message with " "exception data") # not in the main thread, just send message with exception # data and let message handler run the exception handler in # the main thread exc_info = dump_info.exc_info hubQ.send_exception((exc_info.type, exc_info.value, exc_info.stack))
def init_test_environ(): # this was renamed in Python 3, provide backwards compatible name if sys.version_info[:2] == (2, 7): unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp if sys.version_info[0] == 3: unittest.TestCase.assertRegexpMatches = unittest.TestCase.assertRegex unittest.TestCase.assertRaisesRegexp = unittest.TestCase.assertRaisesRegex def dbus_launch_session(): if os.name == "nt" or sys.platform == "darwin": return (-1, "") try: out = subprocess.check_output([ "dbus-daemon", "--session", "--fork", "--print-address=1", "--print-pid=1" ]) except (subprocess.CalledProcessError, OSError): return (-1, "") else: if sys.version_info[0] == 3: out = out.decode("utf-8") addr, pid = out.splitlines() return int(pid), addr pid, addr = dbus_launch_session() if pid >= 0: os.environ["DBUS_SESSION_BUS_ADDRESS"] = addr atexit.register(os.kill, pid, signal.SIGKILL) else: os.environ["DBUS_SESSION_BUS_ADDRESS"] = "." tests_builddir = os.path.abspath( os.environ.get('TESTS_BUILDDIR', os.path.dirname(__file__))) builddir = os.path.dirname(tests_builddir) tests_srcdir = os.path.abspath(os.path.dirname(__file__)) srcdir = os.path.dirname(tests_srcdir) sys.path.insert(0, os.path.join(builddir, 'gi')) sys.path.insert(0, tests_srcdir) sys.path.insert(0, srcdir) sys.path.insert(0, tests_builddir) sys.path.insert(0, builddir) # force untranslated messages, as we check for them in some tests os.environ['LC_MESSAGES'] = 'C' os.environ['G_DEBUG'] = 'fatal-warnings fatal-criticals' if sys.platform == "darwin": # gtk 3.22 has warnings and ciriticals on OS X, ignore for now os.environ['G_DEBUG'] = '' # make Gio able to find our gschemas.compiled in tests/. This needs to be set # before importing Gio. Support a separate build tree, so look in build dir # first. os.environ['GSETTINGS_BACKEND'] = 'memory' os.environ['GSETTINGS_SCHEMA_DIR'] = tests_builddir os.environ['G_FILENAME_ENCODING'] = 'UTF-8' # Force the default theme so broken themes don't affect the tests os.environ['GTK_THEME'] = 'Adwaita' import gi gi.require_version("GIRepository", "2.0") from gi.repository import GIRepository repo = GIRepository.Repository.get_default() repo.prepend_library_path(os.path.join(tests_builddir)) repo.prepend_library_path(os.path.join(tests_builddir, ".libs")) repo.prepend_search_path(tests_builddir) def try_require_version(namespace, version): try: gi.require_version(namespace, version) except ValueError: # prevent tests from running with the wrong version sys.modules["gi.repository." + namespace] = None # Optional try_require_version("Gtk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("Gdk", os.environ.get("TEST_GTK_VERSION", "3.0")) try_require_version("GdkPixbuf", "2.0") try_require_version("Pango", "1.0") try_require_version("PangoCairo", "1.0") try_require_version("Atk", "1.0") # Required gi.require_versions({ "GIMarshallingTests": "1.0", "Regress": "1.0", "GLib": "2.0", "Gio": "2.0", "GObject": "2.0", }) # It's disabled for stable releases by default, this makes sure it's # always on for the tests. warnings.simplefilter('default', gi.PyGIDeprecationWarning) # Otherwise we crash on the first gtk use when e.g. DISPLAY isn't set try: from gi.repository import Gtk except ImportError: pass else: if not Gtk.init_check([])[0]: raise RuntimeError("Gtk available, but Gtk.init_check() failed")