def __init__(self, parent=None):
BaseFrame.__init__(self, parent, -1, lang.getstr("measurement_report"))
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.SetIcons(config.get_icon_bundle([256, 48, 32, 16], appname))
res = TempXmlResource(get_data_path(os.path.join("xrc", "report.xrc")))
res.InsertHandler(xh_fancytext.StaticFancyTextCtrlXmlHandler())
res.InsertHandler(
xh_filebrowsebutton.FileBrowseButtonWithHistoryXmlHandler())
res.InsertHandler(xh_hstretchstatbmp.HStretchStaticBitmapXmlHandler())
res.InsertHandler(xh_bitmapctrls.BitmapButton())
res.InsertHandler(xh_bitmapctrls.StaticBitmap())
self.panel = res.LoadPanel(self, "panel")
self.Sizer = wx.BoxSizer(wx.VERTICAL)
self.Sizer.Add(self.panel, 1, flag=wx.EXPAND)
self.set_child_ctrls_as_attrs(self)
self.measurement_report_btn = wx.Button(self.panel, -1,
lang.getstr("measure"))
self.panel.Sizer.Insert(2,
self.measurement_report_btn,
flag=wx.RIGHT | wx.BOTTOM | wx.ALIGN_RIGHT,
border=16)
self.worker = worker.Worker(self)
self.worker.set_argyll_version("xicclu")
BaseFrame.setup_language(self)
self.mr_setup_language()
self.mr_init_controls()
self.mr_update_controls()
self.mr_init_frame()
def __init__(self, html, embed, view, force, cache):
BaseFrame.__init__(self,
None,
wx.ID_ANY,
lang.getstr("vrml_to_x3d_converter"),
style=wx.DEFAULT_FRAME_STYLE
& ~(wx.MAXIMIZE_BOX | wx.RESIZE_BORDER),
name="vrml2x3dframe")
self.SetIcons(
config.get_icon_bundle([256, 48, 32, 16],
appname + "-VRML-to-X3D-converter"))
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.cache = cache
self.embed = embed
self.force = force
self.html = html
self.worker = Worker(self)
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.SetSizer(sizer)
panel = wx.Panel(self)
sizer.Add(panel)
panelsizer = wx.BoxSizer(wx.HORIZONTAL)
panel.SetSizer(panelsizer)
self.btn = BitmapButton(panel,
wx.ID_ANY,
config.geticon(256, "3d-primitives"),
style=wx.NO_BORDER)
self.btn.SetToolTipString(lang.getstr("file.select"))
self.btn.Bind(
wx.EVT_BUTTON,
lambda event: vrmlfile2x3dfile(None,
html=html,
embed=embed,
view=view,
force=force,
cache=cache,
worker=self.worker))
self.droptarget = FileDrop(self)
vrml_drop_handler = lambda vrmlpath: vrmlfile2x3dfile(vrmlpath,
html=html,
embed=embed,
view=view,
force=force,
cache=cache,
worker=self.
worker)
self.droptarget.drophandlers = {
".vrml": vrml_drop_handler,
".vrml.gz": vrml_drop_handler,
".wrl": vrml_drop_handler,
".wrl.gz": vrml_drop_handler,
".wrz": vrml_drop_handler
}
self.btn.SetDropTarget(self.droptarget)
panelsizer.Add(self.btn, flag=wx.ALL, border=12)
self.Fit()
self.SetMinSize(self.GetSize())
self.SetMaxSize(self.GetSize())
def __init__(self, parent, cgats, worker=None):
"""
Init new CCXPlot window.
parent Parent window (only used for error dialogs)
cgats A CCMX/CCSS CGATS instance
worker Worker instance
"""
self.is_ccss = cgats[0].type == "CCSS"
desc = cgats.get_descriptor()
if cgats.filename:
fn, ext = os.path.splitext(os.path.basename(cgats.filename))
else:
fn = desc
if self.is_ccss:
ext = ".ccss"
else:
ext = ".ccmx"
desc = lang.getstr(ext[1:] + "." + fn, default=desc)
if self.is_ccss:
ccxx_type = "spectral"
else:
ccxx_type = "matrix"
title = "%s: %s" % (lang.getstr(ccxx_type), desc)
if self.is_ccss:
# Convert to TI3 so we can get XYZ from spectra for coloring
temp = worker.create_tempdir()
if isinstance(temp, Exception):
show_result_dialog(temp, parent)
else:
basename = make_filename_safe(desc)
temp_path = os.path.join(temp, basename + ".ti3")
cgats[0].type = "CTI3"
cgats[0].DEVICE_CLASS = "DISPLAY"
cgats.write(temp_path)
temp_out_path = os.path.join(temp, basename + ".CIE.ti3")
result = worker.exec_cmd(get_argyll_util("spec2cie"),
[temp_path, temp_out_path],
capture_output=True)
if isinstance(result, Exception) or not result:
show_result_dialog(
UnloggedError(result or "".join(worker.errors)),
parent)
worker.wrapup(False)
else:
try:
cgats = CGATS.CGATS(temp_out_path)
except Exception as exception:
show_result_dialog(exception, parent)
finally:
worker.wrapup(False)
data_format = cgats.queryv1("DATA_FORMAT")
data = cgats.queryv1("DATA")
XYZ_max = 0
self.samples = []
if self.is_ccss:
x_min = cgats.queryv1("SPECTRAL_START_NM")
x_max = cgats.queryv1("SPECTRAL_END_NM")
bands = cgats.queryv1("SPECTRAL_BANDS")
lores = bands <= 40
if lores:
# Interpolate if lores
# 1nm intervals
steps = int(x_max - x_min) + 1
safe_print("Up-interpolating", bands, "spectral bands to",
steps)
step = (x_max - x_min) / (steps - 1.)
else:
step = (x_max - x_min) / (bands - 1.)
y_min = 0
y_max = 1
Y_max = 0
for i, sample in data.items():
# Get nm and spectral power
values = []
x = x_min
for k in data_format.values():
if k.startswith("SPEC_"):
y = sample[k]
y_min = min(y, y_min)
y_max = max(y, y_max)
if lores:
values.append(y)
else:
values.append((x, y))
x += step
if lores:
# Interpolate if lores. Use Catmull-Rom instead of
# PolySpline as we want curves to go through points exactly
numvalues = len(values)
interp = ICCP.CRInterpolation(values)
values = []
for i in range(steps):
values.append(
(x, interp(i / (steps - 1.) * (numvalues - 1.))))
x += step
# Get XYZ for colorization
XYZ = []
for component in "XYZ":
label = "XYZ_" + component
if label in sample:
v = sample[label]
XYZ_max = max(XYZ_max, v)
if label == "XYZ_Y":
Y_max = max(Y_max, v)
XYZ.append(v)
self.samples.append((XYZ, values, {}))
Plot = plot.PolyLine
Plot._attributes["width"] = 1
else:
# CCMX
cube_size = 2
x_min = 0
y_min = 0
mtx = colormath.Matrix3x3(
[[sample[k] for k in data_format.values()]
for sample in data.values()])
imtx = mtx.inverted()
# Get XYZ that colorimeter would measure without matrix (sRGB ref,
# so not accurate, but useful for visual representation which is all
# we care about here)
if cube_size == 2:
scale = 1
x_max = 100 * scale
y_max = x_max * (74.6 / 67.4)
if sys.platform != "win32":
x_center = x_max / 2.
else:
x_center = x_max / 2. - 2.5
y_center = y_max / 2.
x_center *= scale
y_center *= scale
pos2rgb = [((x_center - 23.7, y_center - 13.7), (0, 0, 1)),
((x_center, y_center + 27.3), (0, 1, 0)),
((x_center + 23.7, y_center - 13.7), (1, 0, 0)),
((x_center - 23.7, y_center + 13.7), (0, 1, 1)),
((x_center, y_center - 27.3), (1, 0, 1)),
((x_center + 23.7, y_center + 13.7), (1, 1, 0)),
((x_center, y_center), (1, 1, 1))]
attrs_c = {'size': 10}
attrs_r = {'size': 5}
else:
x_max = 100
y_max = 100
y = -5
pos2rgb = []
for R in range(cube_size):
for G in range(cube_size):
x = -5
y += 10
for B in range(cube_size):
x += 10
pos2rgb.append(((x, y), (v / (cube_size - 1.0)
for v in (R, G, B))))
attrs_c = {'marker': 'square', 'size': 10}
attrs_r = {'marker': 'square', 'size': 5}
Y_max = (imtx * colormath.get_whitepoint("D65"))[1]
for i, ((x, y), (R, G, B)) in enumerate(pos2rgb):
XYZ = list(colormath.RGB2XYZ(R, G, B))
X, Y, Z = imtx * XYZ
XYZ_max = max(XYZ_max, X, Y, Z)
self.samples.append(([X, Y, Z], [(x, y)], attrs_c))
self.samples.append((XYZ, [(x, y)], attrs_r))
Plot = plot.PolyMarker
if self.is_ccss:
# Protect against division by zero when range is zero
if not x_max - x_min:
x_min = 350.0
x_max = 750.0
if not y_max - y_min:
y_min = 0.0
y_max = 10.0
y_zero = 0
self.ccxx_axis_x = (math.floor(x_min / 50.) * 50,
math.ceil(x_max / 50.) * 50)
self.spec_x = (self.ccxx_axis_x[1] - self.ccxx_axis_x[0]) / 50.
graph_range = nicenum(y_max - y_zero, False)
d = nicenum(graph_range / (NTICK - 1.0), True)
self.spec_y = math.ceil(y_max / d)
self.ccxx_axis_y = (math.floor(y_zero / d) * d, self.spec_y * d)
else:
self.ccxx_axis_x = (math.floor(x_min / 20.) * 20,
math.ceil(x_max / 20.) * 20)
self.ccxx_axis_y = (math.floor(y_min), math.ceil(y_max))
self.gfx = []
for XYZ, values, attrs in self.samples:
if len(XYZ) == 3:
# Got XYZ
if attrs.get("size") > 11.25:
# Colorimeter XYZ
if Y_max > 1:
# Colorimeter brighter than ref
XYZ[:] = [v / Y_max for v in XYZ]
else:
# Colorimeter dimmer than ref
XYZ[:] = [v * Y_max for v in XYZ]
else:
# Ref XYZ
if Y_max > 1:
# Colorimeter brighter than ref
XYZ[:] = [v / Y_max for v in XYZ]
RGB = tuple(
int(v)
for v in colormath.XYZ2RGB(*XYZ, scale=255, round_=True))
else:
RGB = (153, 153, 153)
self.gfx.append(Plot(values, colour=wx.Colour(*RGB), **attrs))
if self.is_ccss:
# Add a few points at the extremes to define a bounding box
self.gfx.append(
plot.PolyLine(
[(self.ccxx_axis_x[0], self.ccxx_axis_y[0]),
(self.ccxx_axis_x[1], self.ccxx_axis_y[1] - y_min)],
colour=wx.Colour(0, 0, 0, 0)))
ref = cgats.queryv1("REFERENCE")
if ref:
ref = get_canonical_instrument_name(safe_unicode(ref, "UTF-8"))
if not self.is_ccss:
observers_ab = {}
for observer in config.valid_values["observer"]:
observers_ab[observer] = lang.getstr("observer." + observer)
x_label = [lang.getstr("matrix")]
x_label.extend(["%9.6f %9.6f %9.6f" % tuple(row) for row in mtx])
if ref:
ref_observer = cgats.queryv1("REFERENCE_OBSERVER")
if ref_observer:
ref += ", " + observers_ab.get(ref_observer, ref_observer)
x_label.append("")
x_label.append(ref)
fit_method = cgats.queryv1("FIT_METHOD")
if fit_method == "xy":
fit_method = lang.getstr("ccmx.use_four_color_matrix_method")
elif fit_method:
fit_method = lang.getstr("perceptual")
fit_de00_avg = cgats.queryv1("FIT_AVG_DE00")
if not isinstance(fit_de00_avg, float):
fit_de00_avg = None
fit_de00_max = cgats.queryv1("FIT_MAX_DE00")
if not isinstance(fit_de00_max, float):
fit_de00_max = None
if fit_method:
x_label.append(fit_method)
fit_de00 = []
if fit_de00_avg:
fit_de00.append(
"ΔE*00 %s %.4f" %
(lang.getstr("profile.self_check.avg"), fit_de00_avg))
if fit_de00_max:
fit_de00.append(
"ΔE*00 %s %.4f" %
(lang.getstr("profile.self_check.max"), fit_de00_max))
if fit_de00:
x_label.append("\n".join(fit_de00))
x_label = "\n".join(x_label)
else:
x_label = ""
if ref:
x_label += ref + ", "
x_label += "%.1fnm, %i-%inm" % ((x_max - x_min) /
(bands - 1.0), x_min, x_max)
scale = max(getcfg("app.dpi") / config.get_default_dpi(), 1)
style = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, None, -1, title, style=style)
self.SetIcons(config.get_icon_bundle([256, 48, 32, 16], appname))
self.SetBackgroundColour(BGCOLOUR)
self.Sizer = wx.GridSizer(1, 1, 0, 0)
bg = wx.Panel(self)
bg.SetBackgroundColour(BGCOLOUR)
bg.Sizer = wx.BoxSizer(wx.VERTICAL)
self.canvas = canvas = LUTCanvas(bg)
if self.is_ccss:
bg.MinSize = (513 * scale, 557 * scale)
btnsizer = wx.BoxSizer(wx.HORIZONTAL)
bg.Sizer.Add(btnsizer,
flag=wx.EXPAND | wx.TOP | wx.RIGHT | wx.LEFT,
border=16)
self.toggle_btn = FlatShadedButton(bg,
-1,
label=lang.getstr("spectral"))
btnsizer.Add(self.toggle_btn, 1)
self.Sizer.Add(bg, 1, flag=wx.EXPAND)
bg.Sizer.Add(canvas, 1, flag=wx.EXPAND)
else:
self.Sizer.Add(bg, flag=wx.ALIGN_CENTER)
canvas_w = 240 * scale
canvas.MinSize = (canvas_w, canvas_w * (74.6 / 67.4))
bg.Sizer.Add(canvas, flag=wx.ALIGN_CENTER)
label = wx.StaticText(bg,
-1,
x_label.replace("&", "&&"),
style=wx.ALIGN_CENTRE_HORIZONTAL)
label.SetForegroundColour(FGCOLOUR)
label.SetMaxFontSize(11)
bg.Sizer.Add(label,
flag=wx.ALIGN_CENTER | wx.ALL & ~wx.TOP,
border=16 * scale)
canvas.SetBackgroundColour(BGCOLOUR)
canvas.SetEnableCenterLines(False)
canvas.SetEnableDiagonals(False)
canvas.SetEnableGrid(True)
canvas.enableTicks = (True, True)
canvas.tickPen = wx.Pen(GRIDCOLOUR, canvas._pointSize[0])
canvas.SetEnablePointLabel(False)
canvas.SetEnableTitle(True)
canvas.SetForegroundColour(FGCOLOUR)
canvas.SetGridColour(GRIDCOLOUR)
canvas.canvas.BackgroundColour = BGCOLOUR
if self.is_ccss:
canvas.HandCursor = wx.StockCursor(wx.CURSOR_SIZING)
canvas.SetCursor(canvas.HandCursor)
else:
canvas.canvas.Unbind(wx.EVT_LEFT_DCLICK)
canvas.SetEnableDrag(False)
canvas.SetCursor(wx.StockCursor(wx.CURSOR_DEFAULT))
canvas.SetXSpec('none')
canvas.SetYSpec('none')
# CallAfter is needed under GTK as usual
wx.CallAfter(self.draw_ccxx)
if self.is_ccss:
self.Bind(wx.EVT_KEY_DOWN, self.key_handler)
for child in self.GetAllChildren():
child.Bind(wx.EVT_KEY_DOWN, self.key_handler)
child.Bind(wx.EVT_MOUSEWHEEL, self.OnWheel)
self.toggle_btn.Bind(wx.EVT_BUTTON, self.toggle_draw)
self.Bind(wx.EVT_SIZE, self.OnSize)
else:
bg.Sizer.Add((0, 16))
self.Sizer.SetSizeHints(self)
self.Sizer.Layout()
def __init__(self,
parent=None,
handler=None,
keyhandler=None,
start_timer=True):
BaseFrame.__init__(self,
parent,
wx.ID_ANY,
lang.getstr("measurement.untethered"),
style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL,
name="untetheredframe")
self.SetIcons(get_icon_bundle([256, 48, 32, 16], appname))
self.sizer = wx.FlexGridSizer(2, 1, 0, 0)
self.sizer.AddGrowableCol(0)
self.sizer.AddGrowableRow(0)
self.sizer.AddGrowableRow(1)
self.panel = wx_Panel(self)
self.SetSizer(self.sizer)
self.sizer.Add(self.panel, 1, wx.EXPAND)
self.panel.SetBackgroundColour(BGCOLOUR)
panelsizer = wx.FlexGridSizer(3, 2, 8, 8)
panelsizer.AddGrowableCol(0)
panelsizer.AddGrowableCol(1)
panelsizer.AddGrowableRow(1)
self.panel.SetSizer(panelsizer)
self.label_RGB = wx.StaticText(self.panel, wx.ID_ANY, " ")
self.label_RGB.SetForegroundColour(FGCOLOUR)
panelsizer.Add(self.label_RGB,
0,
wx.TOP | wx.LEFT | wx.EXPAND,
border=8)
self.label_XYZ = wx.StaticText(self.panel, wx.ID_ANY, " ")
self.label_XYZ.SetForegroundColour(FGCOLOUR)
panelsizer.Add(self.label_XYZ,
0,
wx.TOP | wx.RIGHT | wx.EXPAND,
border=8)
if sys.platform == "darwin":
style = wx.BORDER_THEME
else:
style = wx.BORDER_SIMPLE
self.panel_RGB = BitmapBackgroundPanel(self.panel,
size=(256, 256),
style=style)
self.panel_RGB.scalebitmap = (True, True)
self.panel_RGB.SetBitmap(
getbitmap("theme/checkerboard-32x32x5-333-444"))
panelsizer.Add(self.panel_RGB, 1, wx.LEFT | wx.EXPAND, border=8)
self.panel_XYZ = BitmapBackgroundPanel(self.panel,
size=(256, 256),
style=style)
self.panel_XYZ.scalebitmap = (True, True)
self.panel_XYZ.SetBitmap(
getbitmap("theme/checkerboard-32x32x5-333-444"))
panelsizer.Add(self.panel_XYZ, 1, wx.RIGHT | wx.EXPAND, border=8)
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.back_btn = FlatShadedButton(self.panel,
bitmap=geticon(10, "back"),
label="",
fgcolour=FGCOLOUR)
self.back_btn.Bind(wx.EVT_BUTTON, self.back_btn_handler)
sizer.Add(self.back_btn, 0, wx.LEFT | wx.RIGHT, border=8)
self.label_index = wx.StaticText(self.panel, wx.ID_ANY, " ")
self.label_index.SetForegroundColour(FGCOLOUR)
sizer.Add(self.label_index, 0, wx.ALIGN_CENTER_VERTICAL)
self.next_btn = FlatShadedButton(self.panel,
bitmap=geticon(10, "play"),
label="",
fgcolour=FGCOLOUR)
self.next_btn.Bind(wx.EVT_BUTTON, self.next_btn_handler)
sizer.Add(self.next_btn, 0, wx.LEFT, border=8)
sizer.Add((12, 1), 1)
self.measure_auto_cb = CustomCheckBox(self.panel, wx.ID_ANY,
lang.getstr("auto"))
self.measure_auto_cb.SetForegroundColour(FGCOLOUR)
self.measure_auto_cb.Bind(wx.EVT_CHECKBOX,
self.measure_auto_ctrl_handler)
sizer.Add(self.measure_auto_cb, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT)
panelsizer.Add(sizer, 0, wx.BOTTOM | wx.EXPAND, border=8)
sizer = wx.BoxSizer(wx.HORIZONTAL)
self.measure_btn = FlatShadedButton(self.panel,
bitmap=geticon(10, "play"),
label=lang.getstr("measure"),
fgcolour=FGCOLOUR)
self.measure_btn.Bind(wx.EVT_BUTTON, self.measure_btn_handler)
sizer.Add(self.measure_btn, 0, wx.RIGHT, border=6)
# Sound when measuring
# Needs to be stereo!
self.measurement_sound = audio.Sound(get_data_path("beep.wav"))
self.commit_sound = audio.Sound(get_data_path("camera_shutter.wav"))
bitmap = self.get_sound_on_off_btn_bitmap()
self.sound_on_off_btn = FlatShadedButton(self.panel,
bitmap=bitmap,
fgcolour=FGCOLOUR)
self.sound_on_off_btn.SetToolTipString(
lang.getstr("measurement.play_sound"))
self.sound_on_off_btn.Bind(wx.EVT_BUTTON,
self.measurement_play_sound_handler)
sizer.Add(self.sound_on_off_btn, 0)
sizer.Add((12, 1), 1)
self.finish_btn = FlatShadedButton(self.panel,
label=lang.getstr("finish"),
fgcolour=FGCOLOUR)
self.finish_btn.Bind(wx.EVT_BUTTON, self.finish_btn_handler)
sizer.Add(self.finish_btn, 0, wx.RIGHT, border=8)
panelsizer.Add(sizer, 0, wx.BOTTOM | wx.EXPAND, border=8)
self.grid = CustomGrid(self, -1, size=(536, 256))
self.grid.DisableDragColSize()
self.grid.DisableDragRowSize()
self.grid.SetScrollRate(0, 5)
self.grid.SetCellHighlightROPenWidth(0)
self.grid.SetColLabelSize(self.grid.GetDefaultRowSize())
self.grid.SetDefaultCellAlignment(wx.ALIGN_CENTER, wx.ALIGN_CENTER)
self.grid.SetRowLabelAlignment(wx.ALIGN_RIGHT, wx.ALIGN_CENTER)
self.grid.draw_horizontal_grid_lines = False
self.grid.draw_vertical_grid_lines = False
self.grid.style = ""
self.grid.CreateGrid(0, 9)
self.grid.SetRowLabelSize(62)
for i in range(9):
if i in (3, 4):
size = self.grid.GetDefaultRowSize()
if i == 4:
attr = wx.grid.GridCellAttr()
attr.SetBackgroundColour(wx.Colour(0, 0, 0, 0))
self.grid.SetColAttr(i, attr)
else:
size = 62
self.grid.SetColSize(i, size)
for i, label in enumerate(
["R", "G", "B", "", "", "L*", "a*", "b*", ""]):
self.grid.SetColLabelValue(i, label)
self.grid.SetCellHighlightPenWidth(0)
self.grid.SetDefaultCellBackgroundColour(
self.grid.GetLabelBackgroundColour())
font = self.grid.GetDefaultCellFont()
if font.PointSize > 11:
font.PointSize = 11
self.grid.SetDefaultCellFont(font)
self.grid.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
self.grid.EnableEditing(False)
self.grid.EnableGridLines(False)
self.grid.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK,
self.grid_left_click_handler)
self.grid.Bind(wx.grid.EVT_GRID_SELECT_CELL,
self.grid_left_click_handler)
self.sizer.Add(self.grid, 1, wx.EXPAND)
self.Fit()
self.SetMinSize(self.GetSize())
self.keyhandler = keyhandler
self.id_to_keycode = {}
if sys.platform == "darwin":
# Use an accelerator table for tab, space, 0-9, A-Z, numpad,
# navigation keys and processing keys
keycodes = [wx.WXK_TAB, wx.WXK_SPACE]
keycodes.extend(list(range(ord("0"), ord("9"))))
keycodes.extend(list(range(ord("A"), ord("Z"))))
keycodes.extend(numpad_keycodes)
keycodes.extend(nav_keycodes)
keycodes.extend(processing_keycodes)
for keycode in keycodes:
self.id_to_keycode[wx.Window.NewControlId()] = keycode
accels = []
for id, keycode in self.id_to_keycode.items():
self.Bind(wx.EVT_MENU, self.key_handler, id=id)
accels.append((wx.ACCEL_NORMAL, keycode, id))
if keycode == wx.WXK_TAB:
accels.append((wx.ACCEL_SHIFT, keycode, id))
self.SetAcceleratorTable(wx.AcceleratorTable(accels))
else:
self.Bind(wx.EVT_CHAR_HOOK, self.key_handler)
self.Bind(wx.EVT_KEY_DOWN, self.key_handler)
# Event handlers
self.Bind(wx.EVT_CLOSE, self.OnClose, self)
self.Bind(wx.EVT_MOVE, self.OnMove, self)
self.Bind(wx.EVT_SIZE, self.OnResize, self)
self.timer = wx.Timer(self)
if handler:
self.Bind(wx.EVT_TIMER, handler, self.timer)
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy, self)
# Final initialization steps
for child in self.GetAllChildren():
if (sys.platform == "win32" and sys.getwindowsversion() >= (6, )
and isinstance(child, wx.Panel)):
# No need to enable double buffering under Linux and Mac OS X.
# Under Windows, enabling double buffering on the panel seems
# to work best to reduce flicker.
child.SetDoubleBuffered(True)
self.logger = get_file_logger("untethered")
self._setup()
self.Show()
if start_timer:
self.start_timer()
def __init__(self,
parent=None,
handler=None,
keyhandler=None,
start_timer=True,
rows=None,
cols=None):
if not rows:
rows = getcfg("uniformity.rows")
if not cols:
cols = getcfg("uniformity.cols")
BaseFrame.__init__(self,
parent,
wx.ID_ANY,
lang.getstr("report.uniformity"),
style=wx.DEFAULT_FRAME_STYLE | wx.TAB_TRAVERSAL,
name="displayuniformityframe")
self.SetIcons(get_icon_bundle([256, 48, 32, 16], appname))
self.SetBackgroundColour(BGCOLOUR)
self.sizer = wx.GridSizer(rows, cols, 0, 0)
self.SetSizer(self.sizer)
self.rows = rows
self.cols = cols
self.colors = (wx.WHITE, wx.Colour(192, 192, 192),
wx.Colour(128, 128, 128), wx.Colour(64, 64, 64))
self.labels = {}
self.panels = []
self.buttons = []
for index in range(rows * cols):
panel = wx_Panel(self, style=wx.BORDER_SIMPLE)
panel.SetBackgroundColour(BGCOLOUR)
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
self.panels.append(panel)
button = FlatShadedNumberedButton(
panel,
label=lang.getstr("measure"),
bitmap=getbitmap("theme/icons/10x10/record"),
index=index)
button.Bind(wx.EVT_BUTTON, self.measure)
self.buttons.append(button)
label = wx.StaticText(panel)
label.SetForegroundColour(wx.WHITE)
self.labels[index] = label
sizer.Add(label, 1, wx.ALIGN_CENTER)
sizer.Add(button,
0,
wx.ALIGN_BOTTOM | wx.ALIGN_CENTER | wx.BOTTOM | wx.LEFT
| wx.RIGHT,
border=8)
self.sizer.Add(panel, 1, wx.EXPAND)
self.disable_buttons()
self.keyhandler = keyhandler
self.id_to_keycode = {}
if sys.platform == "darwin":
# Use an accelerator table for tab, space, 0-9, A-Z, numpad,
# navigation keys and processing keys
keycodes = [wx.WXK_TAB, wx.WXK_SPACE]
keycodes.extend(list(range(ord("0"), ord("9"))))
keycodes.extend(list(range(ord("A"), ord("Z"))))
keycodes.extend(numpad_keycodes)
keycodes.extend(nav_keycodes)
keycodes.extend(processing_keycodes)
for keycode in keycodes:
self.id_to_keycode[wx.Window.NewControlId()] = keycode
accels = []
for id, keycode in self.id_to_keycode.items():
self.Bind(wx.EVT_MENU, self.key_handler, id=id)
accels.append((wx.ACCEL_NORMAL, keycode, id))
if keycode == wx.WXK_TAB:
accels.append((wx.ACCEL_SHIFT, keycode, id))
self.SetAcceleratorTable(wx.AcceleratorTable(accels))
else:
self.Bind(wx.EVT_CHAR_HOOK, self.key_handler)
# Event handlers
self.Bind(wx.EVT_CLOSE, self.OnClose, self)
self.Bind(wx.EVT_MOVE, self.OnMove, self)
self.timer = wx.Timer(self)
if handler:
self.Bind(wx.EVT_TIMER, handler, self.timer)
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy, self)
# Final initialization steps
self.logger = get_file_logger("uniformity")
self._setup()
self.Show()
if start_timer:
self.start_timer()
def __init__(self, parent=None, id=-1):
style = wx.DEFAULT_FRAME_STYLE & ~(wx.RESIZE_BORDER | wx.MAXIMIZE_BOX)
if (os.getenv("XDG_SESSION_TYPE") != "wayland"
and getcfg("patterngenerator.use_pattern_window")):
style |= wx.STAY_ON_TOP
InvincibleFrame.__init__(self,
parent,
id,
lang.getstr("measureframe.title"),
style=style,
name="measureframe")
self.SetIcons(config.get_icon_bundle([256, 48, 32, 16], appname))
self.Bind(wx.EVT_CLOSE, self.close_handler, self)
if os.getenv("XDG_SESSION_TYPE") != "wayland":
self.Bind(wx.EVT_MOVE, self.move_handler, self)
self.Bind(wx.EVT_SHOW, self.show_handler)
self.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_SET_FOCUS, self.focus_handler)
self.panel = BitmapBackgroundPanel(self)
self.panel.scalebitmap = (False, False)
if os.getenv("XDG_SESSION_TYPE") == "wayland":
self.sizer = wx.FlexGridSizer(3, 1, 0, 0)
self.sizer.AddGrowableCol(0)
self.sizer.AddGrowableRow(1)
else:
self.sizer = wx.GridSizer(3, 1, 0, 0)
self.panel.SetSizer(self.sizer)
self.hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.sizer.Add(self.hsizer,
flag=wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_TOP)
self.zoommaxbutton = BitmapButton(self.panel,
-1,
geticon(16, "zoom-best-fit"),
style=wx.NO_BORDER,
name="zoommaxbutton")
self.zoommaxbutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.zoommax_handler, self.zoommaxbutton)
self.hsizer.Add(self.zoommaxbutton,
flag=wx.ALIGN_CENTER | wx.LEFT | wx.TOP | wx.BOTTOM,
border=10)
self.zoommaxbutton.SetToolTipString(
lang.getstr("measureframe.zoommax"))
self.hsizer.Add((8, 0))
self.zoominbutton = BitmapButton(self.panel,
-1,
geticon(16, "zoom-in"),
style=wx.NO_BORDER,
name="zoominbutton")
self.zoominbutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.zoomin_handler, self.zoominbutton)
self.hsizer.Add(self.zoominbutton,
flag=wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM,
border=10)
self.zoominbutton.SetToolTipString(lang.getstr("measureframe.zoomin"))
self.hsizer.Add((8, 0))
self.zoomnormalbutton = BitmapButton(self.panel,
-1,
geticon(16, "zoom-original"),
style=wx.NO_BORDER,
name="zoomnormalbutton")
self.zoomnormalbutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.zoomnormal_handler,
self.zoomnormalbutton)
self.hsizer.Add(self.zoomnormalbutton,
flag=wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM,
border=10)
self.zoomnormalbutton.SetToolTipString(
lang.getstr("measureframe."
"zoomnormal"))
self.hsizer.Add((8, 0))
self.zoomoutbutton = BitmapButton(self.panel,
-1,
geticon(16, "zoom-out"),
style=wx.NO_BORDER,
name="zoomoutbutton")
self.zoomoutbutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.zoomout_handler, self.zoomoutbutton)
self.hsizer.Add(self.zoomoutbutton,
flag=wx.ALIGN_CENTER | wx.RIGHT | wx.TOP | wx.BOTTOM,
border=10)
self.zoomoutbutton.SetToolTipString(
lang.getstr("measureframe.zoomout"))
if os.getenv("XDG_SESSION_TYPE") != "wayland":
# No manual centering under Wayland...
self.centerbutton = BitmapButton(self.panel,
-1,
geticon(16, "window-center"),
style=wx.NO_BORDER,
name="centerbutton")
self.centerbutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.center_handler, self.centerbutton)
self.sizer.Add(self.centerbutton,
flag=wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT,
border=10)
self.centerbutton.SetToolTipString(
lang.getstr("measureframe.center"))
else:
self.centermsg = wx.StaticText(
self.panel,
-1,
lang.getstr("measureframe.center.manual"),
style=wx.ALIGN_CENTER_HORIZONTAL)
self.centermsg.Wrap(self.hsizer.MinSize[0] - 20)
self.sizer.Add(self.centermsg,
flag=wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT,
border=10)
self.vsizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.vsizer,
flag=wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL)
if (os.getenv("XDG_SESSION_TYPE") != "wayland"
or config.is_virtual_display()):
self.measure_darken_background_cb = wx.CheckBox(
self.panel, -1, lang.getstr("measure.darken_background"))
self.measure_darken_background_cb.SetValue(
bool(int(getcfg("measure.darken_background"))))
self.measure_darken_background_cb.Bind(wx.EVT_KILL_FOCUS,
self.focus_lost_handler)
self.Bind(wx.EVT_CHECKBOX,
self.measure_darken_background_ctrl_handler,
id=self.measure_darken_background_cb.GetId())
self.vsizer.Add(self.measure_darken_background_cb,
flag=wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL
| wx.LEFT | wx.RIGHT | wx.TOP,
border=10)
else:
self.vsizer.Add((10, 10))
self.measurebutton = wx.Button(
self.panel,
-1,
lang.getstr("measureframe.measurebutton"),
name="measurebutton")
self.measurebutton.Bind(wx.EVT_KILL_FOCUS, self.focus_lost_handler)
self.Bind(wx.EVT_BUTTON, self.measure_handler, self.measurebutton)
self.vsizer.Add(self.measurebutton,
flag=wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL
| wx.ALL,
border=10)
self.measurebutton.SetMaxFontSize(11)
self.measurebutton.SetDefault()
self.last_focused = self.measurebutton
self.display_no = wx.Display.GetFromWindow(self)
self.display_rects = get_display_rects()
self.sizer.SetSizeHints(self)
def __init__(self):
SimpleTerminal.__init__(
self,
None,
wx.ID_ANY,
lang.getstr("scripting-client"),
start_timer=False,
pos=(getcfg("position.scripting.x"),
getcfg("position.scripting.y")),
size=(getcfg("size.scripting.w"), getcfg("size.scripting.h")),
consolestyle=wx.TE_CHARWRAP | wx.TE_MULTILINE | wx.TE_PROCESS_ENTER
| wx.TE_RICH | wx.VSCROLL | wx.NO_BORDER,
show=False,
name="scriptingframe")
self.SetIcons(
config.get_icon_bundle([256, 48, 32, 16],
appname + "-scripting-client"))
self.console.SetForegroundColour("#EEEEEE")
self.console.SetDefaultStyle(wx.TextAttr("#EEEEEE"))
self.busy = False
self.commands = []
self.history = []
self.historyfilename = os.path.join(
confighome, config.appbasename + "-scripting-client.history")
if os.path.isfile(self.historyfilename):
try:
with open(self.historyfilename) as historyfile:
for line in historyfile:
self.history.append(
safe_unicode(line, "UTF-8").rstrip("\r\n"))
except EnvironmentError as exception:
safe_print("Warning - couldn't read history file:", exception)
# Always have empty selection at bottom
self.history.append("")
self.historypos = len(self.history) - 1
self.overwrite = False
# Determine which application we should connect to by default (if any)
self.conn = None
scripting_hosts = self.get_scripting_hosts()
self.sizer.Layout()
if sys.platform != "darwin":
# Under Mac OS X, the transparency messes up the window shadow if
# there is another window's border behind
self.SetTransparent(240)
self.Bind(wx.EVT_ACTIVATE, self.OnActivate)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Unbind(wx.EVT_CHAR_HOOK)
self.console.Unbind(wx.EVT_KEY_DOWN, self.console)
self.console.Bind(wx.EVT_KEY_DOWN, self.key_handler)
self.console.Bind(wx.EVT_TEXT_COPY, self.copy_text_handler)
self.console.Bind(wx.EVT_TEXT_PASTE, self.paste_text_handler)
if sys.platform == "darwin":
# Under Mac OS X, pasting text via the context menu isn't catched
# by EVT_TEXT_PASTE. TODO: Implement custom context menu.
self.console.Bind(wx.EVT_CONTEXT_MENU, lambda event: None)
if scripting_hosts:
self.add_text("> getscriptinghosts" + "\n")
for host in scripting_hosts:
self.add_text(host + "\n")
ip_port = scripting_hosts[0].split()[0]
self.add_text("> connect " + ip_port + "\n")
self.connect_handler(ip_port)