def main(argv=()):
from xpra.platform import program_context
with program_context("Xpra-Bug-Report", "Xpra Bug Report"):
from xpra.log import enable_color
enable_color()
from xpra.log import enable_debug_for
#logging init:
if "-v" in argv:
enable_debug_for("util")
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
gtk_main_quit_on_fatal_exceptions_enable()
from xpra.client.gtk_base.bug_report import BugReport
from xpra.gtk_common.gobject_compat import register_os_signals
app = BugReport()
app.close = app.quit
app.init(True)
register_os_signals(app.quit)
try:
from xpra.platform.gui import ready as gui_ready
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def main(argv=()):
from xpra.os_util import POSIX, OSX
from xpra.platform import program_context
from xpra.platform.gui import init, set_default_icon
with program_context("Xpra-Bug-Report", "Xpra Bug Report"):
from xpra.log import enable_color
enable_color()
if POSIX and not OSX:
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
set_default_icon("bugs.png")
init()
from xpra.log import enable_debug_for
#logging init:
if "-v" in argv:
enable_debug_for("util")
from xpra.client.gtk_base.bug_report import BugReport
from xpra.gtk_common.gobject_compat import register_os_signals
app = BugReport()
app.close = app.quit
app.init(True)
register_os_signals(app.quit, "Bug Report")
try:
from xpra.platform.gui import ready as gui_ready
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def show_pass_dialog(argv):
from xpra.platform.gui import ready as gui_ready, init as gui_init, set_default_icon
set_default_icon("authentication.png")
gui_init()
log("show_pass_dialog(%s)", argv)
def arg(n):
if len(argv) <= n:
return ""
return argv[n].replace("\\n\\r", "\\n").replace("\\n", "\n")
title = arg(0) or "Enter Password"
prompt = arg(1)
icon = arg(2)
app = PasswordInputDialogWindow(title, prompt, icon)
register_os_signals(app.quit, "Password Dialog")
gui_ready()
app.show()
p = app.run()
if p is not None:
sys.stdout.write(p)
sys.stdout.flush()
return 0
return 1
def show_confirm_dialog(argv):
from xpra.platform.gui import ready as gui_ready
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
from xpra.platform.gui import init as gui_init
gui_init()
gtk_main_quit_on_fatal_exceptions_enable()
log("show_confirm_dialog(%s)", argv)
def arg(n):
if len(argv)<=n:
return ""
return argv[n].replace("\\n\\r", "\\n").replace("\\n", "\n")
title = arg(0) or "Confirm Key"
prompt = arg(1)
info = arg(2)
icon = arg(3)
buttons = []
n = 4
while len(argv)>(n+1):
label = arg(n)
try:
code = int(arg(n+1))
except ValueError as e:
log.error("Error: confirm dialog cannot parse code '%s': %s", arg(n+1), e)
return 1
buttons.append((label, code))
n += 2
app = ConfirmDialogWindow(title, prompt, info, icon, buttons)
register_os_signals(app.quit)
gui_ready()
force_focus()
app.show()
return app.run()
def show_pass_dialog(argv):
from xpra.platform.gui import ready as gui_ready
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
from xpra.platform.gui import init as gui_init, set_default_icon
set_default_icon("authentication.png")
gui_init()
gtk_main_quit_on_fatal_exceptions_enable()
log("show_pass_dialog(%s)", argv)
def arg(n):
if len(argv)<=n:
return ""
return argv[n].replace("\\n\\r", "\\n").replace("\\n", "\n")
title = arg(0) or "Enter Password"
prompt = arg(1)
icon = arg(2)
app = PasswordInputDialogWindow(title, prompt, icon)
register_os_signals(app.quit, "Password Dialog")
gui_ready()
app.show()
r = app.run()
if r==0:
password = app.get_password()
sys.stdout.write(password)
sys.stdout.flush()
return r
def main():
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init, ready as gui_ready
gui_init()
with program_context("Start-New-Command", "Start New Command"):
#logging init:
if "-v" in sys.argv:
from xpra.log import enable_debug_for
enable_debug_for("util")
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
gtk_main_quit_on_fatal_exceptions_enable()
app = OpenRequestsWindow()
def cb(accept):
print("callback: %s" % (accept, ))
app.add_request(cb, "1", "file", "someimage.png", 16384, False, True,
10)
app.add_request(cb, "2", "file", "otherimage.png", 16384, False, True,
100)
app.add_request(cb, "3", "file", "document.pdf", 32768, True, False,
200)
app.add_request(cb, "4", "url", "https://xpra.org/", 0, False, True,
300)
app.hide = app.quit
register_os_signals(app.quit)
try:
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def main(): # pragma: no cover
from xpra.platform import program_context
with program_context("AppIndicator-Test", "AppIndicator Test"):
if "-v" in sys.argv:
from xpra.log import enable_debug_for
enable_debug_for("tray")
from xpra.gtk_common.gobject_compat import register_os_signals
from gi.repository import Gtk
menu = Gtk.Menu()
item = Gtk.MenuItem(label="Top Menu Item 1")
submenu = Gtk.Menu()
item.set_submenu(submenu)
sub = Gtk.MenuItem(label="Sub Menu Item 1")
subsubmenu = Gtk.Menu()
sub.set_submenu(subsubmenu)
subsubmenu.append(Gtk.MenuItem(label="Sub Sub Menu Item 1"))
subsubmenu.append(Gtk.MenuItem(label="Sub Sub Menu Item 2"))
submenu.append(sub)
sub = Gtk.MenuItem(label="Sub Menu Item 2")
submenu.append(sub)
menu.append(item)
item = Gtk.MenuItem(label="Top Menu Item 2")
menu.append(item)
menu.show_all()
a = AppindicatorTray(None, None, menu, "test", "xpra.png", None, None,
None, Gtk.main_quit)
a.show()
register_os_signals(Gtk.main_quit)
Gtk.main()
def run(self):
from xpra.gtk_common.gobject_compat import register_os_signals
register_os_signals(self.signal_handler, None)
v = super().run()
self.log("run()=%s" % v)
self.cleanup()
return v
def main(): # pragma: no cover
from xpra.platform import program_context
from xpra.platform.gui import ready as gui_ready, init as gui_init
gui_init()
with program_context("Start-New-Command", "Start New Command"):
#logging init:
if "-v" in sys.argv:
enable_debug_for("util")
client = AdHocStruct()
client.server_last_info_time = monotonic_time()
commands_info = {
0: {
'returncode': None,
'name': 'xterm',
'pid': 542,
'dead': False,
'ignore': True,
'command': ('xterm', ),
'forget': False
},
'start-child': (),
'start-new': True,
'start-after-connect-done': True,
'start': ('xterm', ),
'start-after-connect': (),
'start-child-on-connect': (),
'exit-with-children': False,
'start-child-after-connect': (),
'start-on-connect': (),
}
client.server_last_info = {"commands": commands_info}
client.server_start_new_commands = True
client.server_commands_signals = ("SIGINT", "SIGTERM", "SIGUSR1")
def noop(*_args):
pass
client.send_info_request = noop
client.send = noop
window1 = AdHocStruct()
window1._metadata = {"pid": 542}
client._id_to_window = {1: window1}
def show_start_new_command(*_args):
from xpra.client.gtk_base.start_new_command import getStartNewCommand
getStartNewCommand(None).show()
client.show_start_new_command = show_start_new_command
app = ServerCommandsWindow(client)
app.close = app.quit
register_os_signals(app.quit)
try:
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def run(self):
register_os_signals(self.signal_handler, None)
v = super().run()
self.log("run()=%s" % v)
self.cleanup()
self.close_log()
return v
def do_main(opts):
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Xpra-Session-Browser", "Xpra Session Browser"):
enable_color()
gui = SessionsGUI(opts)
register_os_signals(gui.app_signal)
gtk_main()
log("do_main() gui.exit_code=%i", gui.exit_code)
return gui.exit_code
def main():
with program_context("font-rendering", "Font Rendering"):
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
w = FontWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("clicks", "Clicks"):
w = TestForm()
add_close_accel(w.window, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
def signal_handler(signal):
Gtk.main_quit()
register_os_signals(signal_handler)
Gtk.main()
def handle_signal(self, sig):
""" This is for OS signals SIGINT and SIGTERM """
#next time, just stop:
register_os_signals(self.signal_stop)
signame = SIGNAMES.get(sig, sig)
log("handle_signal(%s) calling stop from main thread", signame)
self.send("signal", signame)
self.timeout_add(0, self.cleanup)
#give time for the network layer to send the signal message
self.timeout_add(150, self.stop)
def main():
with program_context("tray", "Tray"):
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
FakeApplication()
Gtk.main()
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("initiate-moveresize", "Initiate Move-Resize"):
w = make_window()
w.show_all()
add_close_accel(w, Gtk.main_quit)
def signal_handler(signal):
Gtk.main_quit()
register_os_signals(signal_handler)
Gtk.main()
return 0
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("bell", "Bell"):
w = BellWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
def signal_handler(_signal):
Gtk.main_quit()
register_os_signals(signal_handler)
Gtk.main()
return 0
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("colors-plain", "Colors Plain"):
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
w = ColorPlainWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
def main():
with program_context("header-bar", "Header Bar"):
def signal_handler(*_args):
Gtk.main_quit()
from xpra.gtk_common.gobject_compat import register_os_signals
register_os_signals(signal_handler)
w = HeaderBarWindow()
w.connect("delete-event", Gtk.main_quit)
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
def __init__(self, input_filename="-", output_filename="-", wrapped_object=None, method_whitelist=None):
self.name = ""
self._input = None
self._output = None
self.input_filename = input_filename
self.output_filename = output_filename
self.method_whitelist = method_whitelist
self.large_packets = []
#the gobject instance which is wrapped:
self.wrapped_object = wrapped_object
self.send_queue = Queue()
self.protocol = None
register_os_signals(self.handle_signal)
self.setup_mainloop()
def main():
from xpra.platform.gui import init, set_default_icon
with program_context("transparent-window", "Transparent Window"):
set_default_icon("windows.png")
init()
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
w = TransparentWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
return 0
def main():
with program_context("window-opacity", "Window Opacity"):
w = make_window()
def show_with_focus():
force_focus()
w.show_all()
w.present()
add_close_accel(w, Gtk.main_quit)
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
GLib.idle_add(show_with_focus)
Gtk.main()
return 0
def main():
from xpra.platform.gui import init, set_default_icon
with program_context("colors", "Colors"):
set_default_icon("encoding.png")
init()
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler, "test window")
w = AnimatedColorWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
return 0
def main():
with program_context("file-chooser", "File Chooser"):
file_filter = Gtk.FileFilter()
file_filter.set_name("Xpra")
file_filter.add_pattern("*.xpra")
window = None
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
choose_file(window, "test", Gtk.FileChooserAction.OPEN, Gtk.STOCK_OPEN,
None)
return 0
def main(options=None): # pragma: no cover
assert POSIX and not OSX
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.platform.gui import init, ready
with program_context("xpra-start-gui", "Xpra Start GUI"):
enable_color()
init()
gui = DesktopGreeter()
register_os_signals(gui.app_signal)
ready()
gui.show()
gui.present()
Gtk.main()
log("do_main() gui.exit_code=%s", gui.exit_code)
return gui.exit_code
def main(): # pragma: no cover
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.platform.gui import init, ready
with program_context("xpra-start-gui", "Xpra Start GUI"):
enable_color()
init()
gui = StartSession()
register_os_signals(gui.app_signal)
ready()
gui.populate_menus()
gui.show()
gui.present()
Gtk.main()
log("do_main() gui.exit_code=%i", gui.exit_code)
return 0
def main():
from xpra.log import enable_color
from xpra.platform.gui import init, set_default_icon
with program_context("Clipboard-Test", "Clipboard Test Tool"):
enable_color()
set_default_icon("clipboard.png")
init()
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler, "test window")
w = ClipboardStateInfoWindow()
GLib.idle_add(w.show_with_focus)
Gtk.main()
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.platform.gui import init, ready, set_default_icon
with program_context("Xpra-Toolbox", "Xpra Toolbox"):
enable_color()
set_default_icon("toolbox.png")
init()
gui = ToolboxGUI()
register_os_signals(gui.app_signal, "Xpra Toolbox")
ready()
gui.show()
Gtk.main()
log("do_main() gui.exit_code=%i", gui.exit_code)
return gui.exit_code
def __init__(self,
title="Session Access Request",
info="unknown user from unknown location",
timeout=600):
Gtk.Window.__init__(self)
self.timeout = timeout
self.exit_code = 1
self.set_title(title)
self.set_border_width(20)
self.set_resizable(True)
self.set_decorated(True)
icon = get_icon_pixbuf("authentication.png")
if icon:
self.set_icon(icon)
add_close_accel(self, self.quit)
self.connect("delete_event", self.quit)
self.vbox = Gtk.VBox(False, 20)
self.add(self.vbox)
title_label = Gtk.Label(title)
title_label.modify_font(Pango.FontDescription("sans 14"))
self.vbox.add(title_label)
info_label = Gtk.Label(info)
info_label.modify_font(Pango.FontDescription("sans 12"))
self.vbox.add(info_label)
if self.timeout > 0:
self.timeout_label = Gtk.Label()
self.update_timeout()
self.vbox.add(self.timeout_label)
GLib.timeout_add(1000, self.update_timeout)
#buttons:
al = Gtk.Alignment(xalign=1.0, yalign=0.5, xscale=0.0, yscale=0.0)
al.set_padding(0, 0, 10, 10)
hbox = Gtk.HBox(False, 10)
al.add(hbox)
hbox.add(self.btn("Cancel", Gtk.STOCK_NO, self.cancel))
hbox.add(self.btn("Accept", Gtk.STOCK_OK, self.accept))
self.vbox.add(al)
register_os_signals(self.app_signal, "Authentication Dialog")
self.show_all()
def main(options=None): # pragma: no cover
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.platform.gui import init, ready
with program_context("xpra-start-gui", "Xpra Start GUI"):
enable_color()
init()
gui = StartSession(options)
register_os_signals(gui.app_signal)
ready()
gui.session_toggled()
if WIN32 or OSX:
gui.remote_btn.set_active(True)
gui.show()
gui.present()
Gtk.main()
log("do_main() gui.exit_code=%s", gui.exit_code)
return gui.exit_code
