def get_image(self, x, y, width, height, logger=None):
try:
start = time.time()
with xsync:
if USE_XSHM:
log("X11 shadow get_image, xshm=%s", self.xshm)
if self.xshm is None:
self.xshm = XImage.get_XShmWrapper(
get_xwindow(self.window))
self.xshm.setup()
if self.xshm:
image = self.xshm.get_image(get_xwindow(self.window),
x, y, width, height)
#discard to ensure we will call XShmGetImage next time around
self.xshm.discard()
return image
#fallback to gtk capture:
return GTKRootWindowModel.get_image(self, x, y, width, height,
logger)
except Exception as e:
log.warn("Warning: failed to capture root window pixels:")
log.warn(" %s", e)
#cleanup and hope for the best!
self.cleanup()
finally:
end = time.time()
log("X11 shadow captured %s pixels at %i MPixels/s using %s",
width * height,
(width * height / (end - start)) // 1024 // 1024,
["GTK", "XSHM"][USE_XSHM])
def get_image(self, x, y, width, height, logger=None):
try:
start = time.time()
with xsync:
if USE_XSHM:
log("X11 shadow get_image, xshm=%s", self.xshm)
if self.xshm is None:
self.xshm = XImage.get_XShmWrapper(get_xwindow(self.window))
self.xshm.setup()
if self.xshm:
image = self.xshm.get_image(get_xwindow(self.window), x, y, width, height)
#discard to ensure we will call XShmGetImage next time around
self.xshm.discard()
return image
#fallback to gtk capture:
return GTKRootWindowModel.get_image(self, x, y, width, height, logger)
except Exception as e:
log.warn("Warning: failed to capture root window pixels:")
log.warn(" %s", e)
#cleanup and hope for the best!
self.cleanup()
finally:
end = time.time()
log("X11 shadow captured %s pixels at %i MPixels/s using %s", width*height, (width*height/(end-start))//1024//1024, ["GTK", "XSHM"][USE_XSHM])
def __init__(self, root_window):
GTKRootWindowModel.__init__(self, root_window)
self.xshm = None
def __init__(self, root_window):
GTKRootWindowModel.__init__(self, root_window)
self.xshm = None
def setup_window(self):
self.window = gtk.Window()
self.window.connect("destroy", self.close)
self.window.set_default_size(400, 300)
self.window.set_border_width(20)
self.window.set_title("Xpra Bug Report")
self.window.modify_bg(STATE_NORMAL,
gdk.Color(red=65535, green=65535, blue=65535))
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
if self.opengl_info:
def get_gl_info():
return self.opengl_info
else:
try:
from xpra.client.gl.gl_check import check_support
def get_gl_info():
return check_support(force_enable=True)
except:
get_gl_info = None
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 GTKRootWindowModel
rwm = GTKRootWindowModel(gtk.gdk.get_default_root_window())
take_screenshot_fn = rwm.take_screenshot
except:
log("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 cleanup(self):
self.close_capture()
GTKRootWindowModel.cleanup(self)
def __init__(self, root_window):
GTKRootWindowModel.__init__(self, root_window)
self.geometry = root_window.get_geometry()[:4]
self.capture = None
def __init__(self, root_window):
GTKRootWindowModel.__init__(self, root_window)
screen = root_window.get_screen()
screen.connect("size-changed", self._screen_size_changed)
self.xshm = None
def get_image(self, x, y, width, height):
return GTKRootWindowModel.get_image(self.root_window_model, x, y,
width, height)
