if not _sharedConfs.has_key(confFile):
conf = ConfigParser()
conf.read(confFile)
conf.confFile = confFile
_sharedConfs[confFile] = conf
return _sharedConfs[confFile]
def writeConfig(conf):
conf.write(open(conf.confFile, 'w'))
import wx.html
wxEVT_HTML_URL_CLICK = wx.NewId()
EVT_HTML_URL_CLICK = wx.PyEventBinder(wxEVT_HTML_URL_CLICK)
class wxHtmlWindowUrlClick(wx.PyEvent):
def __init__(self, linkinfo):
wx.PyEvent.__init__(self)
self.SetEventType(wxEVT_HTML_URL_CLICK)
self.linkinfo = (linkinfo.GetHref(), linkinfo.GetTarget())
class wxUrlClickHtmlWindow(wx.html.HtmlWindow):
""" HTML window that generates and OnLinkClicked event.
Use this to avoid having to override HTMLWindow
"""
def OnLinkClicked(self, linkinfo):
wx.PostEvent(self, wxHtmlWindowUrlClick(linkinfo))
"z3EtAGDtnf65cn7NDs0JQwIcDWJ0oZApFrIgNAMCI9/I+L/Ht0KVSjbD3xsj110nuhYb9cbz"
"nnl8W5JsZCt6vP4BQCYNciTwQXKs95b/jwCoEbDOghqr3dt7r13riA4OPD/K7mFGj4yOUZHj"
"Uc8pj9fOvvHlL3+ZHj58SP/yi5/v5svlkv7yl7/QRx99tAc4y+XykUDpLWZm0SsbkFmAStCN"
"+HgG3VLhozbU3pLELYqA0iGATva6Nf8Kn8patACXnj4ZkJMF7xLgyJMc69srzAMl4eyJiDe3"
"EUnFoyrYyYDfSM6h5yRlVJIlX4vGegBIt3uAB1HWTtGD++kTHQS6szHfSu6H3MMIwCIdDuFP"
"Uo/oA8feay2/FzzyfvfmFO/wBPXzZMo4OZlM6Otf/zo9fPiQXnzxRZr/9re/pbfeeotOT0/3"
"t6ZQgOw5ZqouRuviRcgSnSSMoh4QMFoXKW8k79ZA0xOQRgezx5HgKoTW00pk1a/k3gSxjXjJ"
"YXRw/LRQa2LLjIv8rgXY9xJK8jrRZm3007qnEd1EPDnkej5OMCmpchoeEcfP9XpNRET/Ax6j"
"kIck2UJrAAAAAElFTkSuQmCC")
# ----------------------------------------------------------------------------
# ZoomBar events and binding for handling them
# ----------------------------------------------------------------------------
wxEVT_ZOOMBAR = wx.NewEventType()
EVT_ZOOMBAR = wx.PyEventBinder(wxEVT_ZOOMBAR, 1)
""" Process a `wxEVT_ZOOMBAR` event, when a :class:`ZoomBar` button is clicked. """
# ----------------------------------------------------------------------------
def MakeDisabledBitmap(original):
"""
Creates a disabled-looking bitmap starting from the input one.
:param `original`: an instance of :class:`wx.Bitmap` to be greyed-out.
"""
img = original.ConvertToImage()
return wx.Bitmap(img.ConvertToGreyscale())
#
# this module is used for custom event
#
import wx
# ------------------------------------- #
# Custom EventType
# ------------------------------------- #
wxNotifyEvent = wx.NewEventType()
# ------------------------------------- #
# Custom Python Event Binder
# ------------------------------------- #
EVT_NOTIFY_EVENT = wx.PyEventBinder(wxNotifyEvent,1)
#
# ------------------------------------- #
# Class NotifyEvent
# ------------------------------------- #
class NotifyEvent(wx.PyCommandEvent):
'''
custom notify event
data: save some private info
'''
def __init__(self, evtType, id = -1):
wx.PyCommandEvent.__init__(self,evtType,id)
self.data = None
#self._eventType = evtType
def SetData(self,data=None):
def getListCtrlSelection(listctrl, state=wx.LIST_STATE_SELECTED):
""" Returns list of item indexes of given state (selected by defaults) """
res = []
idx = -1
while 1:
idx = listctrl.GetNextItem(idx, wx.LIST_NEXT_ALL, state)
if idx == -1:
break
res.append(idx)
return res
wxEVT_DOPOPUPMENU = wx.NewEventType()
EVT_DOPOPUPMENU = wx.PyEventBinder(wxEVT_DOPOPUPMENU, 0)
class ListCtrlSelectionManagerMix:
"""Mixin that defines a platform independent selection policy
As selection single and multi-select list return the item index or a
list of item indexes respectively.
"""
_menu = None
def __init__(self):
self.Bind(wx.EVT_RIGHT_DOWN, self.OnLCSMRightDown)
self.Bind(EVT_DOPOPUPMENU, self.OnLCSMDoPopup)
# self.Connect(-1, -1, self.wxEVT_DOPOPUPMENU, self.OnLCSMDoPopup)
CTRLBAR_NAME_STR = u'EditraControlBar'
CTRLBOX_NAME_STR = u'EditraControlBox'
#-- Control Style Flags --#
# ControlBar
CTRLBAR_STYLE_DEFAULT = 0
CTRLBAR_STYLE_GRADIENT = 1 # Paint the bar with a gradient
CTRLBAR_STYLE_BORDER_BOTTOM = 2 # Add a border to the bottom
CTRLBAR_STYLE_BORDER_TOP = 4 # Add a border to the top
#CTRLBAR_STYLE_FOLDABLE = 2 # Add a fold button to the bar.
# ControlBar event for items added by AddTool
edEVT_CTRLBAR = wx.NewEventType()
EVT_CTRLBAR = wx.PyEventBinder(edEVT_CTRLBAR, 1)
class ControlBarEvent(wx.PyCommandEvent):
"""ControlBar Button Event"""
#--------------------------------------------------------------------------#
class ControlBox(wx.PyPanel):
"""Simple managed panel helper class that allows for adding and
managing the position of a small toolbar like panel.
@see: L{ControlBar}
"""
def __init__(self, parent, id=wx.ID_ANY,
pos=wx.DefaultPosition, size=wx.DefaultSize,
style=wx.TAB_TRAVERSAL|wx.NO_BORDER,
name=CTRLBOX_NAME_STR):
import wx
from control import RibbonControl
from art import *
wxEVT_COMMAND_RIBBONGALLERY_HOVER_CHANGED = wx.NewEventType()
wxEVT_COMMAND_RIBBONGALLERY_SELECTED = wx.NewEventType()
EVT_RIBBONGALLERY_HOVER_CHANGED = wx.PyEventBinder(
wxEVT_COMMAND_RIBBONGALLERY_HOVER_CHANGED, 1)
EVT_RIBBONGALLERY_SELECTED = wx.PyEventBinder(
wxEVT_COMMAND_RIBBONGALLERY_SELECTED, 1)
class RibbonGalleryEvent(wx.PyCommandEvent):
def __init__(self, command_type=None, win_id=0, gallery=None, item=None):
wx.PyCommandEvent.__init__(self, command_type, win_id)
self._gallery = gallery
self._item = item
def Clone(self):
return RibbonGalleryEvent(self)
def GetGallery(self):
return self._gallery
def GetGalleryItem(self):
# Set no delay time to open the web page
webbrowser.PROCESS_CREATION_DELAY = 0
# To show a popup that copies the hyperlinks on the clipboard
wxHYPERLINKS_POPUP_COPY = 1000
""" Flag used to show a popup that copies the hyperlinks on the clipboard. """
# wxEVT_HYPERLINK_LEFT: Respond To A Left Mouse Button Event
# wxEVT_HYPERLINK_MIDDLE: Respond To A Middle Mouse Button Event
# wxEVT_HYPERLINK_RIGHT: Respond To A Right Mouse Button Event
wxEVT_HYPERLINK_LEFT = wx.NewEventType()
wxEVT_HYPERLINK_MIDDLE = wx.NewEventType()
wxEVT_HYPERLINK_RIGHT = wx.NewEventType()
EVT_HYPERLINK_LEFT = wx.PyEventBinder(wxEVT_HYPERLINK_LEFT, 1)
""" Responds to a left mouse button event. Sent when the left mouse button is
clicked, but only if `AutoBrowse` is set to ``False``. """
EVT_HYPERLINK_MIDDLE = wx.PyEventBinder(wxEVT_HYPERLINK_MIDDLE, 1)
""" Responds to a middle mouse button event. Sent when the middle mouse button is clicked. """
EVT_HYPERLINK_RIGHT = wx.PyEventBinder(wxEVT_HYPERLINK_RIGHT, 1)
""" Handles a right mouse button event. Sent when the right mouse button is
clicked, but only if `DoPopup` is set to ``False``. """
# ------------------------------------------------------------
# This class implements the event listener for the hyperlinks
# ------------------------------------------------------------
class HyperLinkEvent(wx.CommandEvent):
"""
return False
# Command to feed pexpect
#self.command = ' '.join([
# 'echo "' + self.pw + '" | ',
# 'sudo openconnect',
# '--protocol="' + self.prot + '"',
# '--user="******"',
# '--passwd-on-stdin',
# self.host
# ])
# Initialise pexpect
self.command = 'cmd.exe /C "for /L %i in (1,1,20) do @echo Log entry %i && @timeout /t 2 > nul"'
# Custom logging event
myCustomLogEvent = wx.NewEventType()
customLogEvent = wx.PyEventBinder(myCustomLogEvent, 1)
class logEvent(wx.PyCommandEvent):
'''Event to signal that log entries are ready'''
def __init__(self, etype, eid, value=None):
'''Creates the event object'''
wx.PyCommandEvent.__init__(self, etype, eid)
self._value = value
def getValue(self):
'''Returns the value from the event'''
return self._value
class vpnThread(threading.Thread):
def __init__(self, parent, params):
'''
@param parent: The gui object that should receive logs
return self.model
def SetModel(self, model):
self.model = model
def SetDescription(self, desc):
'''
Set a string that describes the event that has occurred
'''
self.description = desc
# Generating an event type:
myEVT_NEW_MODEL = wx.NewEventType()
# Creating an event binder object
EVT_NEW_MODEL = wx.PyEventBinder(myEVT_NEW_MODEL)
def _post_new_model_event(parent, model, desc=''):
# Send an event that a new data set has been loaded
evt = GenericModelEvent(myEVT_NEW_MODEL, parent.GetId(), model)
evt.SetDescription(desc)
# Process the event!
parent.GetEventHandler().ProcessEvent(evt)
# Generating an event type:
myEVT_SIM_PLOT = wx.NewEventType()
# Creating an event binder object
EVT_SIM_PLOT = wx.PyEventBinder(myEVT_SIM_PLOT)
IEC_BTN_1, IEC_BTN_2, IEC_BTN_3, IEC_BTN_4, IEC_BTN_9,
IEC_BTN_10, IEC_BTN_11, IEC_BTN_12, IEC_BTN_13,
IEC_BTN_14)[code - IEC_BTN_0], val)
return event
# ------------------------------------------------------------------------
# new wxPython event classes
# ------------------------------------------------------------------------
grEVT_POWERMATE_BUTTON = wx.NewEventType()
grEVT_POWERMATE_ROTATE = wx.NewEventType()
grEVT_POWERMATE_SHUTTLE = wx.NewEventType()
EVT_POWERMATE_BUTTON = wx.PyEventBinder(grEVT_POWERMATE_BUTTON, 0)
EVT_POWERMATE_ROTATE = wx.PyEventBinder(grEVT_POWERMATE_ROTATE, 0)
EVT_POWERMATE_SHUTTLE = wx.PyEventBinder(grEVT_POWERMATE_SHUTTLE, 0)
class PMButtonEvent(wx.PyEvent):
def __init__(self, button, value):
wx.PyEvent.__init__(self)
self.SetEventType(grEVT_POWERMATE_BUTTON)
self.button = button
self.value = value
def Clone(self):
self.__class__(self.GetId())
# All Styles
OPB_ALL_STYLES = (wx.stc.STC_STYLE_DEFAULT, wx.stc.STC_STYLE_CONTROLCHAR,
OPB_STYLE_DEFAULT, OPB_STYLE_ERROR, OPB_STYLE_INFO,
OPB_STYLE_WARN)
# Error Codes
OPB_ERROR_NONE = 0
OPB_ERROR_INVALID_COMMAND = -1
#--------------------------------------------------------------------------#
# Event for notifying that the process has started running
# GetValue will return the command line string that started the process
edEVT_PROCESS_START = wx.NewEventType()
EVT_PROCESS_START = wx.PyEventBinder(edEVT_PROCESS_START, 1)
# Event for notifying that a task is starting to run
edEVT_TASK_START = wx.NewEventType()
EVT_TASK_START = wx.PyEventBinder(edEVT_TASK_START, 1)
# Event for passing output data to buffer
# GetValue returns the output text retrieved from the process
edEVT_UPDATE_TEXT = wx.NewEventType()
EVT_UPDATE_TEXT = wx.PyEventBinder(edEVT_UPDATE_TEXT, 1)
# Event for notifying that the the process has finished and no more update
# events will be sent. GetValue will return the processes exit code
edEVT_PROCESS_EXIT = wx.NewEventType()
EVT_PROCESS_EXIT = wx.PyEventBinder(edEVT_PROCESS_EXIT, 1)
This module contains a widget class and supporting classes for a generic HTML
renderer. It supports only a subset of the HTML standards, and no Javascript
or CSS, but it is relatively lightweight and has no platform dependencies. It
is suitable for displaying simple HTML documents, such as the application's
documentation or built-in help pages.
.. note:: Due to some internal dynamic initialization in wxWidgets, this
module should be imported **before** the :class:`wx.App` object is
created.
"""
from ._html import *
import wx
EVT_HTML_CELL_CLICKED = wx.PyEventBinder(wxEVT_HTML_CELL_CLICKED, 1)
EVT_HTML_CELL_HOVER = wx.PyEventBinder(wxEVT_HTML_CELL_HOVER, 1)
EVT_HTML_LINK_CLICKED = wx.PyEventBinder(wxEVT_HTML_LINK_CLICKED, 1)
# deprecated wxEVT aliases
wxEVT_COMMAND_HTML_CELL_CLICKED = wxEVT_HTML_CELL_CLICKED
wxEVT_COMMAND_HTML_CELL_HOVER = wxEVT_HTML_CELL_HOVER
wxEVT_COMMAND_HTML_LINK_CLICKED = wxEVT_HTML_LINK_CLICKED
def _HtmlBookRecArray___repr__(self):
return "HtmlBookRecArray: " + repr(list(self))
HtmlBookRecArray.__repr__ = _HtmlBookRecArray___repr__
del _HtmlBookRecArray___repr__
BASE_URL = "http://dawningbrooke.net/apis/admin/registration/attendeeonsite/add/"
SERIAL_DEVICE = "/dev/ttyACM0"
if len(sys.argv) == 3:
BASE_URL = sys.argv[1]
SERIAL_DEVICE = sys.argv[2]
else:
print "Usage: {} <Base Add URL> <Serial port>".format(sys.argv[0])
print "Using defaults:\n URL: {}\n Port: {}\n".format(BASE_URL, SERIAL_DEVICE)
def xstr(s):
return '' if s is None else str(s)
t_DATA_WAITING = wx.NewEventType()
DATA_WAITING = wx.PyEventBinder(t_DATA_WAITING, 1)
t_THREAD_ERROR = wx.NewEventType()
THREAD_ERROR = wx.PyEventBinder(t_THREAD_ERROR, 1)
class AAMVATestFrame(wx.Frame):
def __init__(self, *args, **kwargs):
wx.Frame.__init__(self, *args, **kwargs)
self.panel = wx.Panel(self)
vSizer = wx.BoxSizer(wx.VERTICAL)
hSizer1 = wx.BoxSizer(wx.HORIZONTAL)
#Row 1
nameSt = wx.StaticText(self.panel, wx.ID_ANY, "Name")
hSizer1.Add(nameSt, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
self.NameText = wx.TextCtrl(self.panel, wx.ID_ANY, style=wx.TE_READONLY)
import codecs
import serial
import threading
import wx
import wxSerialConfigDialog
# ----------------------------------------------------------------------
# Create an own event type, so that GUI updates can be delegated
# this is required as on some platforms only the main thread can
# access the GUI without crashing. wxMutexGuiEnter/wxMutexGuiLeave
# could be used too, but an event is more elegant.
SERIALRX = wx.NewEventType()
# bind to serial data receive events
EVT_SERIALRX = wx.PyEventBinder(SERIALRX, 0)
class SerialRxEvent(wx.PyCommandEvent):
eventType = SERIALRX
def __init__(self, windowID, data):
wx.PyCommandEvent.__init__(self, self.eventType, windowID)
self.data = data
def Clone(self):
self.__class__(self.GetId(), self.data)
# ----------------------------------------------------------------------
def _EventMaker():
evt = wx.NewEventType()
return (evt, wx.PyEventBinder(evt))
import wx
rpcPENDING = 0
rpcDONE = 1
rpcEXCEPT = 2
class RPCRequest:
"""A wrapper to use for handling requests and their responses"""
status = rpcPENDING
result = None
# here's the ID for external events
wxEVT_EXTERNAL_EVENT = wx.NewEventType()
EVT_EXTERNAL_EVENT = wx.PyEventBinder(wxEVT_EXTERNAL_EVENT, 0)
class ExternalEvent(wx.PyEvent):
"""The custom event class used to pass xmlrpc calls from
the server thread into the GUI thread
"""
def __init__(self, method, args):
wx.PyEvent.__init__(self)
self.SetEventType(wxEVT_EXTERNAL_EVENT)
self.method = method
self.args = args
self.rpcStatus = RPCRequest()
self.rpcStatusLock = threading.Lock()
self.rpcCondVar = threading.Condition()
out = []
while 1:
if inpLines:
inp.write(inpLines.pop())
l = outp.readline()
if not l: break
out.append(l)
errLines = errp.readlines()
serr = ErrorStack.buildErrorList(errLines)
self.pid = pid
if serr or out:
return self.checkError(serr, _('Ran'), out, errRaw=errLines)
else:
return None
PreferredRunner = PopenModuleRunner
wxEVT_EXEC_FINISH = wx.NewId()
EVT_EXEC_FINISH = wx.PyEventBinder(wxEVT_EXEC_FINISH)
class ExecFinishEvent(wx.PyEvent):
def __init__(self, runner):
wx.PyEvent.__init__(self)
self.SetEventType(wxEVT_EXEC_FINISH)
self.runner = runner
def __init__(self):
self.EVT_TYPE_NOTICE = wx.NewEventType()
self.EVT_NOTICE = wx.PyEventBinder(self.EVT_TYPE_NOTICE, 1)
self.subscribers = {}
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Cockpit. If not, see <http://www.gnu.org/licenses/>.
import collections
import json
import typing
import wx
import cockpit.events
EVT_CHANNEL_ADDED = wx.PyEventBinder(wx.NewEventType())
EVT_CHANNEL_REMOVED = wx.PyEventBinder(wx.NewEventType())
Channel = typing.Dict[str, typing.Any]
class Channels(wx.EvtHandler):
"""Map names to channel configurations.
A channel configuration sets objective, light sources, and
cameras. It is the configuration to replicate the image
acquisition settings.
`Channels` keep the order of channels that are added. While
technically not needed for a map/dict object, this is used to
construct GUI elements where it is important to keep the order for
# (See also the genaxmodule script.)
import wx
import wx.activex
clsID = '{D27CDB6E-AE6D-11CF-96B8-444553540000}'
progID = 'ShockwaveFlash.ShockwaveFlash.1'
# Create eventTypes and event binders
wxEVT_ReadyStateChange = wx.activex.RegisterActiveXEvent('OnReadyStateChange')
wxEVT_Progress = wx.activex.RegisterActiveXEvent('OnProgress')
wxEVT_FSCommand = wx.activex.RegisterActiveXEvent('FSCommand')
EVT_ReadyStateChange = wx.PyEventBinder(wxEVT_ReadyStateChange, 1)
EVT_Progress = wx.PyEventBinder(wxEVT_Progress, 1)
EVT_FSCommand = wx.PyEventBinder(wxEVT_FSCommand, 1)
# Derive a new class from ActiveXWindow
class FlashWindow(wx.activex.ActiveXWindow):
def __init__(self, parent, ID=-1, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0, name='FlashWindow'):
wx.activex.ActiveXWindow.__init__(self, parent,
wx.activex.CLSID('{D27CDB6E-AE6D-11CF-96B8-444553540000}'),
ID, pos, size, style, name)
# Methods exported by the ActiveX object
def QueryInterface(self, riid):
return self.CallAXMethod('QueryInterface', riid)
import imagepreview
import nebulaguisettings as guisettings
import servers
import togwin
import trnlayerprefsdlg
import conjurerconfig as cfg
import conjurerframework as cjr
# Layers limit
MaxLayers = 255
# Event used to notify selection of a layer control
EVT_SELECT_TYPE = wx.NewEventType()
EVT_SELECT = wx.PyEventBinder(EVT_SELECT_TYPE, 1)
# LayerSelectedEvent class
class LayerSelectedEvent(wx.PyCommandEvent):
def __init__(self, id, object):
wx.PyCommandEvent.__init__(self, EVT_SELECT_TYPE, id)
self.SetEventObject(object)
# LayerCtrl class
class LayerCtrl(wx.PyControl):
"""Control used to handle a single terrain texture layer"""
def __init__(self, parent, id, layer_id):
wx.PyControl.__init__(self, parent, id, style=wx.NO_BORDER)
self.layer_id = layer_id
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 06 20:14:02 2015
@author: Sebastien Popoff
"""
try:
import wx
except ImportError:
raise ImportError("The wxPython module is required to run this program.")
import threading
import numpy as np
import time
EVT_NEW_IMAGE = wx.PyEventBinder(wx.NewEventType(), 0)
class ImageEvent(wx.PyCommandEvent):
def __init__(self, eventType=EVT_NEW_IMAGE.evtType[0], id=0):
wx.PyCommandEvent.__init__(self, eventType, id)
self.img = None
self.color = False
self.oldImageLock = None
self.eventLock = None
class SLMframe(wx.Frame):
"""Frame used to display full screen image."""
def __init__(self, monitor, isImageLock=True):
self.isImageLock = isImageLock
import wx.gizmos as gizmos
from wx.lib.pubsub import pub as Publisher
import wx.lib.splitter as spl
import invesalius.constants as const
import invesalius.gui.dialogs as dlg
#import invesalius.gui.dicom_preview_panel as dpp
import invesalius.reader.dicom_grouper as dcm
import invesalius.net.dicom as dcm_net
from wx.lib.mixins.listctrl import CheckListCtrlMixin
#from dicionario import musicdata
import wx.lib.mixins.listctrl as listmix
myEVT_SELECT_SERIE = wx.NewEventType()
EVT_SELECT_SERIE = wx.PyEventBinder(myEVT_SELECT_SERIE, 1)
myEVT_SELECT_SLICE = wx.NewEventType()
EVT_SELECT_SLICE = wx.PyEventBinder(myEVT_SELECT_SLICE, 1)
myEVT_SELECT_PATIENT = wx.NewEventType()
EVT_SELECT_PATIENT = wx.PyEventBinder(myEVT_SELECT_PATIENT, 1)
myEVT_SELECT_SERIE_TEXT = wx.NewEventType()
EVT_SELECT_SERIE_TEXT = wx.PyEventBinder(myEVT_SELECT_SERIE_TEXT, 1)
class SelectEvent(wx.PyCommandEvent):
def __init__(self, evtType, id):
super(SelectEvent, self).__init__(evtType, id)
# o wxGridRowMover -> GridRowMover
#
import wx
import wx.grid
#----------------------------------------------------------------------------
# event class and macros
#
# New style 12/7/03
#
wxEVT_COMMAND_GRID_COL_MOVE = wx.NewEventType()
wxEVT_COMMAND_GRID_ROW_MOVE = wx.NewEventType()
EVT_GRID_COL_MOVE = wx.PyEventBinder(wxEVT_COMMAND_GRID_COL_MOVE, 1)
EVT_GRID_ROW_MOVE = wx.PyEventBinder(wxEVT_COMMAND_GRID_ROW_MOVE, 1)
#----------------------------------------------------------------------------
class GridColMoveEvent(wx.PyCommandEvent):
def __init__(self, id, dCol, bCol):
wx.PyCommandEvent.__init__(self, id=id)
self.SetEventType(wxEVT_COMMAND_GRID_COL_MOVE)
self.moveColumn = dCol
self.beforeColumn = bCol
def GetMoveColumn(self):
return self.moveColumn
import projects.ProjCmnDlg as ProjCmnDlg
# Editra Library Imports
import util
import eclib
#--------------------------------------------------------------------------#
# Globals
_ = wx.GetTranslation
#--------------------------------------------------------------------------#
DATE_FORMAT = '%Y-%m-%d %I:%M %p'
edEVT_UPDATE_ITEMS = wx.NewEventType()
EVT_UPDATE_ITEMS = wx.PyEventBinder(edEVT_UPDATE_ITEMS, 1)
class UpdateItemsEvent(wx.PyCommandEvent):
"""Event to signal that items need updating"""
def __init__(self, etype, eid, value=[]):
super(UpdateItemsEvent, self).__init__(etype, eid)
self._value = value
def GetValue(self):
"""Get event value"""
return self._value
#--------------------------------------------------------------------------#
import wx
TOOLBUTTONEVENT = wx.NewEventType()
TOOLTOGGLEEVENT = wx.NewEventType()
TOOLDROPDOWNEVENT = wx.NewEventType()
TOOLRIGHTCLICKEVENT = wx.NewEventType()
TOOLRESIZEEVENT = wx.NewEventType()
ZEVT_TOOL_BUTTON = wx.PyEventBinder(TOOLBUTTONEVENT, 1)
ZEVT_TOOL_TOGGLE_BUTTON = wx.PyEventBinder(TOOLTOGGLEEVENT, 1)
ZEVT_TOOL_DROPDOWN_BUTTON = wx.PyEventBinder(TOOLDROPDOWNEVENT, 1)
ZEVT_TOOL_RIGHT_CLICK = wx.PyEventBinder(TOOLRIGHTCLICKEVENT, 1)
ZEVT_TOOLBAR_RESIZE = wx.PyEventBinder(TOOLRESIZEEVENT, 1)
# ----------------------------------------------------------------------------
# Custom event class.
# ----------------------------------------------------------------------------
class ZToolEvent(wx.PyCommandEvent):
def __init__(self, eventType, windowID, toolNode):
self.toolNode = toolNode
wx.PyCommandEvent.__init__(self, eventType, windowID)
#end __init__
def getToolNode(self):
return self.toolNode
# end getToolNode()
def Clone(self):
return self.__class__(self.GetEventType(), self.GetId(), self.getToolNode())
# end Clone()
def GetCurveWWWl(self, curve):
return (self.curves[curve].ww, self.curves[curve].wl)
class CLUTEvent(wx.PyCommandEvent):
def __init__(self, evtType, id, curve):
wx.PyCommandEvent.__init__(self, evtType, id)
self.curve = curve
def GetCurve(self):
return self.curve
# Occurs when CLUT is sliding
myEVT_CLUT_SLIDER = wx.NewEventType()
EVT_CLUT_SLIDER = wx.PyEventBinder(myEVT_CLUT_SLIDER, 1)
# Occurs when CLUT was slided
myEVT_CLUT_SLIDER_CHANGE = wx.NewEventType()
EVT_CLUT_SLIDER_CHANGE = wx.PyEventBinder(myEVT_CLUT_SLIDER_CHANGE, 1)
# Occurs when CLUT point is changing
myEVT_CLUT_POINT_MOVE = wx.NewEventType()
EVT_CLUT_POINT_MOVE = wx.PyEventBinder(myEVT_CLUT_POINT_MOVE, 1)
# Occurs when a CLUT point was changed
myEVT_CLUT_POINT_RELEASE = wx.NewEventType()
EVT_CLUT_POINT_RELEASE = wx.PyEventBinder(myEVT_CLUT_POINT_RELEASE, 1)
# Selected a curve
myEVT_CLUT_CURVE_SELECT = wx.NewEventType()
__docformat__ = "epytext"
import wx
import math
# Flag to use double buffering (recommendeded = 1)
KC_BUFFERED_DC = 1
"""Flag to use double buffering (recommendeded = 1)"""
# Events
wxEVT_KC_ANGLE_CHANGING = wx.NewEventType()
wxEVT_KC_ANGLE_CHANGED = wx.NewEventType()
EVT_KC_ANGLE_CHANGING = wx.PyEventBinder(wxEVT_KC_ANGLE_CHANGING, 1)
""" Notify the client that the knob is changing its value."""
EVT_KC_ANGLE_CHANGED = wx.PyEventBinder(wxEVT_KC_ANGLE_CHANGED, 1)
""" Notify the client that the knob has changed its value."""
# ---------------------------------------------------------------------------- #
# Class KnobCtrlEvent
# ---------------------------------------------------------------------------- #
class KnobCtrlEvent(wx.CommandEvent):
"""
Represent details of the events that the :class:`KnobCtrl` object sends.
"""
def __init__(self, eventType, eventId=1):
"""
import os
import wx
import math
import wx.lib.agw.floatspin as FS
from time import sleep
from ViewPane import ViewPane
from protocolPane import ProtocolPane
from controlPanel import ControlPanel
from LightCrafter import wxLightCrafterFrame
from PreferencesDialog import PreferencesDialog
import socket
import threading
myEVT_MESSAGE = wx.NewEventType()
EVT_MESSAGE = wx.PyEventBinder(myEVT_MESSAGE, 1)
myEVT_RETURN_MESSAGE = wx.NewEventType()
EVT_RETURN_MESSAGE = wx.PyEventBinder(myEVT_RETURN_MESSAGE, 2)
# Sets Up The Class For The Program And Creates The Window
class wxFixationFrame(wx.Frame):
# The number of ppd of the screen we'll be projecting to (e.g. Lightcrafter, Projector, etc).
SCREEN_PPD = 20
# The increment steps we'll use.
MINOR_INCREMENT = 0.5
MAJOR_INCREMENT = 1
def __init__(self, parent=None, id=wx.ID_ANY):
wx.PyCommandEvent.__init__(self, id=id)
self.SetEventType(wxEVT_COMMAND_COLOURSELECT)
self.value = value
def GetValue(self):
"""
Returns the currently selected colour.
:rtype: :class:`wx.Colour`
"""
return self.value
EVT_COLOURSELECT = wx.PyEventBinder(wxEVT_COMMAND_COLOURSELECT, 1)
#----------------------------------------------------------------------------
class CustomColourData(object):
"""
A simple container for tracking custom colours to be shown in the colour
dialog, and which facilitates reuse of this collection across multiple
instances or multiple invocations of the :class:`ColourSelect` button.
"""
COUNT = 16
def __init__(self):
self._customColours = [None] * self.COUNT
