# -*- coding: utf-8 -*- """Visual whitepoint editor. Based on wx.lib.agw.cubecolourdialog 0.4 by Andrea Gavana @ 26 Feb 2012 License: wxPython license """ import colorsys import os import re import sys import threading from math import atan2, cos, pi, sin, sqrt from time import sleep from DisplayCAL import ( localization as lang, ) from DisplayCAL.config import ( defaults, fs_enc, get_argyll_display_number, get_default_dpi, get_display_name, get_icon_bundle, getbitmap, getcfg, geticon, initcfg, profile_ext, setcfg, ) from DisplayCAL.icc_profile import ( ICCProfile, ICCProfileInvalidError, get_display_profile, VideoCardGammaType, WcsProfilesTagType, ) from DisplayCAL.meta import name as appname from DisplayCAL.util_list import intlist from DisplayCAL.util_str import safe_asciize, wrap from DisplayCAL.worker import ( Error, UnloggedError, Warn, Worker, get_argyll_util, show_result_dialog, ) from DisplayCAL.wxfixes import ( GenBitmapButton as BitmapButton, get_bitmap_disabled, get_bitmap_hover, get_bitmap_pressed, wx, wx_Panel, ) from DisplayCAL.wxwindows import ( FlatShadedButton, HStretchStaticBitmap, TaskBarNotification, ) from wx.lib.agw import aui from wx.lib.intctrl import IntCtrl if sys.platform == "darwin": from platform import mac_ver try: from DisplayCAL import RealDisplaySizeMM as RDSMM except ImportError: RDSMM = None # Use non-native mini frames on all platforms aui.framemanager.AuiManager_UseNativeMiniframes = ( lambda manager: (manager.GetAGWFlags() & aui.AUI_MGR_USE_NATIVE_MINIFRAMES) == aui.AUI_MGR_USE_NATIVE_MINIFRAMES ) colourAttributes = ["r", "g", "b", "h", "s", "v"] colourMaxValues = [255, 255, 255, 359, 255, 255] def rad2deg(x): """Transforms radians into degrees. :param x: a float representing an angle in radians. """ return 180.0 * x / pi def deg2rad(x): """Transforms degrees into radians. :param x: a float representing an angle in degrees. """ return x * pi / 180.0 def s(i) -> int: """Scale for HiDPI if necessary""" return int(i * max(getcfg("app.dpi") / get_default_dpi(), 1)) def update_patterngenerator(self): while self and wx.App.IsMainLoopRunning(): if self.update_patterngenerator_event.wait(0.05): self.update_patterngenerator_event.clear() x, y, size = self.patterngenerator_config self.patterngenerator.send( ( self._colour.r / 255.0, self._colour.g / 255.0, self._colour.b / 255.0, ), ( self._bgcolour.r / 255.0, self._bgcolour.g / 255.0, self._bgcolour.b / 255.0, ), x=x, y=y, w=size, h=size, ) sleep(0.05) def _show_result_after(*args, **kwargs): wx.CallAfter(show_result_dialog, *args, **kwargs) def _wait_thread(fn, *args, **kwargs): # Wait until thread is finished. Yield while waiting. thread = threading.Thread( target=fn, name="VisualWhitepointEditorMaintenance", args=args, kwargs=kwargs ) thread.start() while thread.is_alive(): wx.Yield() sleep(0.05) def Distance(pt1, pt2): """Returns the distance between 2 points. :param pt1: an instance of :class:`Point`; :param pt2: another instance of :class:`Point`. """ distance = sqrt((pt1.x - pt2.x) ** 2.0 + (pt1.y - pt2.y) ** 2.0) return int(round(distance)) def AngleFromPoint(pt, center): """Returns the angle between the x-axis and the line connecting the center and the point `pt`. :param pt: an instance of :class:`Point`; :param center: a float value representing the center. """ y = -1 * (pt.y - center.y) x = pt.x - center.x if x == 0 and y == 0: return 0.0 else: return atan2(y, x) class AuiDarkDockArt(aui.dockart.AuiDefaultDockArt): def __init__(self, *args, **kwargs): aui.dockart.AuiDefaultDockArt.__init__(self, *args, **kwargs) if hasattr(self, "SetDefaultColours"): self.SetDefaultColours(wx.Colour(51, 51, 51)) else: self.SetColour( aui.dockart.AUI_DOCKART_INACTIVE_CAPTION_COLOUR, wx.Colour(43, 43, 43) ) self.SetColour( aui.dockart.AUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR, wx.Colour(153, 153, 153), ) self.SetColour(aui.dockart.AUI_DOCKART_BORDER_COLOUR, wx.Colour(51, 102, 204)) if hasattr(aui, "AUI_DOCKART_HINT_WINDOW_COLOUR"): self.SetColour( aui.dockart.AUI_DOCKART_HINT_WINDOW_COLOUR, wx.Colour(102, 153, 204) ) self.SetMetric(aui.AUI_DOCKART_GRADIENT_TYPE, aui.AUI_GRADIENT_NONE) self.SetCustomPaneBitmap( geticon(16, "button-pin"), aui.dockart.AUI_BUTTON_CLOSE, False ) self.SetCustomPaneBitmap( geticon(16, "button-pin"), aui.dockart.AUI_BUTTON_PIN, False ) def DrawBackground(self, dc, window, orient, rect): """Draws a background. :param dc: a :class:`DC` device context; :param window: an instance of :class:`Window`; :param integer `orient`: the gradient (if any) orientation; :param Rect `rect`: the background rectangle. """ dc.SetPen(wx.TRANSPARENT_PEN) dc.SetBrush(wx.Brush(wx.Colour(51, 51, 51))) dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height) def DrawPaneButton(self, dc, window, button, button_state, _rect, pane): """Draws a pane button in the pane caption area. :param dc: a :class:`DC` device context; :param window: an instance of :class:`Window`; :param integer `button`: the button to be drawn; :param integer `button_state`: the pane button state; :param Rect `_rect`: the pane caption rectangle; :param pane: the pane for which the button is drawn. """ if not pane: return if button == aui.dockart.AUI_BUTTON_CLOSE: if pane.state & aui.dockart.optionActive: bmp = self._active_close_bitmap else: bmp = self._inactive_close_bitmap elif button == aui.dockart.AUI_BUTTON_PIN: if pane.state & aui.dockart.optionActive: bmp = self._active_pin_bitmap else: bmp = self._inactive_pin_bitmap elif button == aui.dockart.AUI_BUTTON_MAXIMIZE_RESTORE: if pane.IsMaximized(): if pane.state & aui.dockart.optionActive: bmp = self._active_restore_bitmap else: bmp = self._inactive_restore_bitmap else: if pane.state & aui.dockart.optionActive: bmp = self._active_maximize_bitmap else: bmp = self._inactive_maximize_bitmap elif button == aui.dockart.AUI_BUTTON_MINIMIZE: if pane.state & aui.dockart.optionActive: bmp = self._active_minimize_bitmap else: bmp = self._inactive_minimize_bitmap isVertical = pane.HasCaptionLeft() rect = wx.Rect(*_rect) if isVertical: old_x = rect.x rect.x = int(rect.x + (rect.width / 2) - (bmp.GetWidth() / 2)) rect.width = old_x + rect.width - rect.x - 1 else: old_y = rect.y rect.y = int(rect.y + (rect.height / 2) - (bmp.GetHeight() / 2)) rect.height = old_y + rect.height - rect.y - 1 if button_state == aui.dockart.AUI_BUTTON_STATE_PRESSED: rect.x += 1 rect.y += 1 if button_state == aui.dockart.AUI_BUTTON_STATE_HOVER: bmp = get_bitmap_hover(bmp) elif button_state == aui.dockart.AUI_BUTTON_STATE_PRESSED: bmp = get_bitmap_pressed(bmp) if isVertical: bmp = wx.ImageFromBitmap(bmp).Rotate90(clockwise=False).ConvertToBitmap() # draw the button itself dc.DrawBitmap(bmp, rect.x, rect.y, True) def SetCustomPaneBitmap(self, bmp, button, active, maximize=False): """Sets a custom button bitmap for the pane button. :param Bitmap `bmp`: the actual bitmap to set; :param integer `button`: the button identifier; :param bool `active`: whether it is the bitmap for the active button or not; :param bool `maximize`: used to distinguish between the maximize and restore bitmaps. """ if button == aui.dockart.AUI_BUTTON_CLOSE: if active: self._active_close_bitmap = bmp else: self._inactive_close_bitmap = bmp if wx.Platform == "__WXMAC__": self._custom_pane_bitmaps = True elif button == aui.dockart.AUI_BUTTON_PIN: if active: self._active_pin_bitmap = bmp else: self._inactive_pin_bitmap = bmp elif button == aui.dockart.AUI_BUTTON_MAXIMIZE_RESTORE: if maximize: if active: self._active_maximize_bitmap = bmp else: self._inactive_maximize_bitmap = bmp else: if active: self._active_restore_bitmap = bmp else: self._inactive_restore_bitmap = bmp elif button == aui.dockart.AUI_BUTTON_MINIMIZE: if active: self._active_minimize_bitmap = bmp else: self._inactive_minimize_bitmap = bmp class AuiManager_LRDocking(aui.AuiManager): """AuiManager with only left/right docking. Also, it is not necessary to hover the drop guide, a drop hint will show near the edges regardless. """ def CreateGuideWindows(self): self.DestroyGuideWindows() def DoDrop(self, docks, panes, target, pt, offset=None): """This is an important function. It basically takes a mouse position, and determines where the panes new position would be. If the pane is to be dropped, it performs the drop operation using the specified dock and pane arrays. By specifying copy dock and pane arrays when calling, a "what-if" scenario can be performed, giving precise coordinates for drop hints. :param docks: a list of :class:`AuiDockInfo` classes; :param panes: a list of :class:`AuiPaneInfo` instances; :param Point `pt`: a mouse position to check for a drop operation; :param Point `offset`: a possible offset from the input point `pt`. """ if offset is None: offset = wx.Point(0, 0) if target.IsToolbar(): return self.DoDropToolbar(docks, panes, target, pt, offset) else: if target.IsFloating(): allow, hint = self.DoDropFloatingPane(docks, panes, target, pt) if allow: return allow, hint return self.DoDropNonFloatingPane(docks, panes, target, pt) def DoDropNonFloatingPane(self, docks, panes, target, pt): """Handles the situation in which the dropped pane is not floating. :param docks: a list of :class:`AuiDockInfo` classes; :param panes: a list of :class:`AuiPaneInfo` instances; :param AuiPaneInfo `target`: the target pane containing the toolbar; :param Point `pt`: a mouse position to check for a drop operation. """ # The ONLY change from # wx.lib.framemanager.FrameManager.DoDropNonFloatingPane # is the removal of top offset by setting new_row_pixels_y to 0. # This way, the drag hint is shown when the mouse is near the right # frame side irrespective of mouse Y position. # screenPt = self._frame.ClientToScreen(pt) # clientSize = self._frame.GetClientSize() # frameRect = aui.GetInternalFrameRect(self._frame, self._docks) drop = self.CopyTarget(target) # The result should always be shown drop.Show() part = self.HitTest(pt.x, pt.y) if not part: return False, target if part.type == aui.AuiDockUIPart.typeDockSizer: if len(part.dock.panes) != 1: return False, target part = self.GetPanePart(part.dock.panes[0].window) if not part: return False, target if not part.pane: return False, target part = self.GetPanePart(part.pane.window) if not part: return False, target insert_dock_row = False insert_row = part.pane.dock_row insert_dir = part.pane.dock_direction insert_layer = part.pane.dock_layer direction = part.pane.dock_direction if direction == aui.AUI_DOCK_TOP: if part.rect.y <= pt.y < part.rect.y + aui.auiInsertRowPixels: insert_dock_row = True elif direction == aui.AUI_DOCK_BOTTOM: if ( part.rect.y + part.rect.height - aui.auiInsertRowPixels < pt.y <= part.rect.y + part.rect.height ): insert_dock_row = True elif direction == aui.AUI_DOCK_LEFT: if part.rect.x <= pt.x < part.rect.x + aui.auiInsertRowPixels: insert_dock_row = True elif direction == aui.AUI_DOCK_RIGHT: if ( part.rect.x + part.rect.width - aui.auiInsertRowPixels < pt.x <= part.rect.x + part.rect.width ): insert_dock_row = True elif direction == aui.AUI_DOCK_CENTER: # "new row pixels" will be set to the default, but # must never exceed 20% of the window size new_row_pixels_x = s(20) new_row_pixels_y = 0 if new_row_pixels_x > (part.rect.width * 20) / 100: new_row_pixels_x = (part.rect.width * 20) / 100 if new_row_pixels_y > (part.rect.height * 20) / 100: new_row_pixels_y = (part.rect.height * 20) / 100 # determine if the mouse pointer is in a location that # will cause a new row to be inserted. The hot spot positions # are along the borders of the center pane insert_layer = 0 insert_dock_row = True pr = part.rect if pr.x <= pt.x < pr.x + new_row_pixels_x: insert_dir = aui.AUI_DOCK_LEFT elif pr.y <= pt.y < pr.y + new_row_pixels_y: insert_dir = aui.AUI_DOCK_TOP elif pr.x + pr.width - new_row_pixels_x <= pt.x < pr.x + pr.width: insert_dir = aui.AUI_DOCK_RIGHT elif pr.y + pr.height - new_row_pixels_y <= pt.y < pr.y + pr.height: insert_dir = aui.AUI_DOCK_BOTTOM else: return False, target insert_row = aui.GetMaxRow(panes, insert_dir, insert_layer) + 1 if insert_dock_row: panes = aui.DoInsertDockRow(panes, insert_dir, insert_layer, insert_row) drop.Dock().Direction(insert_dir).Layer(insert_layer).Row( insert_row ).Position(0) return self.ProcessDockResult(target, drop) # determine the mouse offset and the pane size, both in the # direction of the dock itself, and perpendicular to the dock if part.orientation == wx.VERTICAL: offset = pt.y - part.rect.y size = part.rect.GetHeight() else: offset = pt.x - part.rect.x size = part.rect.GetWidth() drop_position = part.pane.dock_pos # if we are in the top/left part of the pane, # insert the pane before the pane being hovered over if offset <= size / 2: drop_position = part.pane.dock_pos panes = aui.DoInsertPane( panes, part.pane.dock_direction, part.pane.dock_layer, part.pane.dock_row, part.pane.dock_pos, ) # if we are in the bottom/right part of the pane, # insert the pane before the pane being hovered over if offset > size / 2: drop_position = part.pane.dock_pos + 1 panes = aui.DoInsertPane( panes, part.pane.dock_direction, part.pane.dock_layer, part.pane.dock_row, part.pane.dock_pos + 1, ) drop.Dock().Direction(part.dock.dock_direction).Layer(part.dock.dock_layer).Row( part.dock.dock_row ).Position(drop_position) return self.ProcessDockResult(target, drop) class Colour: """This is a class similar to :class:`Colour`, which adds Hue, Saturation and Brightness capability. It contains also methods to convert RGB triplets into HSB triplets and vice-versa. """ def __init__(self, colour): """Default class constructor. :param colour: a standard :class:`Colour`. """ self.r = colour.Red() self.g = colour.Green() self.b = colour.Blue() self._alpha = colour.Alpha() self.ToHSV() def ToRGB(self): """Converts a HSV triplet into a RGB triplet.""" maxVal = self.v delta = (maxVal * self.s) / 255.0 minVal = maxVal - delta hue = float(self.h) if self.h > 300 or self.h <= 60: self.r = maxVal if self.h > 300: self.g = int(round(minVal)) hue = (hue - 360.0) / 60.0 self.b = int(round(-(hue * delta - minVal))) else: self.b = int(round(minVal)) hue = hue / 60.0 self.g = int(round(hue * delta + minVal)) elif 60 < self.h < 180: self.g = int(round(maxVal)) if self.h < 120: self.b = int(round(minVal)) hue = (hue / 60.0 - 2.0) * delta self.r = int(round(minVal - hue)) else: self.r = int(round(minVal)) hue = (hue / 60.0 - 2.0) * delta self.b = int(round(minVal + hue)) else: self.b = int(round(maxVal)) if self.h < 240: self.r = int(round(minVal)) hue = (hue / 60.0 - 4.0) * delta self.g = int(round(minVal - hue)) else: self.g = int(round(minVal)) hue = (hue / 60.0 - 4.0) * delta self.r = int(round(minVal + hue)) def ToHSV(self): """Converts a RGB triplet into a HSV triplet.""" minVal = float(min(self.r, min(self.g, self.b))) maxVal = float(max(self.r, max(self.g, self.b))) delta = maxVal - minVal self.v = int(round(maxVal)) if abs(delta) < 1e-6: self.h = self.s = 0 else: temp = delta / maxVal self.s = int(round(temp * 255.0)) if self.r == int(round(maxVal)): temp = float(self.g - self.b) / delta elif self.g == int(round(maxVal)): temp = 2.0 + (float(self.b - self.r) / delta) else: temp = 4.0 + (float(self.r - self.g) / delta) temp *= 60 if temp < 0: temp += 360 elif temp >= 360.0: temp = 0 self.h = int(round(temp)) def GetPyColour(self): """Returns the wxPython :class:`Colour` associated with this instance.""" return wx.Colour(int(self.r), int(self.g), int(self.b), int(self._alpha)) class BasePyControl(wx.PyControl): """Base class used to hold common code for the HSB colour wheel and the RGB colour cube. """ def __init__(self, parent, bitmap=None): """Default class constructor. Used internally. Do not call it in your code! :param parent: the control parent; :param bitmap: the background bitmap for this custom control. """ wx.PyControl.__init__(self, parent, style=wx.NO_BORDER) self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self._bitmap = bitmap self._mainFrame = wx.GetTopLevelParent(self) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.Bind(wx.EVT_MOTION, self.OnMotion) def OnPaint(self, event): """Handles the ``wx.EVT_PAINT`` for :class:`BasePyControl`. :param event: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) self.Draw(dc) def Draw(self, dc): if "gtk3" in wx.PlatformInfo: bgcolour = self.Parent.BackgroundColour else: bgcolour = self.BackgroundColour dc.SetBackground(wx.Brush(bgcolour)) dc.Clear() dc.DrawBitmap(self._bitmap, 0, 0, True) def OnEraseBackground(self, event): """Handles the ``wx.EVT_ERASE_BACKGROUND`` for :class:`BasePyControl`. :param event: a :class:`EraseEvent` event to be processed. :note: This is intentionally empty to reduce flicker. """ pass def DrawMarkers(self, dc=None): """Draws the markers on top of the background bitmap. :param dc: an instance of :class:`DC`. :note: This method must be overridden in derived classes. """ pass def DrawLines(self, dc): """Draws the lines connecting the markers on top of the background bitmap. :param dc: an instance of :class:`DC`. :note: This method must be overridden in derived classes. """ pass def AcceptsFocusFromKeyboard(self): """Can this window be given focus by keyboard navigation? If not, the only way to give it focus (provided it accepts it at all) is to click it. :note: This method always returns ``False`` as we do not accept focus from the keyboard. :note: Overridden from :class:`PyControl`. """ return False def AcceptsFocus(self): """Can this window be given focus by mouse click? :note: This method always returns ``False`` as we do not accept focus from mouse click. :note: Overridden from :class:`PyControl`. """ return False def OnLeftDown(self, event): """Handles the ``wx.EVT_LEFT_DOWN`` for :class:`BasePyControl`. :param event: a :class:`MouseEvent` event to be processed. :note: This method must be overridden in derived classes. """ pass def OnLeftUp(self, event): """Handles the ``wx.EVT_LEFT_UP`` for :class:`BasePyControl`. :param event: a :class:`MouseEvent` event to be processed. :note: This method must be overridden in derived classes. """ pass def OnMotion(self, event): """Handles the ``wx.EVT_MOTION`` for :class:`BasePyControl`. :param event: a :class:`MouseEvent` event to be processed. :note: This method must be overridden in derived classes. """ pass def OnSize(self, event): """Handles the ``wx.EVT_SIZE`` for :class:`BasePyControl`. :param event: a :class:`SizeEvent` event to be processed. """ self.Refresh() def DoGetBestSize(self): """Overridden base class virtual. Determines the best size of the control based on the bitmap size. :note: Overridden from :class:`PyControl`. """ return wx.Size(self._bitmap.GetWidth(), self._bitmap.GetHeight()) class BasePyButton(BasePyControl): def __init__(self, parent, bitmap): BasePyControl.__init__(self, parent, bitmap) self._bitmap_enabled = bitmap self._bitmap_disabled = get_bitmap_disabled(bitmap) self._bitmap_hover = get_bitmap_hover(bitmap) self._bitmap_pressed = get_bitmap_pressed(bitmap) self.Bind(wx.EVT_ENTER_WINDOW, self.OnMouseEnter) self.Bind(wx.EVT_LEAVE_WINDOW, self.OnMouseLeave) def OnLeftDown(self, event): if self.Enabled: self._bitmap = self._bitmap_pressed self.Refresh() event.Skip() def OnLeftUp(self, event): if self.Enabled: self._bitmap = self._bitmap_hover self.Refresh() event.Skip() def OnMouseEnter(self, event): if self.Enabled: if self.HasCapture(): self._bitmap = self._bitmap_pressed else: self._bitmap = self._bitmap_hover self.Refresh() event.Skip() def OnMouseLeave(self, event): if self.Enabled: self._bitmap = self._bitmap_enabled self.Refresh() event.Skip() def Enable(self, enable=True): if enable != self.Enabled: BasePyControl.Enable(self, enable) if self.Enabled: self._bitmap = self._bitmap_enabled else: self._bitmap = self._bitmap_disabled self.Refresh() class HSVWheel(BasePyControl): """Implements the drawing, mouse handling and sizing routines for the HSV colour wheel. """ def __init__(self, parent, bgcolour): """Default class constructor. Used internally. Do not call it in your code! :param parent: the control parent window. """ BasePyControl.__init__(self, parent, bitmap=getbitmap("theme/colorwheel")) self._bitmap = ( self._bitmap.ConvertToImage() .AdjustChannels(0.8, 0.8, 0.8) .ConvertToBitmap() ) self._mouseIn = False self._buffer = wx.EmptyBitmap(self._bitmap.Width, self._bitmap.Height) self._bg = wx.EmptyBitmap(self._bitmap.Width, self._bitmap.Height) self._bgdc = wx.MemoryDC(self._bg) self.BackgroundColour = bgcolour self.Draw(self._bgdc) def DrawMarkers(self, dc=None): """Draws the markers on top of the background bitmap. :param dc: an instance of :class:`DC`. """ if dc is None: dc = wx.ClientDC(self) if sys.platform != "darwin": dc = wx.BufferedDC(dc, self._buffer) # Blit the DC with our background to the current DC. # Much faster than redrawing the background every time. dc.Blit(0, 0, self._bg.Width, self._bg.Height, self._bgdc, 0, 0) brightMark = self._mainFrame._currentRect darkMarkOuter = wx.Rect( brightMark.x - 1, brightMark.y - 1, brightMark.width + 2, brightMark.height + 2, ) darkMarkInner = wx.Rect( brightMark.x + 1, brightMark.y + 1, brightMark.width - 2, brightMark.height - 2, ) dc.SetBrush(wx.TRANSPARENT_BRUSH) for pencolour, rect in ( (wx.Colour(34, 34, 34), darkMarkOuter), (wx.LIGHT_GREY, brightMark), (wx.Colour(34, 34, 34), darkMarkInner), ): dc.SetPen(wx.Pen(pencolour, 1)) dc.DrawRectangle(rect) def OnLeftDown(self, event): """Handles the ``wx.EVT_LEFT_DOWN`` for :class:`HSVWheel`. :param event: a :class:`MouseEvent` event to be processed. """ point = wx.Point(event.GetX(), event.GetY()) self._mouseIn = False if self.InCircle(point): self._mouseIn = True if self._mouseIn: self.CaptureMouse() self.TrackPoint(point) def OnLeftUp(self, event): """Handles the ``wx.EVT_LEFT_UP`` for :class:`HSVWheel`. :param event: a :class:`MouseEvent` event to be processed. """ if self.GetCapture(): self.ReleaseMouse() self._mouseIn = False def OnMotion(self, event): """Handles the ``wx.EVT_MOTION`` for :class:`HSVWheel`. :param event: a :class:`MouseEvent` event to be processed. """ point = wx.Point(event.GetX(), event.GetY()) if self.GetCapture() and self._mouseIn: self.TrackPoint(point) def OnPaint(self, event): """Handles the ``wx.EVT_PAINT`` for :class:`BasePyControl`. :param event: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) if self._mainFrame._initOver: self.DrawMarkers(dc) else: self.Draw(dc) def InCircle(self, pt): """Returns whether a point is inside the HSV wheel or not. :param pt: an instance of :class:`Point`. """ return Distance(pt, self._mainFrame._centre) <= (self._bitmap.Size[0]) / 2 def TrackPoint(self, pt): """Track a mouse event inside the HSV colour wheel. :param pt: an instance of :class:`Point`. """ if not self._mouseIn: return mainFrame = self._mainFrame colour = mainFrame._colour colour.h = int(round(rad2deg(AngleFromPoint(pt, mainFrame._centre)))) if colour.h < 0: colour.h += 360 colour.s = int( round( Distance(pt, mainFrame._centre) * 255.0 / ((self._bitmap.Size[0] - s(12)) / 2) * 0.2 ) ) if colour.s > 255: colour.s = 255 mainFrame.CalcRects() self.DrawMarkers() colour.ToRGB() mainFrame.SetSpinVals() mainFrame.DrawBright() class BaseLineCtrl(wx.PyControl): """Base class used to hold common code for the Alpha channel control and the brightness palette control. """ def __init__(self, parent, size=wx.DefaultSize): """Default class constructor. Used internally. Do not call it in your code! :param parent: the control parent window. """ wx.PyControl.__init__(self, parent, size=size, style=wx.NO_BORDER) self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self._mainFrame = wx.GetTopLevelParent(self) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.Bind(wx.EVT_MOTION, self.OnMotion) def OnEraseBackground(self, event): """Handles the ``wx.EVT_ERASE_BACKGROUND`` for :class:`BaseLineCtrl`. :param event: a :class:`EraseEvent` event to be processed. :note: This is intentionally empty to reduce flicker. """ pass def OnLeftDown(self, event): """Handles the ``wx.EVT_LEFT_DOWN`` for :class:`BaseLineCtrl`. :param event: a :class:`MouseEvent` event to be processed. """ point = wx.Point(event.GetX(), event.GetY()) theRect = self.GetClientRect() if not theRect.Contains(point): event.Skip() return self.CaptureMouse() self.TrackPoint(point) def OnLeftUp(self, event): """Handles the ``wx.EVT_LEFT_UP`` for :class:`BaseLineCtrl`. :param event: a :class:`MouseEvent` event to be processed. """ if self.GetCapture(): self.ReleaseMouse() self.Refresh() # Needed for proper redrawing after click under OS X def OnMotion(self, event): """Handles the ``wx.EVT_MOTION`` for :class:`BaseLineCtrl`. :param event: a :class:`MouseEvent` event to be processed. """ point = wx.Point(event.GetX(), event.GetY()) if self.GetCapture(): self.TrackPoint(point) def OnSize(self, event): """Handles the ``wx.EVT_SIZE`` for :class:`BaseLineCtrl`. :param event: a :class:`SizeEvent` event to be processed. """ self.Refresh() def BuildRect(self): """Internal method.""" brightRect = wx.Rect(*self.GetClientRect()) brightRect.x += s(2) brightRect.y += s(2) brightRect.width -= s(4) brightRect.height -= s(4) return brightRect def AcceptsFocusFromKeyboard(self): """Can this window be given focus by keyboard navigation? If not, the only way to give it focus (provided it accepts it at all) is to click it. :note: This method always returns ``False`` as we do not accept focus from the keyboard. :note: Overridden from :class:`PyControl`. """ return False def AcceptsFocus(self): """Can this window be given focus by mouse click? :note: This method always returns ``False`` as we do not accept focus from mouse click. :note: Overridden from :class:`PyControl`. """ return False class BrightCtrl(BaseLineCtrl): """Implements the drawing, mouse handling and sizing routines for the brightness palette control. """ def __init__(self, parent, colour=None): """Default class constructor. Used internally. Do not call it in your code! :param parent: the control parent window. """ BaseLineCtrl.__init__(self, parent, size=(s(20), s(102))) self._colour = colour or self._mainFrame._colour self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_MOUSEWHEEL, self.mousewheel_handler) def OnPaint(self, event): """Handles the ``wx.EVT_PAINT`` for :class:`BrightCtrl`. :param event: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) self.DrawMarkers(dc) def DoGetBestSize(self): """Overridden base class virtual. Determines the best size of the control. :note: Overridden from :class:`PyControl`. """ return wx.Size(s(20), s(102)) def Draw(self, dc): if "gtk3" in wx.PlatformInfo: bgcolour = self.Parent.BackgroundColour else: bgcolour = self.BackgroundColour dc.SetBackground(wx.Brush(bgcolour)) dc.Clear() colour = self._colour.GetPyColour() brightRect = self.BuildRect() target_red = colour.Red() target_green = colour.Green() target_blue = colour.Blue() h, s, v = colorsys.rgb_to_hsv( target_red / 255.0, target_green / 255.0, target_blue / 255.0 ) v = 0.8 vstep = v / (brightRect.height - 1) for y_pos in range(brightRect.y, brightRect.height + brightRect.y): r, g, b = [round(c * 255.0) for c in colorsys.hsv_to_rgb(h, s, v)] colour = wx.Colour(int(r), int(g), int(b)) dc.SetPen(wx.Pen(colour, 1, wx.SOLID)) dc.DrawRectangle(brightRect.x, y_pos, brightRect.width, 1) v = v - vstep dc.SetPen(wx.TRANSPARENT_PEN) dc.SetBrush(wx.TRANSPARENT_BRUSH) dc.DrawRectangle(brightRect) def TrackPoint(self, pt): """Tracks a mouse action inside the palette control. :param pt: an instance of :class:`Point`. """ brightRect = self.BuildRect() d = brightRect.GetBottom() - pt.y d *= 255 d /= brightRect.height if d < 0: d = 0 if d > 255: d = 255 mainFrame = self._mainFrame colour = self._colour colour.v = int(round(d)) mainFrame.DrawMarkers() colour.ToRGB() mainFrame.SetSpinVals() def DrawMarkers(self, dc=None): """Draws square markers used with mouse gestures. :param dc: an instance of :class:`DC`. """ if dc is None: dc = wx.ClientDC(self) if sys.platform != "darwin": dc = wx.BufferedDC(dc) self.Draw(dc) colour = self._colour brightRect = self.BuildRect() y = int(round(colour.v / 255.0 * (brightRect.height - s(6)))) y = brightRect.height - s(4) - 1 - y h = s(8) darkMarkOuter = wx.Rect(brightRect.x - 2, y - 1, brightRect.width + 4, h) brightMark = wx.Rect(brightRect.x - 1, y, brightRect.width + 2, h - 2) darkMarkInner = wx.Rect(brightRect.x, y + 1, brightRect.width, h - 4) dc.SetBrush(wx.TRANSPARENT_BRUSH) for pencolour, rect in ( (wx.Colour(34, 34, 34), darkMarkOuter), (wx.LIGHT_GREY, brightMark), (wx.Colour(34, 34, 34), darkMarkInner), ): dc.SetPen(wx.Pen(pencolour, 1)) dc.DrawRectangle(rect) def mousewheel_handler(self, event): self._spin(event.GetWheelRotation()) def _spin(self, direction): if direction > 0: if self._colour.v < 255: self._colour.v += 1 else: if self._colour.v > 0: self._colour.v -= 1 self._mainFrame.DrawMarkers() self._colour.ToRGB() self._mainFrame.SetSpinVals() class HSlider(BaseLineCtrl): """Implements the drawing, mouse handling and sizing routines for the slider control. """ def __init__(self, parent, value=0, minval=0, maxval=100, onchange=None): """Default class constructor. Used internally. Do not call it in your code! :param parent: the control parent window. """ BaseLineCtrl.__init__(self, parent, size=(s(140), s(8))) self.value = value self.minval = minval self.maxval = maxval self.onchange = onchange self._hasfocus = False self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_SET_FOCUS, self.focus_handler) self.Bind(wx.EVT_KILL_FOCUS, self.focus_handler) self.Bind(wx.EVT_KEY_DOWN, self.key_handler) self.Bind(wx.EVT_KEY_UP, self.key_handler) self.Bind(wx.EVT_MOUSEWHEEL, self.mousewheel_handler) def OnPaint(self, event): """Handles the ``wx.EVT_PAINT`` for :class:`BrightCtrl`. :param event: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) self.DrawMarkers(dc) def DoGetBestSize(self): """Overridden base class virtual. Determines the best size of the control. :note: Overridden from :class:`PyControl`. """ return wx.Size(s(140), s(8)) def BuildRect(self): brightRect = self.GetClientRect() brightRect.y += int((brightRect.height - 8) / 2.0) brightRect.height = s(8) return brightRect def Draw(self, dc): if "gtk3" in wx.PlatformInfo: bgcolour = self.Parent.BackgroundColour else: bgcolour = self.BackgroundColour dc.SetBackground(wx.Brush(bgcolour)) dc.Clear() brightRect = self.BuildRect() dc.SetPen(wx.TRANSPARENT_PEN) dc.SetBrush(wx.Brush(wx.Colour(76, 76, 76))) dc.DrawRectangle(brightRect) def TrackPoint(self, pt): """Tracks a mouse action inside the palette control. :param pt: an instance of :class:`Point`. """ brightRect = self.BuildRect() d = pt.x d *= self.maxval d /= brightRect.width if d < self.minval: d = self.minval if d > self.maxval: d = self.maxval self.value = d self.DrawMarkers() if callable(self.onchange): self.onchange() def DrawMarkers(self, dc=None): """Draws square markers used with mouse gestures. :param dc: an instance of :class:`DC`. """ if dc is None: dc = wx.ClientDC(self) if sys.platform != "darwin": dc = wx.BufferedDC(dc) self.Draw(dc) brightRect = self.BuildRect() w = s(8) x = int( round( (self.value - self.minval) / float(self.maxval - self.minval) * (brightRect.width - w) ) ) brightMark = wx.Rect(x, brightRect.y, w, brightRect.height) dc.SetBrush(wx.Brush(wx.Colour(153, 153, 153))) dc.DrawRectangle(brightMark) def GetValue(self): return self.value def SetValue(self, value): self.value = value self.DrawMarkers() @property def Value(self): return self.GetValue() @Value.setter def Value(self, value): self.SetValue(value) def GetMax(self): return self.maxval def GetMin(self): return self.minval def SetMax(self, maxval): self.maxval = maxval self.Refresh() @property def Max(self): return self.GetMax() @Max.setter def Max(self, value): self.SetMax(value) def focus_handler(self, event): self._hasfocus = event.GetEventType() == wx.EVT_SET_FOCUS.evtType[0] def key_handler(self, event): if event.KeyCode in (wx.WXK_RIGHT, wx.WXK_NUMPAD_RIGHT): self._spin(1) elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_NUMPAD_LEFT): self._spin(-1) else: event.Skip() def mousewheel_handler(self, event): self._spin(event.GetWheelRotation()) def _spin(self, direction): inc = (self.maxval - self.minval) / self.ClientSize[0] if direction > 0: if self.Value < self.maxval: self.Value += inc else: if self.Value > self.minval: self.Value -= inc self._mainFrame.area_handler() class NumSpin(wx_Panel): def __init__(self, parent, id=-1, *args, **kwargs): wx_Panel.__init__(self, parent) self.BackgroundColour = "#404040" self.Sizer = wx.BoxSizer(wx.HORIZONTAL) self.numctrl = IntCtrl(self, -1, *args, **kwargs) self.numctrl.BackgroundColour = self.BackgroundColour self.numctrl.SetColors("#999999", "#CC0000") self.numctrl.Bind(wx.EVT_KEY_DOWN, self.key_handler) self.numctrl.Bind(wx.EVT_MOUSEWHEEL, self.mousewheel_handler) self.Sizer.Add(self.numctrl, 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, s(5)) vsizer = wx.BoxSizer(wx.VERTICAL) self.Sizer.Add(vsizer, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT | wx.RIGHT, s(2)) self.spinup = BasePyButton(self, geticon(10, "spin_up")) self.spinup.BackgroundColour = self.BackgroundColour self.spinup.Bind(wx.EVT_LEFT_DOWN, self.left_down_handler) self.spinup.Bind(wx.EVT_LEFT_UP, self.left_up_handler) vsizer.Add(self.spinup, 0, wx.BOTTOM, s(1)) self.spindn = BasePyButton(self, geticon(10, "spin_down")) self.spindn.BackgroundColour = self.BackgroundColour self.spindn.Bind(wx.EVT_LEFT_DOWN, self.left_down_handler) self.spindn.Bind(wx.EVT_LEFT_UP, self.left_up_handler) vsizer.Add(self.spindn, 0, wx.ALIGN_TOP | wx.TOP, s(1)) self._left_down_count = 0 self._left_up_count = 0 def __getattr__(self, name): return getattr(self.numctrl, name) def is_button_pressed(self, btn): return ( btn.Enabled and btn.HasCapture() and btn.ClientRect.Contains(btn.ScreenToClient(wx.GetMousePosition())) ) def left_down_handler(self, event): self._left_down_count += 1 if self._capture_mouse(event): if event.GetEventObject() is self.spinup: self._spin(1, event, bell=False) else: self._spin(-1, event, bell=False) event.Skip() def left_up_handler(self, event): self._left_up_count += 1 while self._left_up_count > self._left_down_count: # Broken platform (wxMac?) :-( # print 'UP', self._left_up_count, 'DN', self._left_down_count self.left_down_handler(event) obj = event.GetEventObject() if obj.HasCapture(): obj.ReleaseMouse() event.Skip() def key_handler(self, event): if event.KeyCode in (wx.WXK_UP, wx.WXK_NUMPAD_UP): self._spin(1, event, bell=False) elif event.KeyCode in (wx.WXK_DOWN, wx.WXK_NUMPAD_DOWN): self._spin(-1, event, bell=False) else: event.Skip() def mousewheel_handler(self, event): if event.GetWheelRotation() > 0: self._spin(1, event, bell=False) else: self._spin(-1, event, bell=False) def _capture_mouse(self, event): obj = event.GetEventObject() if obj.Enabled and not obj.HasCapture(): point = wx.Point(event.GetX(), event.GetY()) if obj.ClientRect.Contains(point): obj.CaptureMouse() return True return obj.Enabled and obj.HasCapture() def _spin(self, inc, event, n=None, delay=500, bell=True): current = self.numctrl.GetValue() if n is None: n = current + inc if inc > 0: btn = self.spinup else: btn = self.spindn if event or self.is_button_pressed(btn): if n == current or (inc > 0 and n < current) or (inc < 0 and n > current): # print '!_spin', current, inc, n, delay, bell pass elif self.numctrl.GetMin() <= n <= self.numctrl.GetMax(): # print '_spin', current, inc, n, delay, bell self.SetValue(n) elif bell: wx.Bell() if btn.Enabled and btn.HasCapture(): current = self.numctrl.GetValue() wx.CallLater(delay, self._spin, inc, None, current + inc, 100) def GetValue(self): return self.numctrl.GetValue() def SetValue(self, value): self.numctrl.SetValue(value) if self.numctrl.GetMax() <= value: self.spinup.HasCapture() and self.spinup.ReleaseMouse() if self.numctrl.GetMin() >= value: self.spindn.HasCapture() and self.spindn.ReleaseMouse() self.spinup.Enable(self.numctrl.GetMax() > value) self.spindn.Enable(self.numctrl.GetMin() < value) @property def Value(self): return self.GetValue() @Value.setter def Value(self, value): self.SetValue(value) class ProfileManager: """Manages profiles associated with the display that a window is on. Clears calibration on the display we're on, and restores it when moved to another display or the window is closed. """ managers = [] def __init__(self, window, geometry=None, profile=None): self._display = window.GetDisplay() self._lock = threading.Lock() self._profiles = {} self._srgb_profile = ICCProfile.from_named_rgb_space("sRGB") self._srgb_profile.setDescription( f"{appname} Visual Whitepoint Editor Temporary Profile" ) self._srgb_profile.calculateID() self._window = window self._window.Bind(wx.EVT_CLOSE, self.window_close_handler) self._window.Bind(wx.EVT_MOVE, self.window_move_handler) self._window.Bind(wx.EVT_DISPLAY_CHANGED, self.display_changed_handler) self._worker = Worker() ProfileManager.managers.append(self) self.update(False) self._profiles_overridden = {} if geometry and profile: self._profiles_overridden[geometry] = profile def _manage_display(self, display_no, geometry): # Has to be thread-safe! with self._lock: try: display_profile = get_display_profile(display_no) except (ICCProfileInvalidError, IOError, IndexError) as exception: print( "Could not get display profile for display %i" % (display_no + 1), "@ %i, %i, %ix%i:" % geometry, exception, ) else: profile = self._profiles_overridden.get(geometry) if not profile: profile = display_profile if display_profile and display_profile.ID != self._srgb_profile.ID: # Set initial whitepoint according to vcgt # Convert calibration information from embedded WCS # profile (if present) to VideCardGammaType if the # latter is not present if ( isinstance(profile.tags.get("MS00"), WcsProfilesTagType) and "vcgt" not in profile.tags ): profile.tags["vcgt"] = profile.tags["MS00"].get_vcgt() if isinstance(profile.tags.get("vcgt"), VideoCardGammaType): values = profile.tags.vcgt.getNormalizedValues() RGB = [] for i in range(3): RGB.append(int(round(values[-1][i] * 255))) ( self._window._colour.r, self._window._colour.g, self._window._colour.b, ) = RGB self._window._colour.ToHSV() wx.CallAfter(self._window.DrawAll) # Remember profile, but discard profile filename # (Important - can't re-install profile from same path # where it is installed!) if not self._set_profile_temp_filename(display_profile): return self._profiles[geometry] = display_profile self._install_profile(display_no, self._srgb_profile) def _install_profile(self, display_no, profile, wrapup=False): # Has to be thread-safe! if self._window.patterngenerator: return dispwin = get_argyll_util("dispwin") if not dispwin: _show_result_after(Error(lang.getstr("argyll.util.not_found", "dispwin"))) return if not profile.fileName or not os.path.isfile(profile.fileName): if not self._set_profile_temp_filename(profile): return profile.write() result = self._worker.exec_cmd( dispwin, ["-v", "-d%i" % (display_no + 1), "-I", profile.fileName], capture_output=True, dry_run=False, ) if not result: result = UnloggedError("".join(self._worker.errors)) if isinstance(result, Exception): _show_result_after(result, wrap=120) if wrapup: self._worker.wrapup(False) # Remove temporary profiles ProfileManager.managers.remove(self) def _install_profile_locked(self, display_no, profile, wrapup=False): # Has to be thread-safe! with self._lock: self._install_profile(display_no, profile, wrapup) def _set_profile_temp_filename(self, profile): temp = self._worker.create_tempdir() if isinstance(temp, Exception): _show_result_after(temp) return if profile.fileName: profile_name = os.path.basename(profile.fileName) else: profile_name = profile.getDescription() + profile_ext if ( sys.platform in ("win32", "darwin") or fs_enc.upper() not in ("UTF8", "UTF-8") ) and re.search(r"[^\x20-\x7e]", profile_name): profile_name = safe_asciize(profile_name) profile.fileName = os.path.join(temp, profile_name) return True def _stop_timer(self): if hasattr(self, "_update_timer") and self._update_timer.IsRunning(): self._update_timer.Stop() def update(self, restore_display_profiles=True): """Clear calibration on the current display, and restore it on the previous one (if any) """ if restore_display_profiles: self.restore_display_profiles() display_no = get_argyll_display_number(self._display.Geometry) if display_no is not None: geometry = self._display.Geometry.Get() threading.Thread( target=self._manage_display, name="VisualWhitepointEditor.DisplayManager[Display %d @ %d, %d, %dx%d]" % ((display_no,) + geometry), args=(display_no, geometry), ).start() if not self._window.patterngenerator: display_name = get_display_name(display_no, True) if display_name: display_name = display_name.replace( "[PRIMARY]", lang.getstr("display.primary") ) self._window.SetTitle( display_name + " ‒ " + lang.getstr("whitepoint.visual_editor") ) else: msg = lang.getstr("whitepoint.visual_editor.display_changed.warning") print(msg) def restore_display_profiles(self, wrapup=False, wait=False): """Reinstall memorized display profiles, restore calibration""" while self._profiles: geometry, profile = self._profiles.popitem() display_no = get_argyll_display_number(geometry) if display_no is not None: thread = threading.Thread( target=self._install_profile_locked, name="VisualWhitepointEditor.ProfileInstallation[Display %d @ %d, %d, %dx%d]" % ((display_no,) + geometry), args=(display_no, profile, wrapup), ) thread.start() if wait: thread.join() else: msg = lang.getstr("whitepoint.visual_editor.display_changed.warning") print(msg) def display_changed_handler(self, event): # Houston, we (may) have a problem! Memorized profile associations may # no longer be correct. def warn_update(): msg = lang.getstr("whitepoint.visual_editor.display_changed.warning") show_result_dialog(Warn(msg)) self and self.update() wx.CallLater(1000, warn_update) def window_close_handler(self, event): """Restores profile(s) when the managed window is closed.""" self._stop_timer() self.restore_display_profiles(True, True) event.Skip() def window_move_handler(self, event): """Clear calibration on the current display, and restore it on the previous one (if any) when the window is moved from one to another display. """ display = self._window.GetDisplay() if not self._display or display.Geometry != self._display.Geometry: self._display = display self._stop_timer() def update(): self._window and self.update() self._update_timer = wx.CallLater(50, update) event.Skip() class VisualWhitepointEditor(wx.Frame): """This is the VisualWhitepointEditor main class implementation.""" def __init__( self, parent, colourData=None, title=wx.EmptyString, pos=wx.DefaultPosition, patterngenerator=None, geometry=None, profile=None, ): """Default class constructor. :param colourData: a standard :class:`ColourData` (as used in :class:`ColourFrame`); to hide the alpha channel control or not. :param patterngenerator: a patterngenerator object :param geometry: the geometry of the display the profile is assigned to :param profile: the profile of the display with the given geometry """ self.patterngenerator = patterngenerator self.update_patterngenerator_event = threading.Event() style = wx.DEFAULT_FRAME_STYLE if patterngenerator: style &= ~(wx.RESIZE_BORDER | wx.MAXIMIZE_BOX) wx.Frame.__init__( self, parent, id=wx.ID_ANY, title=title or lang.getstr("whitepoint.visual_editor"), pos=pos, style=style, name="VisualWhitepointEditor", ) if not patterngenerator: self._mgr = AuiManager_LRDocking( self, aui.AUI_MGR_DEFAULT | aui.AUI_MGR_LIVE_RESIZE | aui.AUI_MGR_SMOOTH_DOCKING, ) self._mgr.SetArtProvider(AuiDarkDockArt()) self.SetIcons(get_icon_bundle([256, 48, 32, 16], appname)) if colourData: self._colourData = colourData else: self._colourData = wx.ColourData() RGB = [] for attribute in "rgb": RGB.append(getcfg("whitepoint.visual_editor." + attribute)) self._colourData.SetColour(wx.Colour(*RGB)) self._colour = Colour(self._colourData.GetColour()) self._bgcolour = Colour(self._colourData.GetColour()) self._bgcolour.v = getcfg("whitepoint.visual_editor.bg_v") self._bgcolour.ToRGB() self._inMouse = False self._initOver = False self._inDrawAll = False self.mainPanel = wx_Panel(self, -1) self.mainPanel.BackgroundColour = "#333333" self.mainPanel.ForegroundColour = "#999999" self.bgPanel = wx_Panel(self, -1) self.bgPanel.Show(not patterngenerator) self.hsvBitmap = HSVWheel(self.mainPanel, self.mainPanel.BackgroundColour) self.brightCtrl = BrightCtrl(self.mainPanel) self.brightCtrl.BackgroundColour = self.mainPanel.BackgroundColour self.bgBrightCtrl = BrightCtrl(self.mainPanel, self._bgcolour) self.bgBrightCtrl.BackgroundColour = self.mainPanel.BackgroundColour if sys.platform == "win32" and sys.getwindowsversion() >= (6,): # 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. self.mainPanel.SetDoubleBuffered(True) self.bgPanel.SetDoubleBuffered(True) self.newColourPanel = wx_Panel(self.bgPanel, style=wx.SIMPLE_BORDER) self.redSpin = NumSpin( self.mainPanel, -1, min=0, max=255, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.greenSpin = NumSpin( self.mainPanel, -1, min=0, max=255, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.blueSpin = NumSpin( self.mainPanel, -1, min=0, max=255, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.hueSpin = NumSpin( self.mainPanel, -1, min=0, max=359, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.saturationSpin = NumSpin( self.mainPanel, -1, min=0, max=255, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.brightnessSpin = NumSpin( self.mainPanel, -1, min=0, max=255, style=wx.NO_BORDER | wx.ALIGN_RIGHT ) self.reset_btn = FlatShadedButton( self.mainPanel, -1, label=lang.getstr("reset"), fgcolour="#999999" ) x, y, scale = ( float(v) for v in getcfg("dimensions.measureframe.whitepoint.visual_editor").split( "," ) ) self.area_size_slider = HSlider( self.mainPanel, min(scale * 100, 1000), 10, 1000, self.area_handler ) self.display_size_mm = {} self.set_area_size_slider_max() self.set_default_size() self.area_size_slider.BackgroundColour = self.mainPanel.BackgroundColour if "gtk3" in wx.PlatformInfo: size = (16, 16) else: size = (-1, -1) self.zoomnormalbutton = BitmapButton( self.mainPanel, -1, geticon(16, "zoom-original-outline"), size=size, style=wx.NO_BORDER, ) self.zoomnormalbutton.BackgroundColour = self.mainPanel.BackgroundColour self.Bind(wx.EVT_BUTTON, self.zoomnormal_handler, self.zoomnormalbutton) self.zoomnormalbutton.SetToolTipString(lang.getstr("measureframe.zoomnormal")) self.area_x_slider = HSlider( self.mainPanel, int(round(x * 1000)), 0, 1000, self.area_handler ) self.area_x_slider.BackgroundColour = self.mainPanel.BackgroundColour self.center_x_button = BitmapButton( self.mainPanel, -1, geticon(16, "window-center-outline"), size=size, style=wx.NO_BORDER, ) self.center_x_button.BackgroundColour = self.mainPanel.BackgroundColour self.Bind(wx.EVT_BUTTON, self.center_x_handler, self.center_x_button) self.center_x_button.SetToolTipString(lang.getstr("measureframe.center")) self.area_y_slider = HSlider( self.mainPanel, int(round(y * 1000)), 0, 1000, self.area_handler ) self.area_y_slider.BackgroundColour = self.mainPanel.BackgroundColour self.center_y_button = BitmapButton( self.mainPanel, -1, geticon(16, "window-center-outline"), size=size, style=wx.NO_BORDER, ) self.center_y_button.BackgroundColour = self.mainPanel.BackgroundColour self.Bind(wx.EVT_BUTTON, self.center_y_handler, self.center_y_button) self.center_y_button.SetToolTipString(lang.getstr("measureframe.center")) self.measure_btn = FlatShadedButton( self.mainPanel, -1, label=lang.getstr("measure"), name="visual_whitepoint_editor_measure_btn", fgcolour="#999999", ) self.measure_btn.SetDefault() self.Bind(wx.EVT_SIZE, self.size_handler) self.SetProperties() self.DoLayout() self.spinCtrls = [ self.redSpin, self.greenSpin, self.blueSpin, self.hueSpin, self.saturationSpin, self.brightnessSpin, ] for spin in self.spinCtrls: spin.Bind(wx.EVT_TEXT, self.OnSpinCtrl) self.reset_btn.Bind(wx.EVT_BUTTON, self.reset_handler) self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) self.Bind(wx.EVT_SHOW, self.show_handler) self.Bind(wx.EVT_MAXIMIZE, self.maximize_handler) self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyDown) # Set up panes self.mainPanel.Fit() mainPanelSize = (self.mainPanel.Size[0], self.mainPanel.Size[1] + s(10)) if not patterngenerator: self._mgr.AddPane( self.mainPanel, aui.AuiPaneInfo() .Name("mainPanel") .Fixed() .Left() .TopDockable(False) .BottomDockable(False) .PaneBorder(False) .CloseButton(False) .PinButton(True) .MinSize(mainPanelSize), ) self._mgr.AddPane( self.bgPanel, aui.AuiPaneInfo() .Name("bgPanel") .CenterPane() .CloseButton(False) .PaneBorder(False), ) self._mgr.Update() self.Bind(aui.EVT_AUI_PANE_CLOSE, self.close_pane_handler) self.Bind(aui.EVT_AUI_PANE_FLOATED, self.float_pane_handler) self.Bind(aui.EVT_AUI_PANE_DOCKED, self.float_pane_handler) # Account for pane titlebar self.Sizer.SetSizeHints(self) self.Sizer.Layout() if not patterngenerator: if hasattr(self, "MinClientSize"): # wxPython 2.9+ minClientSize = self.MinClientSize else: minClientSize = self.WindowToClientSize(self.MinSize) w, h = self.newColourPanel.Size self.ClientSize = ( mainPanelSize[0] + w + s(26), max(minClientSize[1], h + s(26)), ) if sys.platform not in ("win32", "darwin"): correction = s(40) else: correction = 0 w, h = (int(round(self.default_size)),) * 2 minClientSize = ( mainPanelSize[0] + max(minClientSize[1], w + s(26)), max(minClientSize[1], h + s(26)) + correction, ) if hasattr(self, "MinClientSize"): # wxPython 2.9+ self.MinClientSize = minClientSize else: self.MinSize = self.ClientToWindowSize(minClientSize) x, y = self.Position w, h = self.Size if not patterngenerator and ( self.newColourPanel.Size[0] > min( self.bgPanel.Size[0], self.GetDisplay().ClientArea[2] - mainPanelSize[0] ) or self.newColourPanel.Size[1] > min(self.bgPanel.Size[1], self.GetDisplay().ClientArea[3]) ): w, h = self.GetDisplay().ClientArea[2:] self.SetSaneGeometry(x, y, w, h) if patterngenerator: self.update_patterngenerator_thread = threading.Thread( target=update_patterngenerator, name="VisualWhitepointEditorPatternGeneratorUpdateThread", args=(self,), ) self.update_patterngenerator_thread.start() self._pm = ProfileManager(self, geometry, profile) self.Bind(wx.EVT_MOVE, self.move_handler) wx.CallAfter(self.InitFrame) self.keepGoing = True self.measure_btn.Bind(wx.EVT_BUTTON, self.measure) def SetProperties(self): """Sets some initial properties for :class:`VisualWhitepointEditor` (sizes, values).""" min_w = self.redSpin.numctrl.GetTextExtent("255")[0] + s(30) self.redSpin.SetMinSize((min_w, -1)) self.greenSpin.SetMinSize((min_w, -1)) self.blueSpin.SetMinSize((min_w, -1)) self.hueSpin.SetMinSize((min_w, -1)) self.saturationSpin.SetMinSize((min_w, -1)) self.brightnessSpin.SetMinSize((min_w, -1)) def DoLayout(self): """Layouts all the controls in the :class:`VisualWhitepointEditor`.""" margin = s(12) dialogSizer = wx.FlexGridSizer(1, 2, 0, 0) dialogSizer.AddGrowableRow(0) dialogSizer.AddGrowableCol(1) mainSizer = wx.BoxSizer(wx.VERTICAL) shadow = HStretchStaticBitmap( self.mainPanel, -1, getbitmap("theme/shadow-bordertop") ) mainSizer.Add(shadow, 0, wx.EXPAND) label = wx.StaticText(self.mainPanel, -1, lang.getstr("whitepoint")) label.SetMaxFontSize(11) font = label.Font font.SetWeight(wx.BOLD) label.Font = font mainSizer.Add(label, 0, wx.LEFT, margin) hsvGridSizer = wx.GridSizer(2, 3, margin, margin) hsvSizer = wx.BoxSizer(wx.HORIZONTAL) hsvSizer.Add(self.hsvBitmap, 0, wx.ALL, margin) hsvSizer.Add(self.brightCtrl, 0, wx.TOP | wx.BOTTOM, margin + s(5) + 2) hsvSizer.Add((margin + s(5), 1)) hsvSizer.Add(self.bgBrightCtrl, 0, wx.TOP | wx.BOTTOM, margin + s(5) + 2) hsvSizer.Add((margin + s(5), 1)) mainSizer.Add(hsvSizer, 0, wx.LEFT | wx.RIGHT | wx.ALIGN_CENTER, margin) for channel in ("red", "green", "blue", "hue", "saturation", "brightness"): label = wx.StaticText(self.mainPanel, -1, lang.getstr(channel)) label.SetMaxFontSize(11) sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(label) sizer.Add(getattr(self, channel + "Spin"), 0, wx.TOP | wx.EXPAND, s(4)) hsvGridSizer.Add(sizer, 0, wx.EXPAND) mainSizer.Add(hsvGridSizer, 0, wx.LEFT | wx.RIGHT | wx.ALIGN_CENTER, margin) mainSizer.Add(self.reset_btn, 0, wx.ALL | wx.ALIGN_CENTER, margin) shadow = HStretchStaticBitmap( self.mainPanel, -1, getbitmap("theme/shadow-bordertop") ) mainSizer.Add(shadow, 0, wx.EXPAND, margin) area_slider_label = wx.StaticText( self.mainPanel, -1, lang.getstr("measureframe.title") ) area_slider_label.SetMaxFontSize(11) font = area_slider_label.Font font.SetWeight(wx.BOLD) area_slider_label.Font = font mainSizer.Add(area_slider_label, 0, wx.LEFT | wx.BOTTOM, margin) if "gtk3" in wx.PlatformInfo: vmargin = margin else: vmargin = s(6) slider_sizer = wx.FlexGridSizer(3, 3, vmargin, margin) slider_sizer.AddGrowableCol(1) mainSizer.Add(slider_sizer, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, margin) area_size_label = wx.StaticText(self.mainPanel, -1, lang.getstr("size")) area_size_label.SetMaxFontSize(11) slider_sizer.Add(area_size_label, 0, wx.ALIGN_CENTER_VERTICAL) slider_sizer.Add(self.area_size_slider, 0, wx.ALIGN_CENTER_VERTICAL | wx.EXPAND) slider_sizer.Add(self.zoomnormalbutton, 0, wx.ALIGN_CENTER_VERTICAL) area_x_label = wx.StaticText(self.mainPanel, -1, "X") area_x_label.SetMaxFontSize(11) slider_sizer.Add(area_x_label, 0, wx.ALIGN_CENTER_VERTICAL) slider_sizer.Add(self.area_x_slider, 0, wx.ALIGN_CENTER_VERTICAL | wx.EXPAND) slider_sizer.Add(self.center_x_button, 0, wx.ALIGN_CENTER_VERTICAL) area_y_label = wx.StaticText(self.mainPanel, -1, "Y") area_y_label.SetMaxFontSize(11) slider_sizer.Add(area_y_label, 0, wx.ALIGN_CENTER_VERTICAL) slider_sizer.Add(self.area_y_slider, 0, wx.ALIGN_CENTER_VERTICAL | wx.EXPAND) slider_sizer.Add(self.center_y_button, 0, wx.ALIGN_CENTER_VERTICAL) mainSizer.Add(self.measure_btn, 0, wx.ALL | wx.ALIGN_CENTER, margin) self.mainPanel.SetAutoLayout(True) self.mainPanel.SetSizer(mainSizer) mainSizer.Fit(self.mainPanel) mainSizer.SetSizeHints(self.mainPanel) dialogSizer.Add(self.mainPanel, 0, wx.EXPAND) if self.bgPanel.IsShown(): dialogSizer.Add(self.bgPanel, 1, wx.EXPAND, 0) self.SetAutoLayout(True) self.SetSizer(dialogSizer) dialogSizer.Fit(self) dialogSizer.SetSizeHints(self) self.Layout() self.mainSizer = mainSizer self.dialogSizer = dialogSizer def InitFrame(self): """Initialize the :class:`VisualWhitepointEditor`.""" hsvRect = self.hsvBitmap.GetClientRect() self._centre = wx.Point( int(hsvRect.x + hsvRect.width / 2), int(hsvRect.y + hsvRect.height / 2) ) self.CalcRects() self.SetSpinVals() self._initOver = True wx.CallAfter(self.Refresh) def show_handler(self, event): if ( not self.patterngenerator and getattr(event, "IsShown", getattr(event, "GetShow", bool))() and sys.platform == "darwin" and intlist(mac_ver()[0].split(".")) >= [10, 10] ): # Under Yosemite and up, if users use the default titlebar zoom # button to go fullscreen, they will be left with a black screen # after the window has been closed (shortcoming of wxMac). # It is possible to switch back to normal view by alt-tabbing, # but users need to be made aware of it. wx.CallAfter( self.notify, wrap(lang.getstr("fullscreen.osx.warning"), 80), icon=geticon(32, "dialog-warning"), timeout=0, ) event.Skip() def CalcRects(self): """Calculates the brightness control user-selected rect.""" RECT_WIDTH = s(5) pt = self.PtFromAngle(self._colour.h, self._colour.s, self._centre) self._currentRect = wx.Rect( pt.x - RECT_WIDTH, pt.y - RECT_WIDTH, 2 * RECT_WIDTH, 2 * RECT_WIDTH ) def DrawMarkers(self, dc=None): """Draws the markers for all the controls. :param dc: an instance of :class:`DC`. If `dc` is ``None``, a :class:`ClientDC` is created on the fly. """ self.hsvBitmap.DrawMarkers(dc) self.brightCtrl.DrawMarkers(dc) self.bgBrightCtrl.DrawMarkers(dc) def DrawHSB(self): """Refreshes the HSB colour wheel.""" self.hsvBitmap.Refresh() def DrawBright(self): """Refreshes the brightness control.""" self.brightCtrl.Refresh() self.bgBrightCtrl.Refresh() def SetSpinVals(self): """Sets the values for all the spin controls.""" self.redSpin.SetValue(self._colour.r) self.greenSpin.SetValue(self._colour.g) self.blueSpin.SetValue(self._colour.b) self.hueSpin.SetValue(self._colour.h) self.saturationSpin.SetValue(self._colour.s) self.brightnessSpin.SetValue(self._colour.v) self.SetPanelColours() self.update_patterngenerator() def update_patterngenerator(self): if self.patterngenerator: size = min( ( self.area_size_slider.GetValue() / float( self.area_size_slider.GetMax() - self.area_size_slider.GetMin() ) ), 1, ) x = max( self.area_x_slider.GetValue() / float(self.area_x_slider.GetMax()) * (1 - size), 0, ) y = max( self.area_y_slider.GetValue() / float(self.area_y_slider.GetMax()) * (1 - size), 0, ) self.patterngenerator_config = x, y, size self.update_patterngenerator_event.set() def SetPanelColours(self): """Assigns colours to the colour panels.""" self.newColourPanel.BackgroundColour = self._colour.GetPyColour() self._bgcolour.h = self._colour.h self._bgcolour.s = self._colour.s self._bgcolour.ToRGB() self.bgPanel.BackgroundColour = self._bgcolour.GetPyColour() self.bgPanel.Refresh() def OnCloseWindow(self, event): """Handles the ``wx.EVT_CLOSE`` event for :class:`VisualWhitepointEditor`. :param event: a :class:`CloseEvent` event to be processed. """ if self.IsFullScreen(): self.ShowFullScreen(False) event.Skip() def OnKeyDown(self, event): """Handles the ``wx.EVT_CHAR_HOOK`` event for :class:`VisualWhitepointEditor`. :param event: a :class:`KeyEvent` event to be processed. """ if event.GetKeyCode() == wx.WXK_ESCAPE: if self.IsFullScreen(): self.ShowFullScreen(False) self.Restore() else: self.Close() # elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_RIGHT, wx.WXK_UP, # wx.WXK_DOWN): # self._colour.h += {wx.WXK_LEFT: 1, # wx.WXK_RIGHT: -1, # wx.WXK_UP: 0, # wx.WXK_DOWN: 0}[event.KeyCode] # if self._colour.h > 359: # self._colour.h = 0 # elif self._colour.h < 0: # self._colour.h = 359 # self._colour.s += {wx.WXK_LEFT: 0, # wx.WXK_RIGHT: 0, # wx.WXK_UP: 1, # wx.WXK_DOWN: -1}[event.KeyCode] # if self._colour.s > 255: # self._colour.s = 255 # elif self._colour.s < 0: # self._colour.s = 0 # print self._colour.h, self._colour.s # self._colour.ToRGB() # self.DrawAll() else: event.Skip() def PtFromAngle(self, angle, sat, center): """Given the angle with respect to the x-axis, returns the point based on the saturation value. :param angle: a float representing an angle; :param sat: a float representing the colour saturation value; :param center: a float value representing the center. """ angle = deg2rad(angle) sat = min( sat * ((self.hsvBitmap._bitmap.Size[0] - s(12)) / 2) / 51.0, ((self.hsvBitmap._bitmap.Size[0] - s(12)) / 2), ) x = sat * cos(angle) y = sat * sin(angle) pt = wx.Point(int(round(x)), -int(round(y))) pt.x += center.x pt.y += center.y return pt def OnSpinCtrl(self, event): """Handles the ``wx.EVT_SPINCTRL`` event for RGB and HSB colours. :param event: a :class:`SpinEvent` event to be processed. """ obj = event.GetEventObject().Parent position = self.spinCtrls.index(obj) colourVal = event.GetString() try: colourVal = int(colourVal) except Exception: wx.Bell() return attribute, maxVal = colourAttributes[position], colourMaxValues[position] self.AssignColourValue(attribute, colourVal, maxVal, position) def AssignColourValue(self, attribute, colourVal, maxVal, position): """Common code to handle spin control changes.""" originalVal = getattr(self._colour, attribute) if colourVal != originalVal and self._initOver: if colourVal < 0: colourVal = 0 if colourVal > maxVal: colourVal = maxVal setattr(self._colour, attribute, colourVal) if position < 3: self._colour.ToHSV() else: self._colour.ToRGB() self.DrawAll() def DrawAll(self): """Draws all the custom controls after a colour change.""" if self._initOver and not self._inDrawAll: self._inDrawAll = True self.hsvBitmap.DrawMarkers() self.brightCtrl.DrawMarkers() self.CalcRects() self.DrawHSB() self.DrawBright() self.SetSpinVals() self._inDrawAll = False def GetColourData(self): """Returns a wxPython compatible :class:`ColourData`.""" self._colourData.SetColour(self._colour.GetPyColour()) return self._colourData def GetRGBAColour(self): """Returns a 4-elements tuple of red, green, blue, alpha components.""" return (self._colour.r, self._colour.g, self._colour.b, self._colour._alpha) def GetHSVAColour(self): """Returns a 4-elements tuple of hue, saturation, brightness, alpha components.""" return (self._colour.h, self._colour.s, self._colour.v, self._colour._alpha) def EndModal(self, returncode=wx.ID_OK): return returncode def MakeModal(self, makemodal=False): pass def Pulse(self, msg=""): return self.keepGoing, False def Resume(self): self.keepGoing = True def UpdateProgress(self, value=None, msg=""): return self.Pulse(msg) def UpdatePulse(self, msg=""): return self.Pulse(msg) def area_handler(self, event=None): scale = self.area_size_slider.Value / 100.0 x = self.area_x_slider.Value / 1000.0 y = self.area_y_slider.Value / 1000.0 w, h = (int(round(self.default_size * scale)),) * 2 self.bgPanel.MinSize = -1, -1 self.newColourPanel.Size = w, h self.bgPanel.MinSize = w + s(24), h + s(24) bg_w, bg_h = (float(v) for v in self.bgPanel.Size) self.newColourPanel.Position = (int((bg_w - (w)) * x)), int(((bg_h - (h)) * y)) if event: event.Skip() if event and event.GetEventType() == wx.EVT_SIZE.evtType[0]: wx.CallAfter(self.area_handler) else: self.bgPanel.Refresh() self.update_patterngenerator() def center_x_handler(self, event): self.area_x_slider.SetValue(500) self.area_handler() def center_y_handler(self, event): self.area_y_slider.SetValue(500) self.area_handler() def close_pane_handler(self, event): event.Veto() # Prevent closing of pane self.dock_pane() def dock_pane(self): self._mgr.GetPane("mainPanel").Dock().CloseButton(False) self._mgr.Update() self.mainPanel.Refresh() self.area_handler() def float_pane_handler(self, event): if event.GetEventType() == aui.EVT_AUI_PANE_FLOATED.evtType[0]: pos = [ self.Position[i] + (self.Size[i] - self.ClientSize[i]) / {0: 2, 1: 1}[i] + s(10) for i in (0, 1) ] pos[0] += self.mainPanel.Position[0] pos[1] -= (self.Size[0] - self.ClientSize[0]) / 2 self._mgr.GetPane("mainPanel").FloatingPosition(pos).CloseButton(True) wx.CallAfter(self.area_handler) else: wx.CallAfter(self.dock_pane) def flush(self): pass def maximize_handler(self, event): """Handles maximize and fullscreen events""" # print '_isfullscreen?', getattr(self, "_isfullscreen", False) if not getattr(self, "_isfullscreen", False): self._isfullscreen = True # print 'Setting fullscreen...' self.ShowFullScreen(True) # print '...done setting fullscreen.' wx.CallAfter(self.notify, lang.getstr("fullscreen.message")) def move_handler(self, event): event.Skip() display = self.GetDisplay() if not self._pm._display or display.Geometry != self._pm._display.Geometry: self.set_area_size_slider_max() self.set_default_size() self.area_handler() def measure(self, event): if ( not self.Parent or not hasattr(self.Parent, "ambient_measure_handler") or not self.Parent.worker.displays or not self.Parent.worker.instruments ): wx.Bell() return self.measure_btn.Disable() self.setcfg() self.Parent.ambient_measure_handler(event) def notify(self, msg, title=None, icon=None, timeout=-1): # Notification needs to have this frame as toplevel parent so key events # bubble to parent # print 'Showing fullscreen notification' if getattr(self, "notification", None): self.notification.fade("out") self.notification = TaskBarNotification( icon or geticon(32, "dialog-information"), title or self.Title, msg, self.bgPanel, (-1, s(32)), timeout, ) self.notification.Center(wx.HORIZONTAL) def size_handler(self, event): if getattr(self, "_isfullscreen", False): if getattr(self, "notification", None): # print 'Fading out notification' self.notification.fade("out") wx.CallAfter(self._check_fullscreen) self.area_handler(event) def _check_fullscreen(self): # print '_isfullscreen?', getattr(self, "_isfullscreen", False) if getattr(self, "_isfullscreen", False): self._isfullscreen = self.IsFullScreen() # print 'IsFullScreen()?', self._isfullscreen def start_timer(self, ms=50): pass def stop_timer(self): pass def reset_handler(self, event): RGB = [] for attribute in "rgb": RGB.append(defaults["whitepoint.visual_editor." + attribute]) self._colourData.SetColour(wx.Colour(*RGB)) self._colour.r, self._colour.g, self._colour.b = self._colourData.GetColour()[ :3 ] self._colour.ToHSV() self._bgcolour.v = defaults["whitepoint.visual_editor.bg_v"] self.DrawAll() def set_area_size_slider_max(self): # Set max value according to display size maxv = 1000 if RDSMM: geometry = self.GetDisplay().Geometry.Get() display_no = get_argyll_display_number(geometry) if display_no is not None: size_mm = RDSMM.RealDisplaySizeMM(display_no) if 0 not in size_mm: self.display_size_mm[geometry] = [float(v) for v in size_mm] maxv = int(round(max(size_mm) / 100.0 * 100)) if maxv > 100: self.area_size_slider.SetMax(maxv) if self.area_size_slider.GetValue() > self.area_size_slider.GetMax(): self.area_size_slider.SetValue(maxv) def set_default_size(self): geometry = self.GetDisplay().Geometry.Get() size_mm = self.display_size_mm.get(geometry) if size_mm: px_per_mm = max(geometry[2] / size_mm[0], geometry[3] / size_mm[1]) self.default_size = px_per_mm * 100 else: self.default_size = 300 def setcfg(self): for attribute in "rgb": value = getattr(self._colour, attribute) setcfg("whitepoint.visual_editor." + attribute, value) setcfg("whitepoint.visual_editor.bg_v", self._bgcolour.v) x, y = ( ctrl.Value / 1000.0 for ctrl in (self.area_x_slider, self.area_y_slider) ) scale = self.area_size_slider.Value / 100.0 setcfg( "dimensions.measureframe.whitepoint.visual_editor", "%f,%f,%f" % (x, y, scale), ) def write(self, txt): pass def zoomnormal_handler(self, event): scale = float( defaults["dimensions.measureframe.whitepoint.visual_editor"].split(",")[2] ) self.area_size_slider.SetValue(int(round(scale * 100))) self.area_handler() if __name__ == "__main__": from DisplayCAL.wxwindows import BaseApp initcfg() lang.init() app = BaseApp(0) worker = Worker() worker.enumerate_displays_and_ports(check_lut_access=False, enumerate_ports=False) app.TopWindow = VisualWhitepointEditor(None) app.TopWindow.Show() app.MainLoop()