def __init__(self, run_callback=None, can_share=False):
self.run_callback = run_callback
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 150)
self.window.set_title("Start New Command")
icon_pixbuf = self.get_icon("forward.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(0)
# Label:
label = gtk.Label("Command to run:")
label.modify_font(pango.FontDescription("sans 14"))
al = gtk.Alignment(xalign=0, yalign=0.5, xscale=0.0, yscale=0)
al.add(label)
vbox.add(al)
# Actual command:
self.entry = gtk.Entry()
self.entry.set_max_length(255)
self.entry.set_width_chars(32)
self.entry.connect('activate', self.run_command)
vbox.add(self.entry)
if can_share:
self.share = gtk.CheckButton("Shared", use_underline=False)
#Shared commands will also be shown to other clients
self.share.set_active(True)
vbox.add(self.share)
else:
self.share = None
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
btn = gtk.Button(label)
btn.set_tooltip_text(tooltip)
btn.connect("clicked", callback)
if icon_name:
icon = self.get_icon(icon_name)
if icon:
btn.set_image(scaled_image(icon, 24))
hbox.pack_start(btn)
return btn
btn("Run", "Run this command", self.run_command, "forward.png")
btn("Cancel", "", self.close, "quit.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
def __init__(self, title="Title", prompt="", info=[], icon="", buttons=[]):
if is_gtk3():
self.window = gtk.Window(type=WINDOW_TOPLEVEL)
else:
self.window = gtk.Window(WINDOW_TOPLEVEL)
window_defaults(self.window)
self.window.set_position(WIN_POS_CENTER)
self.window.connect("destroy", self.quit)
self.window.set_default_size(400, 150)
self.window.set_title(title)
self.window.set_modal(True)
if icon:
icon_pixbuf = self.get_icon(icon)
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(10)
def al(label, font="sans 14", xalign=0):
l = gtk.Label(label)
l.modify_font(pango.FontDescription(font))
al = gtk.Alignment(xalign=xalign, yalign=0.5, xscale=0.0, yscale=0)
al.add(l)
vbox.add(al)
#window title is visible so this would be redundant:
#al(title, "sans 18", 0.5)
al(prompt, "sans 14")
self.password_input = gtk.Entry()
self.password_input.set_max_length(255)
self.password_input.set_width_chars(32)
self.password_input.connect('activate', self.activate)
self.password_input.set_visibility(False)
vbox.add(self.password_input)
# Buttons:
self.exit_code = 0
hbox = gtk.HBox(False, 0)
al = gtk.Alignment(xalign=1, yalign=0.5, xscale=0, yscale=0)
al.add(hbox)
vbox.pack_start(al)
for label, isdefault, cb in [
("Confirm", True, self.activate),
("Cancel", False, self.quit),
]:
b = self.btn(label, isdefault, cb)
hbox.pack_start(b)
add_close_accel(self.window, self.quit)
vbox.show_all()
self.window.add(vbox)
def __init__(self, show_file_upload_cb=None):
self.show_file_upload_cb = show_file_upload_cb
self.populate_timer = None
self.table = None
self.requests = []
self.expire_labels = {}
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("delete-event", self.close)
self.window.set_default_size(400, 150)
self.window.set_title("Transfers")
icon_pixbuf = self.get_icon("download.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(10)
self.alignment = gtk.Alignment(xalign=0.5,
yalign=0.5,
xscale=1.0,
yscale=1.0)
vbox.pack_start(self.alignment, expand=True, fill=True)
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
b = self.btn(label, tooltip, callback, icon_name)
hbox.pack_start(b)
if self.show_file_upload_cb:
btn("Upload", "", self.show_file_upload_cb, "upload.png")
btn("Close", "", self.close, "quit.png")
downloads = get_download_dir()
if downloads:
btn("Show Downloads Folder", "", self.show_downloads, "browse.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
self.populate_table()
def __init__(self, title="Title", prompt="", info=(), icon="", buttons=()):
if is_gtk3():
self.window = gtk.Window(type=WINDOW_POPUP)
else:
self.window = gtk.Window(WINDOW_POPUP)
window_defaults(self.window)
self.window.set_position(WIN_POS_CENTER)
self.window.connect("delete-event", self.quit)
self.window.set_default_size(400, 150)
self.window.set_title(title)
#self.window.set_modal(True)
if icon:
icon_pixbuf = self.get_icon(icon)
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(10)
def al(label, font="sans 14", xalign=0):
l = gtk.Label(label)
l.modify_font(pango.FontDescription(font))
if label.startswith("WARNING"):
red = color_parse("red")
l.modify_fg(STATE_NORMAL, red)
al = gtk.Alignment(xalign=xalign, yalign=0.5, xscale=0.0, yscale=0)
al.add(l)
vbox.add(al)
al(title, "sans 18", 0.5)
al(info, "sans 14")
al(prompt, "sans 14")
# Buttons:
self.exit_code = 0
if buttons:
hbox = gtk.HBox(False, 0)
al = gtk.Alignment(xalign=1, yalign=0.5, xscale=0, yscale=0)
al.add(hbox)
vbox.pack_start(al)
for label, code in buttons:
b = self.btn(label, "", code)
hbox.pack_start(b)
add_close_accel(self.window, self.quit)
vbox.show_all()
self.window.add(vbox)
def __init__(self):
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 200)
self.window.set_title("Xpra Version Check")
icon = self.get_icon("update.png")
if icon:
self.window.set_icon(icon)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(0)
# Label:
self.progress = 0
self.label = gtk.Label("Version Check")
self.label.modify_font(pango.FontDescription("sans 14"))
al = gtk.Alignment(xalign=0, yalign=0.5, xscale=0.0, yscale=0)
al.add(self.label)
vbox.add(al)
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
btn = gtk.Button(label)
btn.set_tooltip_text(tooltip)
btn.connect("clicked", callback)
if icon_name:
icon = self.get_icon(icon_name)
if icon:
btn.set_image(scaled_image(icon, 24))
hbox.pack_start(btn)
return btn
btn("Download", "Show download page", self.download, "download.png")
btn("Close", "", self.close, "quit.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
def __init__(self, client):
assert client
self.client = client
self.populate_timer = None
self.commands_info = {}
self.table = None
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 150)
self.window.set_title("Server Commands")
icon_pixbuf = self.get_icon("list.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(10)
self.alignment = gtk.Alignment(xalign=0.5,
yalign=0.5,
xscale=1.0,
yscale=1.0)
vbox.pack_start(self.alignment, expand=True, fill=True)
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
b = self.btn(label, tooltip, callback, icon_name)
hbox.pack_start(b)
if self.client.server_start_new_commands:
btn("Start New", "Run a command on the server",
self.client.show_start_new_command, "forward.png")
btn("Close", "", self.close, "quit.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
def __init__(self):
assert not WIN32 and not OSX
gtk.Window.__init__(self)
window_defaults(self)
self.set_title("Start Xpra Session")
self.set_position(WIN_POS_CENTER)
self.set_size_request(640, 300)
icon = get_pixbuf("xpra")
if icon:
self.set_icon(icon)
self.connect("destroy", self.close)
add_close_accel(self, self.close)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(0)
hbox = gtk.HBox(True, 10)
self.seamless_btn = gtk.RadioButton(None, "Seamless Session")
self.seamless_btn.connect("toggled", self.seamless_toggled)
al = gtk.Alignment(xalign=1, yalign=0.5, xscale=0.0, yscale=0)
al.add(self.seamless_btn)
hbox.add(al)
self.desktop_btn = gtk.RadioButton(self.seamless_btn,
"Desktop Session")
#since they're radio buttons, both get toggled,
#so no need to connect to both signals:
#self.desktop.connect("toggled", self.desktop_toggled)
hbox.add(self.desktop_btn)
self.seamless = True
vbox.add(hbox)
# Label:
self.entry_label = gtk.Label("Command to run:")
self.entry_label.modify_font(pango.FontDescription("sans 14"))
self.entry_al = gtk.Alignment(xalign=0,
yalign=0.5,
xscale=0.0,
yscale=0)
self.entry_al.add(self.entry_label)
vbox.add(self.entry_al)
# input command directly as text (if pyxdg is not installed):
self.entry = gtk.Entry()
self.entry.set_max_length(255)
self.entry.set_width_chars(32)
self.entry.connect('activate', self.run_command)
vbox.add(self.entry)
# or use menus if we have xdg data:
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
self.category_box = hbox
self.category_label = gtk.Label("Category:")
self.category_combo = gtk.combo_box_new_text()
hbox.add(self.category_label)
hbox.add(self.category_combo)
self.category_combo.connect("changed", self.category_changed)
self.categories = {}
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
self.command_box = hbox
self.command_label = gtk.Label("Command:")
self.command_combo = gtk.combo_box_new_text()
hbox.pack_start(self.command_label)
hbox.pack_start(self.command_combo)
self.command_combo.connect("changed", self.command_changed)
self.commands = {}
self.xsessions = None
self.desktop_entry = None
# start options:
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
self.attach_cb = gtk.CheckButton()
self.attach_cb.set_label("attach immediately")
self.attach_cb.set_active(True)
al = gtk.Alignment(xalign=1, yalign=0.5, xscale=0.0, yscale=0)
al.add(self.attach_cb)
hbox.add(al)
self.exit_with_children_cb = gtk.CheckButton()
self.exit_with_children_cb.set_label("exit with children")
hbox.add(self.exit_with_children_cb)
self.exit_with_children_cb.set_active(True)
#maybe add:
#clipboard, opengl, sharing?
# Action buttons:
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
def btn(label, tooltip, callback, icon_name=None):
btn = gtk.Button(label)
set_tooltip_text(btn, tooltip)
btn.connect("clicked", callback)
if icon_name:
icon = get_pixbuf(icon_name)
if icon:
btn.set_image(scaled_image(icon, 24))
hbox.pack_start(btn)
return btn
self.cancel_btn = btn("Cancel", "", self.close, "quit.png")
self.run_btn = btn("Start", "Start this command in an xpra session",
self.run_command, "forward.png")
self.run_btn.set_sensitive(False)
vbox.show_all()
self.add(vbox)
def setup_window(self):
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 300)
self.window.set_title("Xpra Bug Report")
icon_pixbuf = self.get_icon("bugs.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(15)
# Title
hbox = gtk.HBox(False, 0)
icon_pixbuf = self.get_icon("xpra.png")
if icon_pixbuf and self.show_about:
from xpra.gtk_common.about import about
logo_button = gtk.Button("")
settings = logo_button.get_settings()
settings.set_property('gtk-button-images', True)
logo_button.connect("clicked", about)
logo_button.set_tooltip_text("About")
image = gtk.Image()
image.set_from_pixbuf(icon_pixbuf)
logo_button.set_image(image)
hbox.pack_start(logo_button, expand=False, fill=False)
label = gtk.Label("Xpra Bug Report Tool")
label.modify_font(pango.FontDescription("sans 14"))
hbox.pack_start(label, expand=True, fill=True)
vbox.pack_start(hbox)
#the box containing all the input:
ibox = gtk.VBox(False, 0)
ibox.set_spacing(3)
vbox.pack_start(ibox)
# Description
al = gtk.Alignment(xalign=0, yalign=0.5, xscale=0.0, yscale=0)
al.add(gtk.Label("Please describe the problem:"))
ibox.pack_start(al)
#self.description = gtk.Entry(max=128)
#self.description.set_width_chars(40)
self.description = gtk.TextView()
self.description.set_accepts_tab(True)
self.description.set_justification(JUSTIFY_LEFT)
self.description.set_border_width(2)
self.description.set_size_request(300, 80)
#self.description.modify_bg(STATE_NORMAL, gdk.Color(red=32768, green=32768, blue=32768))
ibox.pack_start(self.description, expand=False, fill=False)
# Toggles:
al = gtk.Alignment(xalign=0, yalign=0.5, xscale=0.0, yscale=0)
al.add(gtk.Label("Include:"))
ibox.pack_start(al)
#generic toggles:
from xpra.gtk_common.keymap import get_gtk_keymap
from xpra.codecs.loader import codec_versions, load_codecs
load_codecs()
try:
from xpra.sound.wrapper import query_sound
def get_sound_info():
return query_sound()
except:
get_sound_info = None
def get_gl_info():
if self.opengl_info:
return self.opengl_info
try:
from xpra.client.gl.gtk_base.gtkgl_check import check_support
return check_support(force_enable=True)
except Exception as e:
return {"error": str(e)}
from xpra.net.net_util import get_info as get_net_info
from xpra.platform.paths import get_info as get_path_info
from xpra.platform.gui import get_info as get_gui_info
from xpra.version_util import get_version_info, get_platform_info, get_host_info
def get_sys_info():
from xpra.platform.info import get_user_info
from xpra.scripts.config import read_xpra_defaults
return {
"argv": sys.argv,
"path": sys.path,
"exec_prefix": sys.exec_prefix,
"executable": sys.executable,
"version": get_version_info(),
"platform": get_platform_info(),
"host": get_host_info(),
"paths": get_path_info(),
"gtk": get_gtk_version_info(),
"gui": get_gui_info(),
"display": get_display_info(),
"user": get_user_info(),
"env": os.environ,
"config": read_xpra_defaults(),
}
get_screenshot, take_screenshot_fn = None, None
#screenshot: may have OS-specific code
try:
from xpra.platform.gui import take_screenshot
take_screenshot_fn = take_screenshot
except:
log("failed to load platfrom specific screenshot code",
exc_info=True)
if not take_screenshot_fn:
#try with Pillow:
try:
from PIL import ImageGrab #@UnresolvedImport
from xpra.os_util import StringIOClass
def pillow_imagegrab_screenshot():
img = ImageGrab.grab()
out = StringIOClass()
img.save(out, format="PNG")
v = out.getvalue()
out.close()
return (img.width, img.height, "png", img.width * 3, v)
take_screenshot_fn = pillow_imagegrab_screenshot
except Exception as e:
log("cannot use Pillow's ImageGrab: %s", e)
if not take_screenshot_fn:
#default: gtk screen capture
try:
from xpra.server.shadow.gtk_root_window_model import GTKImageCapture
rwm = GTKImageCapture(get_default_root_window())
take_screenshot_fn = rwm.take_screenshot
except:
log.warn("Warning: failed to load gtk screenshot code",
exc_info=True)
log("take_screenshot_fn=%s", take_screenshot_fn)
if take_screenshot_fn:
def get_screenshot():
#take_screenshot() returns: w, h, "png", rowstride, data
return take_screenshot_fn()[4]
self.toggles = (
("system", "txt", "System", get_sys_info,
"Xpra version, platform and host information"),
("network", "txt", "Network", get_net_info,
"Compression, packet encoding and encryption"),
("encoding", "txt", "Encodings", codec_versions,
"Picture encodings supported"),
("opengl", "txt", "OpenGL", get_gl_info,
"OpenGL driver and features"),
("sound", "txt", "Sound", get_sound_info,
"Sound codecs and GStreamer version information"),
("keyboard", "txt", "Keyboard Mapping", get_gtk_keymap,
"Keyboard layout and key mapping"),
("xpra-info", "txt", "Server Info", self.get_server_info,
"Full server information from 'xpra info'"),
("screenshot", "png", "Screenshot", get_screenshot, ""),
)
for name, _, title, value_cb, tooltip in self.toggles:
cb = gtk.CheckButton(title +
[" (not available)", ""][bool(value_cb)])
cb.set_active(self.includes.get(name, True))
cb.set_sensitive(bool(value_cb))
cb.set_tooltip_text(tooltip)
ibox.pack_start(cb)
setattr(self, name, cb)
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
btn = gtk.Button(label)
btn.set_tooltip_text(tooltip)
btn.connect("clicked", callback)
if icon_name:
icon = self.get_icon(icon_name)
if icon:
btn.set_image(scaled_image(icon, 24))
hbox.pack_start(btn)
return btn
if not is_gtk3():
#clipboard does not work in gtk3..
btn("Copy to clipboard", "Copy all data to clipboard",
self.copy_clicked, "clipboard.png")
btn("Save", "Save Bug Report", self.save_clicked, "download.png")
btn("Cancel", "", self.close, "quit.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
def __init__(self, run_callback=None, can_share=False, xdg_menu=None):
self.run_callback = run_callback
self.xdg_menu = xdg_menu
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 150)
self.window.set_title("Start New Command")
icon_pixbuf = self.get_icon("forward.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(0)
if xdg_menu:
# or use menus if we have xdg data:
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
hbox.add(gtk.Label("Category:"))
self.category_combo = gtk.combo_box_new_text()
hbox.add(self.category_combo)
for name in sorted(xdg_menu.keys()):
self.category_combo.append_text(name.decode("utf-8"))
self.category_combo.set_active(0)
self.category_combo.connect("changed", self.category_changed)
hbox = gtk.HBox(False, 20)
vbox.add(hbox)
self.command_combo = gtk.combo_box_new_text()
hbox.pack_start(gtk.Label("Command:"))
hbox.pack_start(self.command_combo)
#this will populate the command combo:
self.category_changed()
else:
entry_label = gtk.Label("Command to run:")
entry_label.modify_font(pango.FontDescription("sans 14"))
entry_al = gtk.Alignment(xalign=0,
yalign=0.5,
xscale=0.0,
yscale=0)
entry_al.add(entry_label)
vbox.add(entry_al)
# Actual command:
self.entry = gtk.Entry()
self.entry.set_max_length(255)
self.entry.set_width_chars(32)
self.entry.connect('activate', self.run_command)
vbox.add(self.entry)
if can_share:
self.share = gtk.CheckButton("Shared", use_underline=False)
#Shared commands will also be shown to other clients
self.share.set_active(True)
vbox.add(self.share)
else:
self.share = None
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
def btn(label, tooltip, callback, icon_name=None):
btn = gtk.Button(label)
btn.set_tooltip_text(tooltip)
btn.connect("clicked", callback)
if icon_name:
icon = self.get_icon(icon_name)
if icon:
btn.set_image(scaled_image(icon, 24))
hbox.pack_start(btn)
return btn
btn("Run", "Run this command", self.run_command, "forward.png")
btn("Cancel", "", self.close, "quit.png")
def accel_close(*_args):
self.close()
add_close_accel(self.window, accel_close)
vbox.show_all()
self.window.vbox = vbox
self.window.add(vbox)
def do_create_window(self):
self.window = gtk.Window()
window_defaults(self.window)
self.window.connect("destroy", self.destroy)
self.window.set_default_size(400, 260)
self.window.set_title("Xpra Launcher")
self.window.set_position(WIN_POS_CENTER)
vbox = gtk.VBox(False, 0)
vbox.set_spacing(15)
#top row:
hbox = gtk.HBox(False, 0)
# About dialog (and window icon):
icon_pixbuf = self.get_icon("xpra.png")
if icon_pixbuf:
self.window.set_icon(icon_pixbuf)
logo_button = self.image_button("", "About", icon_pixbuf, about)
hbox.pack_start(logo_button, expand=False, fill=False)
# Bug report tool link:
icon_pixbuf = self.get_icon("bugs.png")
self.bug_tool = None
if icon_pixbuf:
def bug(*_args):
if self.bug_tool == None:
from xpra.client.gtk_base.bug_report import BugReport
self.bug_tool = BugReport()
self.bug_tool.init(show_about=False)
self.bug_tool.show()
bug_button = self.image_button("", "Bug Report", icon_pixbuf, bug)
hbox.pack_start(bug_button, expand=False, fill=False)
# Session browser link:
icon_pixbuf = self.get_icon("mdns.png")
self.mdns_gui = None
if icon_pixbuf and has_mdns():
def mdns(*_args):
if self.mdns_gui == None:
from xpra.client.gtk_base.mdns_gui import mdns_sessions
self.mdns_gui = mdns_sessions(self.config)
def close_mdns():
self.mdns_gui.destroy()
self.mdns_gui = None
self.mdns_gui.do_quit = close_mdns
else:
self.mdns_gui.present()
mdns_button = self.image_button("", "Browse Sessions", icon_pixbuf,
mdns)
hbox.pack_start(mdns_button, expand=False, fill=False)
# Title
label = gtk.Label("Connect to xpra server")
label.modify_font(pango.FontDescription("sans 14"))
hbox.pack_start(label, expand=True, fill=True)
vbox.pack_start(hbox)
# Mode:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("Mode: "))
self.mode_combo = gtk.combo_box_new_text()
for x in self.get_connection_modes():
self.mode_combo.append_text(x.upper())
self.mode_combo.connect("changed", self.mode_changed)
hbox.pack_start(self.mode_combo)
vbox.pack_start(hbox)
# Username@Host:Port
hbox = gtk.HBox(False, 0)
hbox.set_spacing(5)
self.username_entry = gtk.Entry()
self.username_entry.set_max_length(128)
self.username_entry.set_width_chars(16)
self.username_entry.connect("changed", self.validate)
self.username_entry.connect("activate", self.connect_clicked)
self.username_entry.set_tooltip_text("username")
self.username_label = gtk.Label("@")
self.host_entry = gtk.Entry()
self.host_entry.set_max_length(128)
self.host_entry.set_width_chars(24)
self.host_entry.connect("changed", self.validate)
self.host_entry.connect("activate", self.connect_clicked)
self.host_entry.set_tooltip_text("hostname")
self.ssh_port_entry = gtk.Entry()
self.ssh_port_entry.set_max_length(5)
self.ssh_port_entry.set_width_chars(5)
self.ssh_port_entry.connect("changed", self.validate)
self.ssh_port_entry.connect("activate", self.connect_clicked)
self.ssh_port_entry.set_tooltip_text("SSH port")
self.port_entry = gtk.Entry()
self.port_entry.set_max_length(5)
self.port_entry.set_width_chars(5)
self.port_entry.connect("changed", self.validate)
self.port_entry.connect("activate", self.connect_clicked)
self.port_entry.set_tooltip_text("port/display")
hbox.pack_start(self.username_entry)
hbox.pack_start(self.username_label)
hbox.pack_start(self.host_entry)
hbox.pack_start(self.ssh_port_entry)
hbox.pack_start(gtk.Label(":"))
hbox.pack_start(self.port_entry)
vbox.pack_start(hbox)
# Password
hbox = gtk.HBox(False, 0)
hbox.set_spacing(20)
self.password_entry = gtk.Entry()
self.password_entry.set_max_length(128)
self.password_entry.set_width_chars(30)
self.password_entry.set_text("")
self.password_entry.set_visibility(False)
self.password_entry.connect("changed", self.password_ok)
self.password_entry.connect("changed", self.validate)
self.password_label = gtk.Label("Password: "******"Disable Strict Host Key Check")
self.nostrict_host_check.set_active(False)
al = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0, yscale=0)
al.add(self.nostrict_host_check)
hbox.pack_start(al)
vbox.pack_start(hbox)
# Info Label
self.info = gtk.Label()
self.info.set_line_wrap(True)
self.info.set_size_request(360, -1)
self.info.modify_fg(STATE_NORMAL, red)
vbox.pack_start(self.info)
#hide encoding options by default
self.encoding_combo = None
self.encoding_options_check = None
self.encoding_box = None
if not PYTHON3:
#not implemented for gtk3, where we can't use set_menu()...
hbox = gtk.HBox(False, 0)
hbox.set_spacing(20)
self.encoding_options_check = gtk.CheckButton(
"Advanced Encoding Options")
self.encoding_options_check.connect("toggled",
self.encoding_options_toggled)
self.encoding_options_check.set_active(False)
al = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0, yscale=0)
al.add(self.encoding_options_check)
hbox.pack_start(al)
vbox.pack_start(hbox)
self.encoding_box = gtk.VBox()
vbox.pack_start(self.encoding_box)
# Encoding:
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
hbox.pack_start(gtk.Label("Encoding: "))
self.encoding_combo = OptionMenu()
def get_current_encoding():
return self.config.encoding
def set_new_encoding(e):
self.config.encoding = e
encodings = ["auto"] + [x for x in PREFERED_ENCODING_ORDER]
server_encodings = encodings
es = make_encodingsmenu(get_current_encoding, set_new_encoding,
encodings, server_encodings)
self.encoding_combo.set_menu(es)
set_history_from_active(self.encoding_combo)
hbox.pack_start(self.encoding_combo)
self.encoding_box.pack_start(hbox)
self.encoding_combo.connect("changed", self.encoding_changed)
# Quality
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
self.quality_label = gtk.Label("Quality: ")
hbox.pack_start(self.quality_label)
self.quality_combo = OptionMenu()
def set_min_quality(q):
self.config.min_quality = q
def set_quality(q):
self.config.quality = q
def get_min_quality():
return self.config.min_quality
def get_quality():
return self.config.quality
sq = make_min_auto_menu("Quality", MIN_QUALITY_OPTIONS,
QUALITY_OPTIONS, get_min_quality,
get_quality, set_min_quality, set_quality)
self.quality_combo.set_menu(sq)
set_history_from_active(self.quality_combo)
hbox.pack_start(self.quality_combo)
self.encoding_box.pack_start(hbox)
# Speed
hbox = gtk.HBox(False, 20)
hbox.set_spacing(20)
self.speed_label = gtk.Label("Speed: ")
hbox.pack_start(self.speed_label)
self.speed_combo = OptionMenu()
def set_min_speed(s):
self.config.min_speed = s
def set_speed(s):
self.config.speed = s
def get_min_speed():
return self.config.min_speed
def get_speed():
return self.config.speed
ss = make_min_auto_menu("Speed", MIN_SPEED_OPTIONS, SPEED_OPTIONS,
get_min_speed, get_speed, set_min_speed,
set_speed)
self.speed_combo.set_menu(ss)
set_history_from_active(self.speed_combo)
hbox.pack_start(self.speed_combo)
self.encoding_box.pack_start(hbox)
self.encoding_box.hide()
# Buttons:
hbox = gtk.HBox(False, 20)
vbox.pack_start(hbox)
#Save:
self.save_btn = gtk.Button("Save")
self.save_btn.set_tooltip_text("Save settings to a session file")
self.save_btn.connect("clicked", self.save_clicked)
hbox.pack_start(self.save_btn)
#Load:
self.load_btn = gtk.Button("Load")
self.load_btn.set_tooltip_text("Load settings from a session file")
self.load_btn.connect("clicked", self.load_clicked)
hbox.pack_start(self.load_btn)
# Connect button:
self.connect_btn = gtk.Button("Connect")
self.connect_btn.connect("clicked", self.connect_clicked)
connect_icon = self.get_icon("retry.png")
if connect_icon:
self.connect_btn.set_image(scaled_image(connect_icon, 24))
hbox.pack_start(self.connect_btn)
add_close_accel(self.window, self.accel_close)
vbox.show_all()
self.encoding_options_toggled()
self.window.vbox = vbox
self.window.add(vbox)
