def test_all_codecs_found(self):
from xpra.codecs import loader
#the self tests would swallow the exceptions and produce a warning:
loader.RUN_SELF_TESTS = False
loader.load_codecs()
#test them all:
for codec_name in loader.ALL_CODECS:
codec = loader.get_codec(codec_name)
if not codec:
continue
try:
#try to suspend error logging for full tests,
#as those may cause errors
log = getattr(codec, "log", None)
if SUSPEND_CODEC_ERROR_LOGGING and log:
import logging
log.logger.setLevel(logging.CRITICAL)
init_module = getattr(codec, "init_module", None)
#print("%s.init_module=%s" % (codec, init_module))
if init_module:
try:
init_module()
except Exception as e:
print("cannot initialize %s: %s" % (codec, e))
print(" test skipped")
continue
#print("found %s: %s" % (codec_name, codec))
selftest = getattr(codec, "selftest", None)
#print("selftest(%s)=%s" % (codec_name, selftest))
if selftest:
selftest(True)
finally:
if log:
log.logger.setLevel(logging.DEBUG)
def test_all_codecs_found(self):
from xpra.codecs import loader
#the self tests would swallow the exceptions and produce a warning:
loader.RUN_SELF_TESTS = False
loader.load_codecs()
#test them all:
for codec_name in loader.ALL_CODECS:
codec = loader.get_codec(codec_name)
if not codec:
continue
try:
#try to suspend error logging for full tests,
#as those may cause errors
log = getattr(codec, "log", None)
if SUSPEND_CODEC_ERROR_LOGGING and log:
import logging
log.logger.setLevel(logging.CRITICAL)
init_module = getattr(codec, "init_module", None)
#print("%s.init_module=%s" % (codec, init_module))
if init_module:
try:
init_module()
except Exception as e:
print("cannot initialize %s: %s" % (codec, e))
print(" test skipped")
continue
#print("found %s: %s" % (codec_name, codec))
selftest = getattr(codec, "selftest", None)
#print("selftest(%s)=%s" % (codec_name, selftest))
if selftest:
selftest(True)
finally:
if log:
log.logger.setLevel(logging.DEBUG)
def init_encodings(self):
load_codecs(decoders=False)
encs, core_encs = [], []
def add_encodings(encodings):
for ce in encodings:
e = {"rgb32" : "rgb", "rgb24" : "rgb"}.get(ce, ce)
if self.allowed_encodings is not None and e not in self.allowed_encodings:
#not in whitelist (if it exists)
continue
if e not in encs:
encs.append(e)
if ce not in core_encs:
core_encs.append(ce)
add_encodings(["rgb24", "rgb32"])
#video encoders (empty when first called - see threaded_init)
ve = getVideoHelper().get_encodings()
log("init_encodings() adding video encodings: %s", ve)
add_encodings(ve) #ie: ["vp8", "h264"]
#Pithon Imaging Libary:
enc_pillow = get_codec("enc_pillow")
if enc_pillow:
pil_encs = enc_pillow.get_encodings()
add_encodings(x for x in pil_encs if x!="webp")
#Note: webp will only be enabled if we have a Python-PIL fallback
#(either "webp" or "png")
if has_codec("enc_webp") and ("webp" in pil_encs or "png" in pil_encs):
add_encodings(["webp"])
if "webp" not in self.lossless_mode_encodings:
self.lossless_mode_encodings.append("webp")
#look for video encodings with lossless mode:
for e in ve:
for colorspace,especs in getVideoHelper().get_encoder_specs(e).items():
for espec in especs:
if espec.has_lossless_mode:
if e not in self.lossless_mode_encodings:
log("found lossless mode for encoding %s with %s and colorspace %s", e, espec, colorspace)
self.lossless_mode_encodings.append(e)
break
#now update the variables:
self.encodings = encs
self.core_encodings = core_encs
self.lossless_encodings = [x for x in self.core_encodings if (x.startswith("png") or x.startswith("rgb") or x=="webp")]
log("allowed encodings=%s, encodings=%s, core encodings=%s, lossless encodings=%s", self.allowed_encodings, encs, core_encs, self.lossless_encodings)
pref = [x for x in PREFERED_ENCODING_ORDER if x in self.encodings]
if pref:
self.default_encoding = pref[0]
else:
self.default_encoding = None
#default encoding:
if not self.encoding or str(self.encoding).lower() in ("auto", "none"):
self.default_encoding = None
elif self.encoding in self.encodings:
self.default_encoding = self.encoding
else:
log.warn("ignored invalid default encoding option: %s", self.encoding)
def load_codecs(self):
log("load_codecs()")
from xpra.codecs.video_helper import getVideoHelper, NO_GFX_CSC_OPTIONS #pylint: disable=import-outside-toplevel
vh = getVideoHelper()
vh.set_modules(video_decoders=self.session_options.video_decoders,
csc_modules=self.session_options.csc_modules or NO_GFX_CSC_OPTIONS)
vh.init()
from xpra.codecs.loader import load_codecs, show_codecs #pylint: disable=import-outside-toplevel
load_codecs()
show_codecs()
log("load_codecs() done")
def init(self):
load_codecs()
try:
self._lock.acquire()
#check again with lock held (in case of race):
if self._initialized:
return
self.init_video_encoders_options()
self.init_csc_options()
self.init_video_decoders_options()
self._initialized = True
finally:
self._lock.release()
def init(self):
log("VideoHelper.init()")
load_codecs()
with self._lock:
#check again with lock held (in case of race):
log("VideoHelper.init() initialized=%s", self._initialized)
if self._initialized:
return
self.init_video_encoders_options()
self.init_csc_options()
self.init_video_decoders_options()
self._initialized = True
log("VideoHelper.init() done")
def video_init(self):
enclog("video_init() loading codecs")
load_codecs(decoders=False)
enclog("video_init() will try video encoders: %s",
csv(self.video_encoder_modules) or "none")
self.video_helper = getVideoHelper()
#only use video encoders (no CSC supported in proxy)
self.video_helper.set_modules(
video_encoders=self.video_encoder_modules)
self.video_helper.init()
self.video_encoding_defs = {}
self.video_encoders = {}
self.video_encoders_dst_formats = []
self.video_encoders_last_used_time = {}
self.video_encoder_types = []
#figure out which encoders we want to proxy for (if any):
encoder_types = set()
for encoding in self.video_helper.get_encodings():
colorspace_specs = self.video_helper.get_encoder_specs(encoding)
for colorspace, especs in colorspace_specs.items():
if colorspace not in ("BGRX", "BGRA", "RGBX", "RGBA"):
#only deal with encoders that can handle plain RGB directly
continue
for spec in especs: #ie: video_spec("x264")
spec_props = spec.to_dict()
del spec_props["codec_class"] #not serializable!
spec_props[
"score_boost"] = 50 #we want to win scoring so we get used ahead of other encoders
spec_props[
"max_instances"] = 3 #limit to 3 video streams we proxy for (we really want 2,
# but because of races with garbage collection, we need to allow more)
#store it in encoding defs:
self.video_encoding_defs.setdefault(
encoding, {}).setdefault(colorspace,
[]).append(spec_props)
encoder_types.add(spec.codec_type)
enclog("encoder types found: %s", tuple(encoder_types))
#remove duplicates and use preferred order:
order = PREFERRED_ENCODER_ORDER[:]
for x in tuple(encoder_types):
if x not in order:
order.append(x)
self.video_encoder_types = [x for x in order if x in encoder_types]
enclog.info("proxy video encoders: %s",
", ".join(self.video_encoder_types or [
"none",
]))
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.util import print_nested_dict
from xpra.log import enable_color
from xpra.platform import program_context
with program_context("Video Helper"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
info = vh.get_info()
print_nested_dict(info)
def init(self):
log("VideoHelper.init()")
load_codecs()
try:
self._lock.acquire()
#check again with lock held (in case of race):
log("VideoHelper.init() initialized=%s", self._initialized)
if self._initialized:
return
self.init_video_encoders_options()
self.init_csc_options()
self.init_video_decoders_options()
self._initialized = True
finally:
self._lock.release()
log("VideoHelper.init() done")
def init(self):
log("VideoHelper.init()")
load_codecs()
try:
self._lock.acquire()
# check again with lock held (in case of race):
log("VideoHelper.init() initialized=%s", self._initialized)
if self._initialized:
return
self.init_video_encoders_options()
self.init_csc_options()
self.init_video_decoders_options()
self._initialized = True
finally:
self._lock.release()
log("VideoHelper.init() done")
def init(self, opts):
self.allowed_encodings = opts.encodings
self.encoding = opts.encoding
self.video_scaling = parse_bool_or_int("video-scaling",
opts.video_scaling)
self.quality = opts.quality
self.min_quality = opts.min_quality
self.speed = opts.speed
self.min_speed = opts.min_speed
#until we add the ability to choose decoders, use all of them:
#(and default to non grahics card csc modules if not specified)
load_codecs(encoders=False)
vh = getVideoHelper()
vh.set_modules(video_decoders=opts.video_decoders,
csc_modules=opts.csc_modules or NO_GFX_CSC_OPTIONS)
vh.init()
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.util import print_nested_dict
from xpra.log import enable_color
from xpra.platform import program_context
with program_context("Video Helper"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
log.info("VideoHelper.get_info():")
info = vh.get_info()
print_nested_dict(info)
def video_init(self):
enclog("video_init() loading codecs")
load_codecs(decoders=False)
enclog("video_init() will try video encoders: %s", csv(self.video_encoder_modules) or "none")
self.video_helper = getVideoHelper()
#only use video encoders (no CSC supported in proxy)
self.video_helper.set_modules(video_encoders=self.video_encoder_modules)
self.video_helper.init()
self.video_encoding_defs = {}
self.video_encoders = {}
self.video_encoders_dst_formats = []
self.video_encoders_last_used_time = {}
self.video_encoder_types = []
#figure out which encoders we want to proxy for (if any):
encoder_types = set()
for encoding in self.video_helper.get_encodings():
colorspace_specs = self.video_helper.get_encoder_specs(encoding)
for colorspace, especs in colorspace_specs.items():
if colorspace not in ("BGRX", "BGRA", "RGBX", "RGBA"):
#only deal with encoders that can handle plain RGB directly
continue
for spec in especs: #ie: video_spec("x264")
spec_props = spec.to_dict()
del spec_props["codec_class"] #not serializable!
spec_props["score_boost"] = 50 #we want to win scoring so we get used ahead of other encoders
spec_props["max_instances"] = 3 #limit to 3 video streams we proxy for (we really want 2,
# but because of races with garbage collection, we need to allow more)
#store it in encoding defs:
self.video_encoding_defs.setdefault(encoding, {}).setdefault(colorspace, []).append(spec_props)
encoder_types.add(spec.codec_type)
enclog("encoder types found: %s", tuple(encoder_types))
#remove duplicates and use preferred order:
order = PREFERRED_ENCODER_ORDER[:]
for x in list(encoder_types):
if x not in order:
order.append(x)
self.video_encoder_types = [x for x in order if x in encoder_types]
enclog.info("proxy video encoders: %s", ", ".join(self.video_encoder_types))
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.log import enable_color
from xpra.platform import init, clean
try:
init("Video Helper")
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
log.info("VideoHelper.get_info():")
info = vh.get_info()
for k in sorted(info.keys()):
v = info.get(k)
if type(v) in (list, tuple):
v = csv(v)
log.info("%s=%s", k, v)
finally:
clean()
def test_all_codecs_found(self):
from xpra.codecs import loader
#the self tests would swallow the exceptions and produce a warning:
loader.RUN_SELF_TESTS = False
loader.load_codecs()
#test them all:
for codec_name in loader.ALL_CODECS:
codec = loader.get_codec(codec_name)
if not codec:
continue
init_module = getattr(codec, "init_module", None)
#print("%s.init_module=%s" % (codec, init_module))
if init_module:
try:
init_module()
except Exception as e:
print("cannot initialize %s: %s" % (codec, e))
print(" test skipped")
continue
#print("found %s: %s" % (codec_name, codec))
selftest = getattr(codec, "selftest", None)
#print("selftest(%s)=%s" % (codec_name, selftest))
if selftest:
selftest(True)
def test_all_codecs_found(self):
from xpra.codecs import loader
#the self tests would swallow the exceptions and produce a warning:
loader.RUN_SELF_TESTS = False
loader.load_codecs()
#test them all:
for codec_name in loader.ALL_CODECS:
codec = loader.get_codec(codec_name)
if not codec:
continue
init_module = getattr(codec, "init_module", None)
#print("%s.init_module=%s" % (codec, init_module))
if init_module:
try:
init_module()
except Exception as e:
print("cannot initialize %s: %s" % (codec, e))
print(" test skipped")
continue
#print("found %s: %s" % (codec_name, codec))
selftest = getattr(codec, "selftest", None)
#print("selftest(%s)=%s" % (codec_name, selftest))
if selftest:
selftest(True)
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.log import enable_color
from xpra.platform import init, clean
try:
init("Video Helper")
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS,
ALL_VIDEO_DECODER_OPTIONS)
vh.init()
log.info("VideoHelper.get_info():")
info = vh.get_info()
for k in sorted(info.keys()):
v = info.get(k)
if type(v) in (list, tuple):
v = csv(v)
log.info("%s=%s", k, v)
finally:
clean()
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 main(argv):
assert len(argv) > 1, "specify images to benchmark"
from xpra.net import compression
compression.init_all()
from xpra.codecs.loader import load_codecs, get_codec
loaded = load_codecs(encoders=True, decoders=False, csc=False, video=False)
print("loaded: %s" % csv(loaded))
for codec in loaded:
print("%s : %s" % (codec, get_codec(codec)))
from PIL import Image
for f in argv[1:]:
img = Image.open(f)
if img.mode not in ("RGBA", "RGB"):
img = img.convert("RGB")
pixel_format = img.mode
w, h = img.size
rgb_data = img.tobytes("raw")
stride = w * len(pixel_format)
print()
print("%s : %s" % (f, img))
for warmup in (True, False):
speed = 50
for quality in Q:
if not warmup:
print()
print("quality = %i" % quality)
for codec in loaded:
mod = get_codec(codec)
encodings = mod.get_encodings()
if not warmup:
print(" %s : %s" % (codec, encodings))
#print("%s" % (dir(mod), ))
for e in encodings:
image = ImageWrapper(0,
0,
w,
h,
rgb_data,
pixel_format,
len(pixel_format) * 8,
stride,
planes=ImageWrapper.PACKED,
thread_safe=True)
sizes = []
n = 1 if warmup else N
options = {
"quality":
quality,
"speed":
speed,
"rgb_formats":
("BGRX", "BGRA", "RGBA", "RGBX", "RGB", "BGR"),
"zlib":
True,
"lz4":
True,
"alpha":
True,
}
client_options = {}
start = monotonic()
for _ in range(n):
try:
r = mod.encode(e, image, options)
except Exception:
print("error on %s.%s" % (mod, mod.encode))
raise
if not r:
print(
"error: no data for %s encoding %s as %r" %
(codec, image, e))
continue
cdata = r[1]
client_options = r[2]
sizes.append(len(cdata))
end = monotonic()
if not warmup:
cratio = ceil(100 * sum(sizes) /
(w * h * len(pixel_format) * N))
mps = (w * h * N) / (end - start)
print(
" %-16s : %3i%% - %7i MPixels/s, %s"
% (e, cratio, mps // 1024 // 1024,
client_options))
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:
logo_button = gtk.Button("")
settings = logo_button.get_settings()
settings.set_property('gtk-button-images', True)
logo_button.connect("clicked", about)
set_tooltip_text(logo_button, "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.gstreamer_util import get_info as get_sound_info
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.version_util import get_version_info, get_platform_info, get_host_info
def get_sys_info():
d = {}
for k, v in {
"version": get_version_info(),
"platform": get_platform_info(),
"host": get_host_info(),
"paths": get_path_info(),
"gtk": get_gtk_version_info(),
"user": get_user_info(),
"env": os.environ,
}.items():
updict(d, k, v)
return d
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:
#default: gtk screen capture
try:
from xpra.server.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.xpra_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))
set_tooltip_text(cb, 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)
set_tooltip_text(btn, 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
#Copy:
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)
# Copyright (C) 2016 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import time
import struct
from xpra.log import Logger
log = Logger()
import glib
from xpra.util import typedict
from tests.xpra.clients.fake_gtk_client import FakeGTKClient, gtk_main
from xpra.codecs.loader import load_codecs
load_codecs(encoders=False, decoders=True, csc=False)
class WindowAnim(object):
def __init__(self, window_class, client, wid, W=630, H=480, animate=True):
self.wid = wid
self.window = window_class(client, None, wid, 10, 10, W, H, W, H,
typedict({}), False, typedict({}), 0, None)
self.window.show()
self.paint_rect(0, 0, W, H, chr(255) * 4 * W * H)
self.paint_rect(W // 2 - 16, H // 2 - 16, 32, 32, chr(0) * 4 * 32 * 32)
self.animate = animate
self.damage = False
client.handle_key_action = self.handle_key_action
def handle_key_action(self, window, event):
# Copyright (C) 2016 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import binascii
import math
from xpra.log import Logger
log = Logger()
import glib
from xpra.util import typedict
from tests.xpra.clients.fake_gtk_client import FakeGTKClient, gtk_main
from xpra.codecs.loader import load_codecs
load_codecs(encoders=False, decoders=True, csc=False)
class WindowAnim(object):
def __init__(self, window_class, client, wid, W=630, H=480):
self.wid = wid
self.window = window_class(client, None, wid, 10, 10, W, H, W, H, typedict({}), False, typedict({}), 0, None)
self.window.show()
self.paint_rect(0, 0, W, H, chr(255)*4*W*H)
def paint_crect(self, x=200, y=200, w=32, h=32, color=0x80808080):
import struct
c = struct.pack("@I", color & 0xFFFFFFFF)
img_data = c*w*h
self.window.draw_region(x, y, w, h, "rgb32", img_data, w*4, 0, typedict({}), [])
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)
