def run_gui(self): application = Gtk.Application() application.userConfig = fractconfig.userConfig() window = main_window.MainWindow(application) window.f.set_size(self.w, self.h) window.f.thaw() times = [] self.last_time = now() def status_changed(f, status): if status == 0: # done new_time = now() times.append(new_time - self.last_time) self.last_time = new_time self.pos += 1 if self.pos < len(files): window.load(files[self.pos]) else: Gtk.main_quit() window.f.connect('status-changed', status_changed) window.load(files[0]) Gtk.main() return times
def create_app(self, window_class, app_name): self.user = api.get_current_user(self.store) # FIXME: Perhaps we should just ignore permission checking, it'll # save quite a few selects settings = self.store.find(ProfileSettings, app_dir_name=app_name, user_profile=self.user.profile).one() if settings is None: settings = self.create_profile_settings(self.user.profile, app_name) api.user_settings.set(u'actual-version', stoq.stoq_version) self.shell = mock.Mock() self.options = mock.Mock(spec=[u'debug']) self.options.debug = False app = Gtk.Application.get_default() if not app: app = Gtk.Application() app.set_default() app.register() self.window = MockShellWindow(self.options, self.shell, store=self.store, app=app) self.window.in_ui_test = True self.window.statusbar.push(0, u'Test Statusbar test') shell_app = self.window.run_application(app_name) assert shell_app is not None return shell_app
def run(application, model): gtk_app = Gtk.Application( application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.FLAGS_NONE ) def app_startup(app): application.init() component_registry = application.get_service("component_registry") apply_application_actions(component_registry, app) def app_activate(app): # Make sure gui is loaded ASAP. # This prevents menu items from appearing at unwanted places. main_window = application.get_service("main_window") main_window.open(app) app.add_window(main_window.window) file_manager = application.get_service("file_manager") if model: file_manager.load(model) else: file_manager.action_new() def app_shutdown(app): application.shutdown() gtk_app.connect("startup", app_startup) gtk_app.connect("activate", app_activate) gtk_app.connect("shutdown", app_shutdown) gtk_app.run()
def __init__(self): self.seen = None self.timer = None self.notify_src = None self.tick_src = None Notify.init("Tea Time") xml = Gtk.Builder() xml.set_translation_domain(GETTEXT_DOMAIN) xml.add_from_file(DATA + "window.ui") xml.connect_signals({"hide-widget": lambda w, *args: w.hide_on_delete()}) desktop_file_name = "teatime.desktop" self.window = xml.get_object("window1") if "SNAP" in os.environ: desktop_file_name = "teatime_teatime.desktop" icon = os.environ["SNAP"]+"/meta/gui/icon.svg" self.window.set_default_icon_from_file(icon) xml.get_object("aboutdialog1").set_logo(None) self.app = Gtk.Application(application_id="net.rojtberg.teatime") self.app.connect("startup", self._startup, xml) self.app.connect("activate", lambda *args: self.window.present()) self.le = Unity.LauncherEntry.get_for_desktop_file(desktop_file_name)
def __init__(self): vmmGObject.__init__(self) self.windowConnect = None self.windowPreferences = None self.windowAbout = None self.windowCreate = None self.windowManager = None self.windowMigrate = None self.conns = {} self.err = vmmErrorDialog() self.err.set_find_parent_cb(self._find_error_parent_cb) self.timer = None self.last_timeout = 0 self.systray = None self.delete_dialog = None self.application = Gtk.Application( application_id="com.redhat.virt-manager", flags=0) self.application.connect("activate", self._activate) self._appwindow = Gtk.Window() self._tick_counter = 0 self._tick_thread_slow = False self._tick_thread = threading.Thread(name="Tick thread", target=self._handle_tick_queue, args=()) self._tick_thread.daemon = True self._tick_queue = Queue.PriorityQueue(100) self.inspection = None self._create_inspection_thread() # Counter keeping track of how many manager and details windows # are open. When it is decremented to 0, close the app or # keep running in system tray if enabled self.windows = 0 # Public bits set by virt-manager cli self.skip_autostart = False self.uri_at_startup = None self.uri_cb = None self.show_manager_window = True self.init_systray() self.add_gsettings_handle( self.config.on_stats_update_interval_changed(self.reschedule_timer)) self.add_gsettings_handle( self.config.on_view_system_tray_changed(self.system_tray_changed)) self.schedule_timer() self.load_stored_uris() self._tick_thread.start() self.tick()
def run(disk, part): def on_activate(app): win = EFIWindow(app) win.query_system(disk, part) win.show() app = Gtk.Application() app.connect('activate', on_activate) app.run()
def main(): 'constructor for your class instances' parse_options() default_settings = Gtk.Settings.get_default(); default_settings.set_property('gtk-button-images', True); app = Gtk.Application(application_id="net.launchpad.emulica", flags=Gio.ApplicationFlags.FLAGS_NONE) app.connect("activate", on_activate) app.run(None)
def __init__(self, *args, **kwargs): GLib.set_application_name(_("Extensions Manager debugger")) super().__init__(*args, application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) self.application = Gtk.Application() self.application.connect("activate", self.do_activate) self.application.connect("startup", self.do_startup)
def __init__(self, name, app_id): # GLib.set_application_name(name.encode('ascii')) self._impl = Gtk.Application(application_id=app_id, flags=Gio.ApplicationFlags.FLAGS_NONE) self.main_window = MainWindow() self._impl.connect('startup', self._startup) self._impl.connect('activate', self._activate) self._impl.connect('shutdown', self._shutdown)
def __init__(self, root_path, *args, **kwargs): GLib.set_application_name("Cinnamon Tools Helper") super().__init__(*args, application_id="org.cinnamon.cinnamon-tools-repository-helper", flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) self.root_path = root_path self.application = Gtk.Application() self.application.connect("activate", self.do_activate) self.application.connect("startup", self.do_startup)
def _init_gtk_application(self): self._application = Gtk.Application( application_id="org.virt-manager.virt-manager", flags=0) self._application.register(None) self._application.connect("activate", self._on_gtk_application_activated) action = Gio.SimpleAction.new("cli_command", GLib.VariantType.new("(sss)")) action.connect("activate", self._handle_cli_command) self._application.add_action(action)
def test_gtkApplicationActivate(self): """ L{Gtk.Application} instances can be registered with a gtk3reactor. """ reactor = gtk3reactor.Gtk3Reactor() self.addCleanup(self.unbuildReactor, reactor) app = Gtk.Application( application_id='com.twistedmatrix.trial.gtk3reactor', flags=Gio.ApplicationFlags.FLAGS_NONE) self.runReactor(app, reactor)
def __init__(self): vmmGObject.__init__(self) self.windowConnect = None self.windowPreferences = None self.windowAbout = None self.windowCreate = None self.windowManager = None self.windowMigrate = None self.conns = {} self.err = vmmErrorDialog() self.timer = None self.last_timeout = 0 self.systray = None self.delete_dialog = None self.application = Gtk.Application( application_id="com.redhat.virt-manager", flags=0) self.application.connect("activate", self._activate) self._appwindow = Gtk.Window() self._tick_thread = None self._tick_thread_slow = False if not self.config.support_threading: logging.debug("Libvirt doesn't support threading, skipping.") self.inspection = None self._create_inspection_thread() # Counter keeping track of how many manager and details windows # are open. When it is decremented to 0, close the app or # keep running in system tray if enabled self.windows = 0 # Public bits set by virt-manager cli self.skip_autostart = False self.uri_at_startup = None self.uri_cb = None self.show_manager_window = True self.init_systray() self.add_gconf_handle( self.config.on_stats_update_interval_changed(self.reschedule_timer)) self.add_gconf_handle( self.config.on_view_system_tray_changed(self.system_tray_changed)) self.schedule_timer() self.load_stored_uris() self.tick()
def run(args): application: Optional[Application] = None def app_startup(gtk_app): nonlocal application @event_handler(SessionCreated) def on_session_created(event): main_window = event.session.get_service("main_window") main_window.open(gtk_app) @event_handler(ApplicationShutdown) def on_quit(event): gtk_app.quit() try: application = Application() apply_application_actions(application, gtk_app) if macos_init: macos_init(application) event_manager = application.get_service("event_manager") event_manager.subscribe(on_session_created) event_manager.subscribe(on_quit) except Exception: gtk_app.quit() raise def app_activate(gtk_app): assert application if not application.has_sessions(): app_file_manager = application.get_service("app_file_manager") app_file_manager.new() def app_open(gtk_app, files, n_files, hint): # appfilemanager should take care of this: assert application app_file_manager = application.get_service("app_file_manager") if hint == "__new__": app_file_manager.new() else: assert n_files == 1 for file in files: app_file_manager.load(file.get_path()) gtk_app = Gtk.Application( application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.HANDLES_OPEN ) add_main_options(gtk_app) gtk_app.connect("startup", app_startup) gtk_app.connect("activate", app_activate) gtk_app.connect("open", app_open) gtk_app.run(args)
def create(self): Icon.app_icon = Icon.load(self.interface.icon, default=Icon.TIBERIUS_ICON) # Stimulate the build of the app self.native = Gtk.Application(application_id=self.interface.app_id, flags=Gio.ApplicationFlags.FLAGS_NONE) # Connect the GTK signal that will cause app startup to occur self.native.connect('startup', self.startup) self.native.connect('activate', self.activate) # self.native.connect('shutdown', self.shutdown) self.actions = None
def run(self, model=None): """Start the GUI application. The file_manager service is used here to load a Gaphor model if one was specified on the command line.""" import gi gi.require_version("Gtk", "3.0") from gi.repository import Gio, Gtk app = Gtk.Application( application_id="org.gaphor.Gaphor", flags=Gio.ApplicationFlags.FLAGS_NONE ) self._app = app def app_startup(app): self.init() def app_activate(app): # Make sure gui is loaded ASAP. # This prevents menu items from appearing at unwanted places. main_window = self.get_service("main_window") main_window.open(app) app.add_window(main_window.window) file_manager = self.get_service("file_manager") if model: file_manager.load(model) else: file_manager.action_new() def app_shutdown(app): self.shutdown() def main_quit(action, param): # Perform the "luxe" quit version, as defined in MainWindow main_window = self.get_service("main_window") return main_window.quit() action = Gio.SimpleAction.new("quit", None) action.connect("activate", main_quit) app.add_action(action) app.connect("startup", app_startup) app.connect("activate", app_activate) app.connect("shutdown", app_shutdown) app.run()
def __init__(self, name, app_id, icon=None, startup=None): # GLib.set_application_name(name.encode('ascii')) self._impl = Gtk.Application(application_id=app_id, flags=Gio.ApplicationFlags.FLAGS_NONE) # Set the icon for the app Icon.app_icon = Icon.load(icon, default=TIBERIUS_ICON) self.icon = Icon.app_icon self._startup_method = startup # Connect the GTK signal that will cause app startup to occur self._impl.connect('startup', self._startup) self._impl.connect('activate', self._activate)
def guilaunch(): import gi gi.require_version("Gtk", "3.0") from gi.repository import Gtk def on_activate(app): win = Gtk.ApplicationWindow(application=app) btn = Gtk.Button(label="Hello, World!") btn.connect('clicked', lambda x: win.close()) win.add(btn) win.show_all() app = Gtk.Application(application_id='org.gtk.Example') app.connect('activate', on_activate) app.run(None)
def __init__(self, app_title="", app_command=None, working_directory=None, app_info_label=None, sub_id="", *args, **kwargs): self.app_title = app_title self.app_command = app_command self.working_directory = working_directory self.app_info_label = app_info_label self.sub_id = sub_id if self.app_title: GLib.set_application_name(self.app_title) super().__init__(*args, application_id=APPLICATION_ID + self.sub_id, flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) self.application = Gtk.Application() self.application.connect("activate", self.do_activate) self.application.connect("startup", self.do_startup)
def __init__(self, *args, **kwargs): self.type = "applet" self.uuid = APPLET_UUID self.selected_instance = None self.gsettings = Gio.Settings.new("org.cinnamon") self.load_xlet_data() self.load_instance() GLib.set_application_name(self.xlet_meta["name"]) super().__init__(*args, application_id="%s-%s" % (APPLICATION_ID, INSTANCE_ID), flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) self.application = Gtk.Application() self.application.connect("activate", self.do_activate) self.application.connect("startup", self.do_startup)
def _register_action_group(self): """Register ourself in the gtk application infrastructure. """ # Register the group in Gtk.Application to make it available to all app = Gtk.Application.get_default() if not app: app = Gtk.Application() Gtk.Application.set_default(app) window = app.get_active_window() if window: window.insert_action_group(self.group_name, self.group) else: # There is no window yet, so we must wait for one to be added to the applicattion def _window_added(app, window): window.insert_action_group(self.group_name, self.group) app.disconnect(self._conn_id) self._conn_id = app.connect('window-added', _window_added)
def run(args): application: Optional[Application] = None def new_session(): assert application session = application.new_session() subscribe_to_lifecycle_events(session, application, gtk_app) main_window = session.get_service("main_window") main_window.open(gtk_app) return session def app_startup(gtk_app): nonlocal application try: application = Application() apply_application_actions(application, gtk_app) except Exception: gtk_app.quit() raise def app_activate(gtk_app): assert application if not application.has_sessions(): gtk_app.open([], "__new__") def app_open(gtk_app, files, n_files, hint): session = new_session() file_manager = session.get_service("file_manager") if hint == "__new__": file_manager.new() else: assert n_files == 1 for file in files: file_manager.load(file.get_path()) gtk_app = Gtk.Application(application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.HANDLES_OPEN) add_main_options(gtk_app) gtk_app.connect("startup", app_startup) gtk_app.connect("activate", app_activate) gtk_app.connect("open", app_open) gtk_app.run(args)
def main(): def upload_screenshot(app): b64ss = takeScreenshot() r = requests.post('{}/upload'.format(SERVER_ADDRESS), json={'image': b64ss}) if 300 > r.status_code > 199: res = r.json() return "{}/get/{}".format(SERVER_ADDRESS, res.get('slug', '')) raise Exception() def on_active(app): win = Gtk.ApplicationWindow(application=app) clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) grid = Gtk.Grid() label = Gtk.Label( label= "SCREENSHOTS GO BURRRR\nYOU HAVE NEVER SEEN SCREENSHOTS BURRRR LIKE THIS EVER BEFORE!" ) btn = Gtk.Button(label="Take Screenshot") btn.connect('clicked', lambda x: clipboard.set_text(upload_screenshot(app), -1)) # Adding elements to the grid grid.attach(label, 0, 0, 1, 1) grid.attach(btn, 0, 1, 1, 1) grid.set_margin_top(10) grid.set_margin_left(10) grid.set_margin_right(10) grid.set_margin_bottom(10) label.set_margin_bottom(10) win.add(grid) win.show_all() app = Gtk.Application(application_id='com.imagebin.ScreenshotUtil') app.connect('activate', on_active) app.run(None)
def __init__(self, bootstrap, options, initial=True): global _shell _shell = self self._appname = None self._bootstrap = bootstrap self._dbconn = ShellDatabaseConnection(options=options) self._blocked_apps = [] self._hidden_apps = [] self._login = None self._options = options self._user = None app = Gtk.Application.get_default() if not app: app = Gtk.Application() Gtk.Application.set_default(app) self._app = app self._app.connect('activate', self._on_app__activate) self.windows = []
def launch_eovpn(): app = Gtk.Application(application_id='com.github.jkotra.eovpn', flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE) app.add_main_option("debug", ord("d"), GLib.OptionFlags.NONE, GLib.OptionArg.STRING, "Show Debug Messages.", "[CRITICAL|ERROR|WARNING|INFO|DEBUG]") app.add_main_option("config", ord("c"), GLib.OptionFlags.NONE, GLib.OptionArg.NONE, "OpenVPN configuration file.", "[*.ovpn]") app.connect('activate', on_activate) app.connect('command-line', do_command_line) #handle --config -c parser = argparse.ArgumentParser(prog="eovpn", add_help=False) parser.add_argument('-c', '--config', nargs="?", dest='openvpn_config', type=str, action='store', help="openvpn config file.", default=None, required=False) args, _ = parser.parse_known_args(sys.argv[1:]) if args.openvpn_config is not None: try: #single line validation ;) assert open(args.openvpn_config, "r").read().split("\n")[0] == "client" set_standalone(args.openvpn_config) except Exception as e: logger.error(e) # as glib dont support our custom command, remove these from sys.argv. # the above declared `add_main_option` is essentially a dummy placeholder. if "-c" in sys.argv: sys.argv.remove("-c") if "--config" in sys.argv: sys.argv.remove("--config") exit_code = app.run(sys.argv) return exit_code
def __init__(self, name, app_id, icon=None, startup=None, document_types=None): # Set the icon for the app Icon.app_icon = Icon.load(icon, default=TIBERIUS_ICON) super().__init__( name=name, app_id=app_id, icon=Icon.app_icon, startup=startup, document_types=document_types ) # Stimulate the build of the app self._impl = Gtk.Application(application_id=self.app_id, flags=Gio.ApplicationFlags.FLAGS_NONE) # Connect the GTK signal that will cause app startup to occur self._impl.connect('startup', self._startup) self._impl.connect('activate', self._activate) # self._impl.connect('shutdown', self._shutdown) self._actions = None
def __init__(self, *args, **kwargs): GLib.set_application_name(APPLET_NAME) super().__init__(*args, application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) if os.path.exists("%s/metadata.json" % APPLET_DIR): raw_data = open("%s/metadata.json" % APPLET_DIR).read() try: self.extension_meta = json.loads(raw_data) except Exception: self.extension_meta = None else: self.extension_meta = None self.application = Gtk.Application() self.application.connect("activate", self.do_activate) self.application.connect("startup", self.do_startup) self.settings = Settings().get_settings()
def __init__(self, config, *args, **kwargs): """Summary Parameters ---------- config : TYPE Description *args Description **kwargs Description """ self.config = config GLib.set_application_name(_("Feeds Reader (Fork By Odyseus)")) super().__init__(*args, application_id=APPLICATION_ID, flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs) self.application = Gtk.Application() self.application.connect("startup", self.do_startup) self.application.connect("activate", self.do_activate)
def run(application, model): gtk_app = Gtk.Application( application_id="org.gaphor.Gaphor", flags=Gio.ApplicationFlags.FLAGS_NONE ) def app_startup(app): application.init() def app_activate(app): # Make sure gui is loaded ASAP. # This prevents menu items from appearing at unwanted places. main_window = application.get_service("main_window") main_window.open(app) app.add_window(main_window.window) file_manager = application.get_service("file_manager") if model: file_manager.load(model) else: file_manager.action_new() def app_shutdown(app): application.shutdown() def app_quit(action, param): file_manager = application.get_service("file_manager") return file_manager.file_quit() action = Gio.SimpleAction.new("quit", None) action.connect("activate", app_quit) gtk_app.add_action(action) gtk_app.connect("startup", app_startup) gtk_app.connect("activate", app_activate) gtk_app.connect("shutdown", app_shutdown) gtk_app.run()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._app = Gtk.Application() self._app.set_application_id('qubes.qrexec-policy-agent') self._app.register()