def verify_capture(self, ss):
#verify capture works:
log("verify_capture(%s)", ss)
try:
capture = GTKImageCapture(self.root)
bdata = capture.take_screenshot()[-1]
nid = XPRA_DISPLAY_NOTIFICATION_ID
title = body = ""
if any(b != 0 for b in bdata):
log("verify_capture(%s) succeeded", ss)
if is_Wayland():
title = "Wayland Session Warning"
body = "Wayland sessions are not supported,\n"+\
"the screen capture is likely to be empty"
else:
log.warn("Warning: shadow screen capture is blank")
body = "The shadow display capture is blank"
if get_loaded_kernel_modules("vboxguest", "vboxvideo"):
body += "\nthis may be caused by the VirtualBox video driver."
title = "Shadow Capture Failure"
log("verify_capture: title=%r, body=%r", ss, title, body)
if title and body:
ss.may_notify(nid, title, body, icon_name="server")
except Exception as e:
ss.may_notify(nid,
"Shadow Error",
"Error shadowing the display:\n%s" % e,
icon_name="bugs")
def do_make_screenshot_packet(self):
capture = GTKImageCapture(self.root)
w, h, encoding, rowstride, data = capture.take_screenshot()
assert encoding == "png" #use fixed encoding for now
from xpra.net.compression import Compressed
return [
"screenshot", w, h, encoding, rowstride,
Compressed(encoding, data)
]
def setup_capture(window):
ww, wh = window.get_geometry()[2:4]
capture = None
if USE_NVFBC:
try:
log("setup_capture(%s) USE_NVFBC_CUDA=%s", window, USE_NVFBC_CUDA)
if USE_NVFBC_CUDA:
capture = NvFBC_CUDACapture()
else:
capture = NvFBC_SysCapture()
capture.init_context(ww, wh)
capture.refresh()
image = capture.get_image(0, 0, ww, wh)
assert image, "test capture failed"
except Exception as e:
log("get_image() NvFBC test failed", exc_info=True)
log("not using %s: %s", capture, e)
capture = None
if not capture and XImage.has_XShm() and USE_XSHM:
capture = XImageCapture(get_xwindow(window))
if not capture:
capture = GTKImageCapture(window)
log("setup_capture(%s)=%s", window, capture)
return capture
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)