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()
