# --------------------------------------------------------------------------------- #
# RULERCTRL wxPython IMPLEMENTATION
#
# Andrea Gavana, @ 03 Nov 2006
# Latest Revision: 01 Dec 2009, 09.00 GMT
#
#
# TODO List
#
# 1. Any idea?
#
# For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
# Write To Me At:
#
# gavana@kpo.kz
# andrea.gavana@gmail.com
#
# Or, Obviously, To The wxPython Mailing List!!!
#
#
# End Of Comments
# --------------------------------------------------------------------------------- #
"""
RulerCtrl implements a ruler window that can be placed on top, bottom, left or right
to any wxPython widget.
Description
===========
RulerCtrl implements a ruler window that can be placed on top, bottom, left or right
to any wxPython widget. It is somewhat similar to the rulers you can find in text
editors software, though not so powerful.
RulerCtrl has the following characteristics:
- Can be horizontal or vertical;
- 4 built-in formats: integer, real, time and linearDB formats;
- Units (as ``cm``, ``dB``, ``inches``) can be displayed together with the label values;
- Possibility to add a number of "paragraph indicators", small arrows that point at
the current indicator position;
- Customizable background colour, tick colour, label colour;
- Possibility to flip the ruler (i.e. changing the tick alignment);
- Changing individually the indicator colour (requires PIL at the moment);
- Different window borders are supported (``wx.STATIC_BORDER``, ``wx.SUNKEN_BORDER``,
``wx.DOUBLE_BORDER``, ``wx.NO_BORDER``, ``wx.RAISED_BORDER``, ``wx.SIMPLE_BORDER``);
- Logarithmic scale available;
- Possibility to draw a thin line over a selected window when moving an indicator,
which emulates the text editors software.
And a lot more. See the demo for a review of the functionalities.
Events
======
RulerCtrl implements the following events related to indicators:
- ``EVT_INDICATOR_CHANGING``: the user is about to change the position of one indicator;
- ``EVT_INDICATOR_CHANGED``: the user has changed the position of one indicator.
Supported Platforms
===================
RulerCtrl has been tested on the following platforms:
* Windows (Windows XP);
* Linux Ubuntu (Dapper 6.06)
Window Styles
=============
`No particular window styles are available for this class.`
Events Processing
=================
This class processes the following events:
========================== ==================================================
Event Name Description
========================== ==================================================
``EVT_INDICATOR_CHANGED`` The user has changed the indicator value.
``EVT_INDICATOR_CHANGING`` The user is about to change the indicator value.
========================== ==================================================
License And Version
===================
RulerCtrl is distributed under the wxPython license.
Latest Revision: Andrea Gavana @ 01 Dec 2009, 09.00 GMT
Version 0.3
"""
__docformat__ = "epytext"
import wx
import math
import cStringIO, zlib
# Try to import PIL, if possible.
# This is used only to change the colour for an indicator arrow.
_hasPIL = False
try:
import Image
_hasPIL = True
except:
pass
# Built-in formats
IntFormat = 1
""" Integer format. """
RealFormat = 2
""" Real format. """
TimeFormat = 3
""" Time format. """
LinearDBFormat = 4
""" Linear DB format. """
HHMMSS_Format = 5
""" HHMMSS format. """
# Events
wxEVT_INDICATOR_CHANGING = wx.NewEventType()
wxEVT_INDICATOR_CHANGED = wx.NewEventType()
EVT_INDICATOR_CHANGING = wx.PyEventBinder(wxEVT_INDICATOR_CHANGING, 2)
""" The user is about to change the indicator value. """
EVT_INDICATOR_CHANGED = wx.PyEventBinder(wxEVT_INDICATOR_CHANGED, 2)
""" The user has changed the indicator value. """
# Some accessor functions
#----------------------------------------------------------------------
def GetIndicatorData():
return zlib.decompress(
'x\xda\x01x\x01\x87\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\n\x00\
\x00\x00\n\x08\x06\x00\x00\x00\x8d2\xcf\xbd\x00\x00\x00\x04sBIT\x08\x08\x08\
\x08|\x08d\x88\x00\x00\x01/IDAT\x18\x95m\xceO(\x83q\x1c\xc7\xf1\xf7\xef\xf9\
\xcd\xf6D6\xca\x1c\xc8\x9f\x14\'J-\xc4A9(9(-\xe5 \xed\xe4\xe2\xe2\xb2\x928\
\xb9\xec\xc2\x01\x17.\x0e\xe4\xe6B\xed\xb2\x1c\xdc$5\x97\xf9S\xb3\x14+\x0eO\
\xdb\xccZ\x9e\xfd\xf9\xba\x98E{\x1d\xbf\xbd\xfb\xf4U\x00\x18\x9d\xc3\xad\x1d\
\xa1+\xa7S\x15\xf8\xa1\xb5i\xbc\xc4\xd7\x0f\xca\xc5\xd82U3[\x97\xb1\x82\xc4S\
"\x89\xb4\xc8SZ\xc4\xb2E\xfa\x06CR)\x1c\x00\xb8\x8cb"-|\x94@\x01\x0e\r\xee&\
\xf8\x12\xc5\xdf\xd0\xd4\xf2\xf6i\x90/\x82\xe9\x82\xdb\xe72\xa7\xe7%\x92\x99\
\xdfA\xb4j\x9b]\xa5\xaek\xbag|\xaa\xdd\xca)\xceb\x10\xbe\x87\xacm VT\xd0N\
\x0f\xf9\xd7\x94\xd6\xde\xb1\xdd\xf9\xcdm_\x83\xdb\x81\x95W\x88\x02\xad\x159\
\x01\xcc!U2}\xa3$\x0f\x1dZR\xd1\xfd\xbb\x9b\xc7\x89\xc99\x7f\xb7\xb7\xd1\x00\
\xc0.B\xbe\xac\xc8\xbe?P\x8e\x8c\x1ccg\x02\xd5\x1f\x9a\x07\xf6\x82a[6.D\xfc\
\'"\x9e\xc0\xb5\xa0\xeb\xd7\xa8\xc9\xdd\xbf\xb3pdI\xefRD\xc0\x08\xd6\x8e*\\-\
+\xa0\x17\xff\x9f\xbf\x01{\xb5t\x9e\x99]a\x97\x00\x00\x00\x00IEND\xaeB`\x82G\
\xbf\xa8>' )
def GetIndicatorBitmap():
return wx.BitmapFromImage(GetIndicatorImage())
def GetIndicatorImage():
stream = cStringIO.StringIO(GetIndicatorData())
return wx.ImageFromStream(stream)
def MakePalette(tr, tg, tb):
"""
Creates a palette to be applied on an image based on input colour.
:param `tr`: the red intensity of the input colour;
:param `tg`: the green intensity of the input colour;
:param `tb`: the blue intensity of the input colour.
"""
l = []
for i in range(255):
l.extend([tr*i / 255, tg*i / 255, tb*i / 255])
return l
def ConvertWXToPIL(bmp):
"""
Converts a `wx.Image` into a PIL image.
:param `bmp`: an instance of `wx.Image`.
"""
width = bmp.GetWidth()
height = bmp.GetHeight()
img = Image.fromstring("RGBA", (width, height), bmp.GetData())
return img
def ConvertPILToWX(pil, alpha=True):
"""
Converts a PIL image into a `wx.Image`.
:param `pil`: a PIL image;
:param `alpha`: ``True`` if the image contains alpha transparency, ``False``
otherwise.
"""
if alpha:
image = apply(wx.EmptyImage, pil.size)
image.SetData(pil.convert("RGB").tostring())
image.SetAlphaData(pil.convert("RGBA").tostring()[3::4])
else:
image = wx.EmptyImage(pil.size[0], pil.size[1])
new_image = pil.convert('RGB')
data = new_image.tostring()
image.SetData(data)
return image
# ---------------------------------------------------------------------------- #
# Class RulerCtrlEvent
# ---------------------------------------------------------------------------- #
class RulerCtrlEvent(wx.PyCommandEvent):
"""
Represent details of the events that the L{RulerCtrl} object sends.
"""
def __init__(self, eventType, eventId=1):
"""
Default class constructor.
:param `eventType`: the event type;
:param `eventId`: the event identifier.
"""
wx.PyCommandEvent.__init__(self, eventType, eventId)
def SetValue(self, value):
"""
Sets the event value.
:param `value`: the new indicator position.
"""
self._value = value
def GetValue(self):
""" Returns the event value. """
return self._value
def SetOldValue(self, oldValue):
"""
Sets the event old value.
:param `value`: the old indicator position.
"""
self._oldValue = oldValue
def GetOldValue(self):
""" Returns the event old value. """
return self._oldValue
# ---------------------------------------------------------------------------- #
# Class Label
# ---------------------------------------------------------------------------- #
class Label(object):
"""
Auxilary class. Just holds information about a label in L{RulerCtrl}.
"""
def __init__(self, pos=-1, lx=-1, ly=-1, text=""):
"""
Default class constructor.
:param `pos`: the indicator position;
:param `lx`: the indicator x coordinate;
:param `ly`: the indicator y coordinate;
:param `text`: the label text.
"""
self.pos = pos
self.lx = lx
self.ly = ly
self.text = text
# ---------------------------------------------------------------------------- #
# Class Indicator
# ---------------------------------------------------------------------------- #
class Indicator(object):
"""
This class holds all the information about a single indicator inside L{RulerCtrl}.
You should not call this class directly. Use `ruler.AddIndicator(id, value)` to
add an indicator to your L{RulerCtrl}.
"""
def __init__(self, parent, id=wx.ID_ANY, value=0):
"""
Default class constructor.
:param `parent`: the parent window, an instance of L{RulerCtrl};
:param `id`: the indicator identifier;
:param `value`: the initial value of the indicator.
"""
self._parent = parent
if id == wx.ID_ANY:
id = wx.NewId()
self._id = id
self._colour = None
self.RotateImage(GetIndicatorImage())
self.SetValue(value)
def GetPosition(self):
""" Returns the position at which we should draw the indicator bitmap. """
orient = self._parent._orientation
flip = self._parent._flip
left, top, right, bottom = self._parent.GetBounds()
minval = self._parent._min
maxval = self._parent._max
value = self._value
if self._parent._log:
value = math.log10(value)
maxval = math.log10(maxval)
minval = math.log10(minval)
pos = float(value-minval)/abs(maxval - minval)
if orient == wx.HORIZONTAL:
xpos = int(pos*right) - self._img.GetWidth()/2
if flip:
ypos = top
else:
ypos = bottom - self._img.GetHeight()
else:
ypos = int(pos*bottom) - self._img.GetHeight()/2
if flip:
xpos = left
else:
xpos = right - self._img.GetWidth()
return xpos, ypos
def GetImageSize(self):
""" Returns the indicator bitmap size. """
return self._img.GetWidth(), self._img.GetHeight()
def GetRect(self):
""" Returns the indicator client rectangle. """
return self._rect
def RotateImage(self, img=None):
"""
Rotates the default indicator bitmap.
:param `img`: if not ``None``, the indicator image.
"""
if img is None:
img = GetIndicatorImage()
orient = self._parent._orientation
flip = self._parent._flip
left, top, right, bottom = self._parent.GetBounds()
if orient == wx.HORIZONTAL:
if flip:
img = img.Rotate(math.pi, (5, 5), True)
else:
if flip:
img = img.Rotate(-math.pi/2, (5, 5), True)
else:
img = img.Rotate(math.pi/2, (5, 5), True)
self._img = img
def SetValue(self, value):
"""
Sets the indicator value.
:param `value`: the new indicator value.
"""
if value < self._parent._min:
value = self._parent._min
if value > self._parent._max:
value = self._parent._max
self._value = value
self._rect = wx.Rect()
self._parent.Refresh()
def GetValue(self):
""" Returns the indicator value. """
return self._value
def Draw(self, dc):
"""
Actually draws the indicator.
:param `dc`: an instance of `wx.DC`.
"""
xpos, ypos = self.GetPosition()
bmp = wx.BitmapFromImage(self._img)
dc.DrawBitmap(bmp, xpos, ypos, True)
self._rect = wx.Rect(xpos, ypos, self._img.GetWidth(), self._img.GetHeight())
def GetId(self):
""" Returns the indicator id. """
return self._id
def SetColour(self, colour):
"""
Sets the indicator colour.
:param `colour`: the new indicator colour, an instance of `wx.Colour`.
:note: This method requires PIL.
"""
if not _hasPIL:
return
palette = colour.Red(), colour.Green(), colour.Blue()
img = ConvertWXToPIL(GetIndicatorBitmap())
l = MakePalette(*palette)
# The Palette Can Be Applied Only To "L" And "P" Images, Not "RGBA"
img = img.convert("L")
# Apply The New Palette
img.putpalette(l)
# Convert The Image Back To RGBA
img = img.convert("RGBA")
img = ConvertPILToWX(img)
self.RotateImage(img)
self._parent.Refresh()
# ---------------------------------------------------------------------------- #
# Class RulerCtrl
# ---------------------------------------------------------------------------- #
class RulerCtrl(wx.PyPanel):
"""
RulerCtrl implements a ruler window that can be placed on top, bottom, left or right
to any wxPython widget. It is somewhat similar to the rulers you can find in text
editors software, though not so powerful.
"""
def __init__(self, parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
style=wx.STATIC_BORDER, orient=wx.HORIZONTAL):
"""
Default class constructor.
:param `parent`: parent window. Must not be ``None``;
:param `id`: window identifier. A value of -1 indicates a default value;
:param `pos`: the control position. A value of (-1, -1) indicates a default position,
chosen by either the windowing system or wxPython, depending on platform;
:param `size`: the control size. A value of (-1, -1) indicates a default size,
chosen by either the windowing system or wxPython, depending on platform;
:param `style`: the window style;
:param `orient`: sets the orientation of the L{RulerCtrl}, and can be either
``wx.HORIZONTAL`` of ``wx.VERTICAL``.
"""
wx.PyPanel.__init__(self, parent, id, pos, size, style)
self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
width, height = size
self._min = 0.0
self._max = 10.0
self._orientation = orient
self._spacing = 5
self._hassetspacing = False
self._format = RealFormat
self._flip = False
self._log = False
self._labeledges = False
self._units = ""
self._drawingparent = None
self._drawingpen = wx.Pen(wx.BLACK, 2)
self._left = -1
self._top = -1
self._right = -1
self._bottom = -1
self._major = 1
self._minor = 1
self._indicators = []
self._currentIndicator = None
fontsize = 10
if wx.Platform == "__WXMSW__":
fontsize = 8
self._minorfont = wx.Font(fontsize, wx.SWISS, wx.NORMAL, wx.NORMAL)
self._majorfont = wx.Font(fontsize, wx.SWISS, wx.NORMAL, wx.BOLD)
if wx.Platform == "__WXMAC__":
self._minorfont.SetNoAntiAliasing(True)
self._majorfont.SetNoAntiAliasing(True)
self._bits = []
self._userbits = []
self._userbitlen = 0
self._tickmajor = True
self._tickminor = True
self._timeformat = IntFormat
self._labelmajor = True
self._labelminor = True
self._tickpen = wx.Pen(wx.BLACK)
self._textcolour = wx.BLACK
self._background = wx.WHITE
self._valid = False
self._state = 0
self._style = style
self._orientation = orient
wbound, hbound = self.CheckStyle()
if orient & wx.VERTICAL:
self.SetBestSize((28, height))
else:
self.SetBestSize((width, 28))
self.SetBounds(0, 0, wbound, hbound)
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_MOUSE_EVENTS, self.OnMouseEvents)
self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, lambda evt: True)
def OnMouseEvents(self, event):
"""
Handles the ``wx.EVT_MOUSE_EVENTS`` event for L{RulerCtrl}.
:param `event`: a `wx.MouseEvent` event to be processed.
"""
if not self._indicators:
event.Skip()
return
mousePos = event.GetPosition()
if event.LeftDown():
self.CaptureMouse()
self.GetIndicator(mousePos)
self._mousePosition = mousePos
self.SetIndicatorValue(sendEvent=False)
elif event.Dragging() and self._currentIndicator:
self._mousePosition = mousePos
self.SetIndicatorValue()
elif event.LeftUp():
if self.HasCapture():
self.ReleaseMouse()
self.SetIndicatorValue(sendEvent=False)
if self._drawingparent:
self._drawingparent.Refresh()
self._currentIndicator = None
#else:
# self._currentIndicator = None
event.Skip()
def OnPaint(self, event):
"""
Handles the ``wx.EVT_PAINT`` event for L{RulerCtrl}.
:param `event`: a `wx.PaintEvent` event to be processed.
"""
dc = wx.BufferedPaintDC(self)
dc.SetBackground(wx.Brush(self._background))
dc.Clear()
self.Draw(dc)
def OnSize(self, event):
"""
Handles the ``wx.EVT_SIZE`` event for L{RulerCtrl}.
:param `event`: a `wx.SizeEvent` event to be processed.
"""
width, height = self.CheckStyle()
self.SetBounds(0, 0, width, height)
self.Invalidate()
event.Skip()
def OnEraseBackground(self, event):
"""
Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{RulerCtrl}.
:param `event`: a `wx.EraseEvent` event to be processed.
:note: This method is intentionally empty to reduce flicker.
"""
pass
def SetIndicatorValue(self, sendEvent=True):
"""
Sets the indicator value.
:param `sendEvent`: ``True`` to send a L{RulerCtrlEvent}, ``False`` otherwise.
"""
if self._currentIndicator is None:
return
left, top, right, bottom = self.GetBounds()
x = self._mousePosition.x
y = self._mousePosition.y
maxvalue = self._max
minvalue = self._min
if self._log:
minvalue = math.log10(minvalue)
maxvalue = math.log10(maxvalue)
deltarange = abs(self._max - self._min)
if self._orientation == wx.HORIZONTAL: # only x moves
value = deltarange*float(x)/(right - left)
else:
value = deltarange*float(y)/(bottom - top)
value += minvalue
if self._log:
value = 10**value
if value < self._min or value > self._max:
return
self.DrawOnParent(self._currentIndicator)
if sendEvent:
event = RulerCtrlEvent(wxEVT_INDICATOR_CHANGING, self._currentIndicator.GetId())
event.SetOldValue(self._currentIndicator.GetValue())
event.SetValue(value)
event.SetEventObject(self)
if self.GetEventHandler().ProcessEvent(event):
self.DrawOnParent(self._currentIndicator)
return
self._currentIndicator.SetValue(value)
if sendEvent:
event.SetEventType(wxEVT_INDICATOR_CHANGED)
event.SetOldValue(value)
self.GetEventHandler().ProcessEvent(event)
self.DrawOnParent(self._currentIndicator)
self.Refresh()
def GetIndicator(self, mousePos):
"""
Returns the indicator located at the mouse position `mousePos` (if any).
:param `mousePos`: the mouse position, an instance of `wx.Point`.
"""
for indicator in self._indicators:
if indicator.GetRect().Contains(mousePos):
self._currentIndicator = indicator
break
def CheckStyle(self):
""" Adjust the L{RulerCtrl} style accordingly to borders, units, etc..."""
width, height = self.GetSize()
if self._orientation & wx.HORIZONTAL:
if self._style & wx.NO_BORDER:
hbound = 28
wbound = width-1
elif self._style & wx.SIMPLE_BORDER:
hbound = 27
wbound = width-1
elif self._style & wx.STATIC_BORDER:
hbound = 26
wbound = width-3
elif self._style & wx.SUNKEN_BORDER:
hbound = 24
wbound = width-5
elif self._style & wx.RAISED_BORDER:
hbound = 22
wbound = width-7
elif self._style & wx.DOUBLE_BORDER:
hbound = 22
wbound = width-7
else:
if self._style & wx.NO_BORDER:
wbound = 28
hbound = height-1
elif self._style & wx.SIMPLE_BORDER:
wbound = 27
hbound = height-1
elif self._style & wx.STATIC_BORDER:
wbound = 26
hbound = height-3
elif self._style & wx.SUNKEN_BORDER:
wbound = 24
hbound = height-5
elif self._style & wx.RAISED_BORDER:
wbound = 22
hbound = height-7
elif self._style & wx.DOUBLE_BORDER:
wbound = 22
hbound = height-7
minText = self.LabelString(self._min, major=True)
maxText = self.LabelString(self._max, major=True)
dc = wx.ClientDC(self)
minWidth, minHeight = dc.GetTextExtent(minText)
maxWidth, maxHeight = dc.GetTextExtent(maxText)
maxWidth = max(maxWidth, minWidth)
maxHeight = max(maxHeight, minHeight)
if self._orientation == wx.HORIZONTAL:
if maxHeight + 4 > hbound:
hbound = maxHeight
self.SetBestSize((-1, maxHeight + 4))
if self.GetContainingSizer():
self.GetContainingSizer().Layout()
else:
if maxWidth + 4 > wbound:
wbound = maxWidth
self.SetBestSize((maxWidth + 4, -1))
if self.GetContainingSizer():
self.GetContainingSizer().Layout()
return wbound, hbound
def TickMajor(self, tick=True):
"""
Sets whether the major ticks should be ticked or not.
:param `tick`: ``True`` to show major ticks, ``False`` otherwise.
"""
if self._tickmajor != tick:
self._tickmajor = tick
self.Invalidate()
def TickMinor(self, tick=True):
"""
Sets whether the minor ticks should be ticked or not.
:param `tick`: ``True`` to show minor ticks, ``False`` otherwise.
"""
if self._tickminor != tick:
self._tickminor = tick
self.Invalidate()
def LabelMinor(self, label=True):
"""
Sets whether the minor ticks should be labeled or not.
:param `label`: ``True`` to label minor ticks, ``False`` otherwise.
"""
if self._labelminor != label:
self._labelminor = label
self.Invalidate()
def LabelMajor(self, label=True):
"""
Sets whether the major ticks should be labeled or not.
:param `label`: ``True`` to label major ticks, ``False`` otherwise.
"""
if self._labelmajor != label:
self._labelmajor = label
self.Invalidate()
def GetTimeFormat(self):
""" Returns the time format. """
return self._timeformat
def SetTimeFormat(self, format=TimeFormat):
"""
Sets the time format.
:param `format`: the format used to display time values.
"""
if self._timeformat != format:
self._timeformat = format
self.Invalidate()
def SetFormat(self, format):
"""
Sets the format for L{RulerCtrl}.
:param `format`: the format used to display values in L{RulerCtrl}. This can be
one of the following bits:
====================== ======= ==============================
Format Value Description
====================== ======= ==============================
``IntFormat`` 1 Integer format
``RealFormat`` 2 Real format
``TimeFormat`` 3 Time format
``LinearDBFormat`` 4 Linear DB format
``HHMMSS_Format`` 5 HHMMSS format
====================== ======= ==============================
"""
if self._format != format:
self._format = format
self.Invalidate()
def SetLog(self, log=True):
"""
Sets whether L{RulerCtrl} should have a logarithmic scale or not.
:param `log`: ``True`` to use a logarithmic scake, ``False`` to use a
linear one.
"""
if self._log != log:
self._log = log
self.Invalidate()
def SetUnits(self, units):
"""
Sets the units that should be displayed beside the labels.
:param `units`: the units that should be displayed beside the labels.
"""
# Specify the name of the units (like "dB") if you
# want numbers like "1.6" formatted as "1.6 dB".
if self._units != units:
self._units = units
self.Invalidate()
def SetBackgroundColour(self, colour):
"""
Sets the L{RulerCtrl} background colour.
:param `colour`: an instance of `wx.Colour`.
:note: Overridden from `wx.PyPanel`.
"""
self._background = colour
wx.PyPanel.SetBackgroundColour(self, colour)
self.Refresh()
def SetOrientation(self, orient=None):
"""
Sets the L{RulerCtrl} orientation.
:param `orient`: can be ``wx.HORIZONTAL`` or ``wx.VERTICAL``.
"""
if orient is None:
orient = wx.HORIZONTAL
if self._orientation != orient:
self._orientation = orient
if self._orientation == wx.VERTICAL and not self._hassetspacing:
self._spacing = 2
self.Invalidate()
def SetRange(self, minVal, maxVal):
"""
Sets the L{RulerCtrl} range.
:param `minVal`: the minimum value of L{RulerCtrl};
:param `maxVal`: the maximum value of L{RulerCtrl}.
"""
# For a horizontal ruler,
# minVal is the value in the center of pixel "left",
# maxVal is the value in the center of pixel "right".
if self._min != minVal or self._max != maxVal:
self._min = minVal
self._max = maxVal
self.Invalidate()
def SetSpacing(self, spacing):
"""
Sets the L{RulerCtrl} spacing between labels.
:param `spacing`: the spacing between labels, in pixels.
"""
self._hassetspacing = True
if self._spacing != spacing:
self._spacing = spacing
self.Invalidate()
def SetLabelEdges(self, labelEdges=True):
"""
Sets whether the edge values should always be displayed or not.
:param `labelEdges`: ``True`` to always display edge labels, ``False`` otherwise/
"""
# If this is True, the edges of the ruler will always
# receive a label. If not, the nearest round number is
# labeled (which may or may not be the edge).
if self._labeledges != labelEdges:
self._labeledges = labelEdges
self.Invalidate()
def SetFlip(self, flip=True):
"""
Sets whether the orientation of the tick marks should be reversed.
:param `flip`: ``True`` to reverse the orientation of the tick marks, ``False``
otherwise.
"""
# If this is True, the orientation of the tick marks
# is reversed from the default eg. above the line
# instead of below
if self._flip != flip:
self._flip = flip
self.Invalidate()
for indicator in self._indicators:
indicator.RotateImage()
def SetFonts(self, minorFont, majorFont):
"""
Sets the fonts for minor and major tick labels.
:param `minorFont`: the font used to draw minor ticks, a valid `wx.Font` object;
:param `majorFont`: the font used to draw major ticks, a valid `wx.Font` object.
"""
self._minorfont = minorFont
self._majorfont = majorFont
if wx.Platform == "__WXMAC__":
self._minorfont.SetNoAntiAliasing(True)
self._majorfont.SetNoAntiAliasing(True)
self.Invalidate()
def SetTickPenColour(self, colour=wx.BLACK):
"""
Sets the pen colour to draw the ticks.
:param `colour`: a valid `wx.Colour` object.
"""
self._tickpen = wx.Pen(colour)
self.Refresh()
def SetLabelColour(self, colour=wx.BLACK):
"""
Sets the labels colour.
:param `colour`: a valid `wx.Colour` object.
"""
self._textcolour = colour
self.Refresh()
def OfflimitsPixels(self, start, end):
""" Used internally. """
if not self._userbits:
if self._orientation == wx.HORIZONTAL:
self._length = self._right-self._left
else:
self._length = self._bottom-self._top
self._userbits = [0]*self._length
self._userbitlen = self._length+1
if end < start:
i = end
end = start
start = i
if start < 0:
start = 0
if end > self._length:
end = self._length
for ii in xrange(start, end+1):
self._userbits[ii] = 1
def SetBounds(self, left, top, right, bottom):
"""
Sets the bounds for L{RulerCtrl} (its client rectangle).
:param `left`: the left corner of the client rectangle;
:param `top`: the top corner of the client rectangle;
:param `right`: the right corner of the client rectangle;
:param `bottom`: the bottom corner of the client rectangle.
"""
if self._left != left or self._top != top or self._right != right or \
self._bottom != bottom:
self._left = left
self._top = top
self._right = right
self._bottom = bottom
self.Invalidate()
def GetBounds(self):
""" Returns the L{RulerCtrl} bounds (its client rectangle). """
return self._left, self._top, self._right, self._bottom
def AddIndicator(self, id, value):
"""
Adds an indicator to L{RulerCtrl}. You should pass a unique id and a starting
value for the indicator.
:param `id`: the indicator identifier;
:param `value`: the indicator initial value.
"""
self._indicators.append(Indicator(self, id, value))
self.Refresh()
def SetIndicatorColour(self, id, colour=None):
"""
Sets the indicator colour.
:param `id`: the indicator identifier;
:param `colour`: a valid `wx.Colour` object.
:note: This method requires PIL to change the image palette.
"""
if not _hasPIL:
return
if colour is None:
colour = wx.WHITE
for indicator in self._indicators:
if indicator.GetId() == id:
indicator.SetColour(colour)
break
def Invalidate(self):
""" Invalidates the ticks calculations. """
self._valid = False
if self._orientation == wx.HORIZONTAL:
self._length = self._right - self._left
else:
self._length = self._bottom - self._top
self._majorlabels = []
self._minorlabels = []
self._bits = []
self._userbits = []
self._userbitlen = 0
self.Refresh()
def FindLinearTickSizes(self, UPP):
""" Used internally. """
# Given the dimensions of the ruler, the range of values it
# has to display, and the format (i.e. Int, Real, Time),
# figure out how many units are in one Minor tick, and
# in one Major tick.
#
# The goal is to always put tick marks on nice round numbers
# that are easy for humans to grok. This is the most tricky
# with time.
# As a heuristic, we want at least 16 pixels
# between each minor tick
units = 16.0*abs(UPP)
self._digits = 0
if self._format == LinearDBFormat:
if units < 0.1:
self._minor = 0.1
self._major = 0.5
return
if units < 1.0:
self._minor = 1.0
self._major = 6.0
return
self._minor = 3.0
self._major = 12.0
return
elif self._format == IntFormat:
d = 1.0
while 1:
if units < d:
self._minor = d
self._major = d*5.0
return
d = d*5.0
if units < d:
self._minor = d
self._major = d*2.0
return
d = 2.0*d
elif self._format == TimeFormat:
if units > 0.5:
if units < 1.0: # 1 sec
self._minor = 1.0
self._major = 5.0
return
if units < 5.0: # 5 sec
self._minor = 5.0
self._major = 15.0
return
if units < 10.0:
self._minor = 10.0
self._major = 30.0
return
if units < 15.0:
self._minor = 15.0
self._major = 60.0
return
if units < 30.0:
self._minor = 30.0
self._major = 60.0
return
if units < 60.0: # 1 min
self._minor = 60.0
self._major = 300.0
return
if units < 300.0: # 5 min
self._minor = 300.0
self._major = 900.0
return
if units < 600.0: # 10 min
self._minor = 600.0
self._major = 1800.0
return
if units < 900.0: # 15 min
self._minor = 900.0
self._major = 3600.0
return
if units < 1800.0: # 30 min
self._minor = 1800.0
self._major = 3600.0
return
if units < 3600.0: # 1 hr
self._minor = 3600.0
self._major = 6*3600.0
return
if units < 6*3600.0: # 6 hrs
self._minor = 6*3600.0
self._major = 24*3600.0
return
if units < 24*3600.0: # 1 day
self._minor = 24*3600.0
self._major = 7*24*3600.0
return
self._minor = 24.0*7.0*3600.0 # 1 week
self._major = 24.0*7.0*3600.0
# Otherwise fall through to RealFormat
# (fractions of a second should be dealt with
# the same way as for RealFormat)
elif self._format == RealFormat:
d = 0.000001
self._digits = 6
while 1:
if units < d:
self._minor = d
self._major = d*5.0
return
d = d*5.0
if units < d:
self._minor = d
self._major = d*2.0
return
d = d*2.0
self._digits = self._digits - 1
def LabelString(self, d, major=None):
""" Used internally. """
# Given a value, turn it into a string according
# to the current ruler format. The number of digits of
# accuracy depends on the resolution of the ruler,
# i.e. how far zoomed in or out you are.
s = ""
if d < 0.0 and d + self._minor > 0.0:
d = 0.0
if self._format == IntFormat:
s = "%d"%int(math.floor(d+0.5))
elif self._format == LinearDBFormat:
if self._minor >= 1.0:
s = "%d"%int(math.floor(d+0.5))
else:
s = "%0.1f"%d
elif self._format == RealFormat:
if self._minor >= 1.0:
s = "%d"%int(math.floor(d+0.5))
else:
s = (("%." + str(self._digits) + "f")%d).strip()
elif self._format == TimeFormat:
if major:
if d < 0:
s = "-"
d = -d
if self.GetTimeFormat() == HHMMSS_Format:
secs = int(d + 0.5)
if self._minor >= 1.0:
s = ("%d:%02d:%02d")%(secs/3600, (secs/60)%60, secs%60)
else:
t1 = ("%d:%02d:")%(secs/3600, (secs/60)%60)
format = "%" + "%0d.%dlf"%(self._digits+3, self._digits)
t2 = format%(d%60.0)
s = s + t1 + t2
else:
if self._minor >= 3600.0:
hrs = int(d/3600.0 + 0.5)
h = "%d:00:00"%hrs
s = s + h
elif self._minor >= 60.0:
minutes = int(d/60.0 + 0.5)
if minutes >= 60:
m = "%d:%02d:00"%(minutes/60, minutes%60)
else:
m = "%d:00"%minutes
s = s + m
elif self._minor >= 1.0:
secs = int(d + 0.5)
if secs >= 3600:
t = "%d:%02d:%02d"%(secs/3600, (secs/60)%60, secs%60)
elif secs >= 60:
t = "%d:%02d"%(secs/60, secs%60)
else:
t = "%d"%secs
s = s + t
else:
secs = int(d)
if secs >= 3600:
t1 = "%d:%02d:"%(secs/3600, (secs/60)%60)
elif secs >= 60:
t1 = "%d:"%(secs/60)
if secs >= 60:
format = "%%0%d.%dlf"%(self._digits+3, self._digits)
else:
format = "%%%d.%dlf"%(self._digits+3, self._digits)
t2 = format%(d%60.0)
s = s + t1 + t2
if self._units != "":
s = s + " " + self._units
return s
def Tick(self, dc, pos, d, major):
"""
Ticks a particular position.
:param `dc`: an instance of `wx.DC`;
:param `pos`: the label position;
:param `d`: the current label value;
:param `major`: ``True`` if it is a major ticks, ``False`` if it is a minor one.
"""
if major:
label = Label()
self._majorlabels.append(label)
else:
label = Label()
self._minorlabels.append(label)
label.pos = pos
label.lx = self._left - 2000 # don't display
label.ly = self._top - 2000 # don't display
label.text = ""
dc.SetFont((major and [self._majorfont] or [self._minorfont])[0])
l = self.LabelString(d, major)
strw, strh = dc.GetTextExtent(l)
if self._orientation == wx.HORIZONTAL:
strlen = strw
strpos = pos - strw/2
if strpos < 0:
strpos = 0
if strpos + strw >= self._length:
strpos = self._length - strw
strleft = self._left + strpos
if self._flip:
strtop = self._top + 4
self._maxheight = max(self._maxheight, 4 + strh)
else:
strtop = self._bottom - strh - 6
self._maxheight = max(self._maxheight, strh + 6)
else:
strlen = strh
strpos = pos - strh/2
if strpos < 0:
strpos = 0
if strpos + strh >= self._length:
strpos = self._length - strh
strtop = self._top + strpos
if self._flip:
strleft = self._left + 5
self._maxwidth = max(self._maxwidth, 5 + strw)
else:
strleft = self._right - strw - 6
self._maxwidth = max(self._maxwidth, strw + 6)
# See if any of the pixels we need to draw this
# label is already covered
if major and self._labelmajor or not major and self._labelminor:
for ii in xrange(strlen):
if self._bits[strpos+ii]:
return
# If not, position the label and give it text
label.lx = strleft
label.ly = strtop
label.text = l
if major:
if self._tickmajor and not self._labelmajor:
label.text = ""
self._majorlabels[-1] = label
else:
if self._tickminor and not self._labelminor:
label.text = ""
label.text = label.text.replace(self._units, "")
self._minorlabels[-1] = label
# And mark these pixels, plus some surrounding
# ones (the spacing between labels), as covered
if (not major and self._labelminor) or (major and self._labelmajor):
leftmargin = self._spacing
if strpos < leftmargin:
leftmargin = strpos
strpos = strpos - leftmargin
strlen = strlen + leftmargin
rightmargin = self._spacing
if strpos + strlen > self._length - self._spacing:
rightmargin = self._length - strpos - strlen
strlen = strlen + rightmargin
for ii in xrange(strlen):
self._bits[strpos+ii] = 1
def Update(self, dc):
"""
Updates all the ticks calculations.
:param `dc`: an instance of `wx.DC`.
"""
# This gets called when something has been changed
# (i.e. we've been invalidated). Recompute all
# tick positions.
if self._orientation == wx.HORIZONTAL:
self._maxwidth = self._length
self._maxheight = 0
else:
self._maxwidth = 0
self._maxheight = self._length
self._bits = [0]*(self._length+1)
self._middlepos = []
if self._userbits:
for ii in xrange(self._length):
self._bits[ii] = self._userbits[ii]
else:
for ii in xrange(self._length):
self._bits[ii] = 0
if not self._log:
UPP = (self._max - self._min)/float(self._length) # Units per pixel
self.FindLinearTickSizes(UPP)
# Left and Right Edges
if self._labeledges:
self.Tick(dc, 0, self._min, True)
self.Tick(dc, self._length, self._max, True)
# Zero (if it's in the middle somewhere)
if self._min*self._max < 0.0:
mid = int(self._length*(self._min/(self._min-self._max)) + 0.5)
self.Tick(dc, mid, 0.0, True)
sg = ((UPP > 0.0) and [1.0] or [-1.0])[0]
# Major ticks
d = self._min - UPP/2
lastd = d
majorint = int(math.floor(sg*d/self._major))
ii = -1
while ii <= self._length:
ii = ii + 1
lastd = d
d = d + UPP
if int(math.floor(sg*d/self._major)) > majorint:
majorint = int(math.floor(sg*d/self._major))
self.Tick(dc, ii, sg*majorint*self._major, True)
# Minor ticks
d = self._min - UPP/2
lastd = d
minorint = int(math.floor(sg*d/self._minor))
ii = -1
while ii <= self._length:
ii = ii + 1
lastd = d
d = d + UPP
if int(math.floor(sg*d/self._minor)) > minorint:
minorint = int(math.floor(sg*d/self._minor))
self.Tick(dc, ii, sg*minorint*self._minor, False)
# Left and Right Edges
if self._labeledges:
self.Tick(dc, 0, self._min, True)
self.Tick(dc, self._length, self._max, True)
else:
# log case
lolog = math.log10(self._min)
hilog = math.log10(self._max)
scale = self._length/(hilog - lolog)
lodecade = int(math.floor(lolog))
hidecade = int(math.ceil(hilog))
# Left and Right Edges
if self._labeledges:
self.Tick(dc, 0, self._min, True)
self.Tick(dc, self._length, self._max, True)
startdecade = 10.0**lodecade
# Major ticks are the decades
decade = startdecade
for ii in xrange(lodecade, hidecade):
if ii != lodecade:
val = decade
if val > self._min and val < self._max:
pos = int(((math.log10(val) - lolog)*scale)+0.5)
self.Tick(dc, pos, val, True)
decade = decade*10.0
# Minor ticks are multiples of decades
decade = startdecade
for ii in xrange(lodecade, hidecade):
for jj in xrange(2, 10):
val = decade*jj
if val >= self._min and val < self._max:
pos = int(((math.log10(val) - lolog)*scale)+0.5)
self.Tick(dc, pos, val, False)
decade = decade*10.0
self._valid = True
def Draw(self, dc):
"""
Actually draws the whole L{RulerCtrl}.
:param `dc`: an instance of `wx.DC`.
"""
if not self._valid:
self.Update(dc)
dc.SetBrush(wx.Brush(self._background))
dc.SetPen(self._tickpen)
dc.SetTextForeground(self._textcolour)
dc.DrawRectangleRect(self.GetClientRect())
if self._orientation == wx.HORIZONTAL:
if self._flip:
dc.DrawLine(self._left, self._top, self._right+1, self._top)
else:
dc.DrawLine(self._left, self._bottom-1, self._right+1, self._bottom-1)
else:
if self._flip:
dc.DrawLine(self._left, self._top, self._left, self._bottom+1)
else:
dc.DrawLine(self._right-1, self._top, self._right-1, self._bottom+1)
dc.SetFont(self._majorfont)
for label in self._majorlabels:
pos = label.pos
if self._orientation == wx.HORIZONTAL:
if self._flip:
dc.DrawLine(self._left + pos, self._top,
self._left + pos, self._top + 5)
else:
dc.DrawLine(self._left + pos, self._bottom - 5,
self._left + pos, self._bottom)
else:
if self._flip:
dc.DrawLine(self._left, self._top + pos,
self._left + 5, self._top + pos)
else:
dc.DrawLine(self._right - 5, self._top + pos,
self._right, self._top + pos)
if label.text != "":
dc.DrawText(label.text, label.lx, label.ly)
dc.SetFont(self._minorfont)
for label in self._minorlabels:
pos = label.pos
if self._orientation == wx.HORIZONTAL:
if self._flip:
dc.DrawLine(self._left + pos, self._top,
self._left + pos, self._top + 3)
else:
dc.DrawLine(self._left + pos, self._bottom - 3,
self._left + pos, self._bottom)
else:
if self._flip:
dc.DrawLine(self._left, self._top + pos,
self._left + 3, self._top + pos)
else:
dc.DrawLine(self._right - 3, self._top + pos,
self._right, self._top + pos)
if label.text != "":
dc.DrawText(label.text, label.lx, label.ly)
for indicator in self._indicators:
indicator.Draw(dc)
def SetDrawingParent(self, dparent):
"""
Sets the window to which L{RulerCtrl} draws a thin line over.
:param `dparent`: an instance of `wx.Window`, representing the window to
which L{RulerCtrl} draws a thin line over.
"""
self._drawingparent = dparent
def GetDrawingParent(self):
""" Returns the window to which L{RulerCtrl} draws a thin line over. """
return self._drawingparent
def DrawOnParent(self, indicator):
"""
Actually draws the thin line over the drawing parent window.
:param `indicator`: the current indicator, an instance of L{Indicator}.
"""
if not self._drawingparent:
return
xpos, ypos = indicator.GetPosition()
parentrect = self._drawingparent.GetClientRect()
dc = wx.ScreenDC()
dc.SetLogicalFunction(wx.INVERT)
dc.SetPen(self._drawingpen)
dc.SetBrush(wx.TRANSPARENT_BRUSH)
imgx, imgy = indicator.GetImageSize()
if self._orientation == wx.HORIZONTAL:
x1 = xpos+ imgx/2
y1 = parentrect.y
x2 = x1
y2 = parentrect.height
x1, y1 = self._drawingparent.ClientToScreenXY(x1, y1)
x2, y2 = self._drawingparent.ClientToScreenXY(x2, y2)
elif self._orientation == wx.VERTICAL:
x1 = parentrect.x
y1 = ypos + imgy/2
x2 = parentrect.width
y2 = y1
x1, y1 = self._drawingparent.ClientToScreenXY(x1, y1)
x2, y2 = self._drawingparent.ClientToScreenXY(x2, y2)
dc.DrawLine(x1, y1, x2, y2)
dc.SetLogicalFunction(wx.COPY)
|