This commit was manufactured by cvs2svn to create tag 'M_STABLE'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/M_STABLE@40387 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/wx/lib/analogclock.py

@@ -0,0 +1,808 @@
+# -*- coding: iso-8859-1 -*-
+#----------------------------------------------------------------------
+# Name:        wx.lib.analogclock
+# Purpose:     A simple analog clock window
+#
+# Author:      several folks on wxPython-users
+#
+# Created:     16-April-2003
+# RCS-ID:      $Id$
+# Copyright:   (c) 2003 by Total Control Software
+# Licence:     wxWindows license
+#----------------------------------------------------------------------
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+# o Tested with updated demo and with builtin test.
+# 
+# 15-February-2004 - E. A. Tacao
+#
+# o Many ehnacements
+#
+
+
+import math
+import sys
+import string
+import time
+
+import wx
+
+from analogclockopts import ACCustomizationFrame
+
+
+# self.clockStyle:
+SHOW_QUARTERS_TICKS = 1
+SHOW_HOURS_TICKS    = 2
+SHOW_MINUTES_TICKS  = 4
+ROTATE_TICKS        = 8
+SHOW_HOURS_HAND     = 16
+SHOW_MINUTES_HAND   = 32
+SHOW_SECONDS_HAND   = 64
+SHOW_SHADOWS        = 128
+OVERLAP_TICKS       = 256
+
+# self.tickMarkHoursStyle and self.tickMarkMinutesStyle:
+TICKS_NONE          = 1
+TICKS_SQUARE        = 2
+TICKS_CIRCLE        = 4
+TICKS_POLY          = 8
+TICKS_DECIMAL       = 16
+TICKS_ROMAN         = 32
+
+
+class AnalogClockWindow(wx.PyWindow):
+    """An analog clock window"""
+
+    def __init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
+                 style=0, name="clock"):
+        
+        # Initialize the wxWindow...
+        wx.PyWindow.__init__(self, parent, ID, pos, size, style, name)
+
+        # Initialize some variables and defaults...
+        self.clockStep = 1
+        self.prefs_open = False
+
+        self.tickShapeHours = self.tickShapeMinutes= [[0,0],
+                                                      [1,-1],
+                                                      [2,0],
+                                                      [1,4]]
+        self.handHoursThickness = 5
+        self.handHoursColour = (0, 0, 0)
+
+        self.handMinutesThickness = 3
+        self.handMinutesColour = (0, 0, 0)
+
+        self.handSecondsThickness = 1
+        self.handSecondsColour = (0, 0, 0)
+
+        self.tickMarkHoursPen = wx.Pen((0, 0, 0), 1, wx.SOLID)
+        self.tickMarkHoursBrush = wx.Brush((0, 0, 0), wx.SOLID)
+        self.markSizeHour = 10
+        self.tickMarkHoursFont = wx.Font(0, wx.SWISS, wx.NORMAL, wx.BOLD)
+        self.tickMarkHoursFont.SetPointSize(self.markSizeHour)
+
+        self.tickMarkMinutesPen = wx.Pen((0, 0, 0), 1, wx.SOLID)
+        self.tickMarkMinutesBrush = wx.Brush((0, 0, 0), wx.SOLID)
+        self.markSizeMin = 6
+        self.tickMarkMinutesFont = wx.Font(self.markSizeMin, wx.SWISS, wx.NORMAL, wx.BOLD)
+
+        self.offM = 0
+
+        self.shadowPenColour = self.shadowBrushColour = (128,128,128)
+
+        self.watchPen = None
+        self.watchBrush = None
+
+        self.clockStyle = SHOW_HOURS_TICKS | SHOW_MINUTES_TICKS | SHOW_SHADOWS | ROTATE_TICKS
+        self.handsStyle = SHOW_SECONDS_HAND
+
+        self.tickMarkHoursStyle = TICKS_POLY
+        self.tickMarkMinutesStyle = TICKS_CIRCLE
+
+        self.currentTime=None
+
+        size = wx.Size(*size)
+        bestSize = self.GetBestSize()
+        size.x = max(size.x, bestSize.x)
+        size.y = max(size.y, bestSize.y)
+        self.SetSize(size)
+        
+        # Make an initial bitmap for the face, it will be updated and
+        # painted at the first EVT_SIZE event.
+        W, H = size
+        self.faceBitmap = wx.EmptyBitmap(max(W,1), max(H,1))
+        
+        # Set event handlers...
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x: None)
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.Bind(wx.EVT_TIMER, self.OnTimerExpire)
+        self.Bind(wx.EVT_WINDOW_DESTROY, self.OnQuit)
+        self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
+        self.Bind(wx.EVT_RIGHT_UP, self.OnRightClick)         
+
+        # Initialize the timer that drives the update of the clock
+        # face.  Update every half second to ensure that there is at
+        # least one true update during each realtime second.
+        self.timer = wx.Timer(self)
+        self.timer.Start(500)
+
+
+    def DoGetBestSize(self):
+        return wx.Size(25,25)
+
+
+    def OnPaint(self, event):
+        dc = wx.BufferedPaintDC(self)
+        self._doDrawHands(dc, True)
+
+
+    def OnTimerExpire(self, event):
+        size = self.GetClientSize()
+        dc = wx.BufferedDC(wx.ClientDC(self), size)
+        self._doDrawHands(dc, True)
+
+
+    def OnQuit(self, event):
+        self.timer.Stop()
+        del self.timer
+
+        
+    def OnRightDown(self, event):
+        self.x = event.GetX()
+        self.y = event.GetY()
+        event.Skip()
+
+
+    def OnRightClick(self, event):
+        # only do this part the first time so the events are only bound once
+        if not hasattr(self, "popupID1"):
+            self.popupID1 = wx.NewId()
+            self.popupID2 = wx.NewId()
+            self.Bind(wx.EVT_MENU, self.OnPopupOne, id=self.popupID1)
+            self.Bind(wx.EVT_MENU, self.OnPopupTwo, id=self.popupID2)
+
+        # make a menu
+        sm = wx.Menu()
+
+        sm.Append(self.popupID1, "Customize...")
+        sm.Append(self.popupID2, "About...")
+
+        # If there already a setup window open, we must not appear...
+        if not self.prefs_open:
+            # Popup the menu.  If an item is selected then its handler
+            # will be called before PopupMenu returns.
+            self.PopupMenu(sm, (self.x,self.y))
+        sm.Destroy()
+
+
+    def OnPopupOne(self, event):
+        self.prefs_open=True
+        frame = ACCustomizationFrame(self, -1, "AnalogClock Preferences")
+        frame.Show(True)
+
+
+    def OnPopupTwo(self, event):
+        dlg = wx.MessageDialog(self, "AnalogClockWindow\n\nby Several folks on wxPython-users\nwith enhancements from E. A. Tac<61>o",
+                          'About', wx.OK | wx.ICON_INFORMATION)
+        dlg.ShowModal()
+        dlg.Destroy()
+
+
+    def OnSize(self, event):
+        # The faceBitmap init is done here, to make sure the buffer is always
+        # the same size as the Window
+        size  = self.GetClientSize()
+        if size.x < 1 or size.y < 1:
+            return
+        
+        self.faceBitmap = wx.EmptyBitmap(size.width, size.height)
+
+        # Update drawing coordinates...
+        new_dim = size.Get()
+        if not hasattr(self,"dim"):
+            self.dim = new_dim
+
+        x,y=[0,1]
+        self.scale = min([float(new_dim[x]) / self.dim[x],
+                          float(new_dim[y]) / self.dim[y]])
+
+        self.centerX = self.faceBitmap.GetWidth() / 2
+        self.centerY = self.faceBitmap.GetHeight() / 2
+
+        self.shadowDistance = 2 * self.scale
+
+        self.radius_watch = min(self.centerX, self.centerY)
+
+        self._doDrawFace()
+        
+
+
+    def _doDrawHands(self, drawDC, force=0):
+        currentTime = list(time.localtime(time.time())[3:6])
+
+        if not (self.handsStyle & SHOW_SECONDS_HAND):
+            currentTime[2]=-1
+
+        if not (force or currentTime != self.currentTime):
+            return
+        self.currentTime = currentTime
+        hour, minutes, seconds = currentTime
+
+        # Start by drawing the face bitmap
+        drawDC.DrawBitmap(self.faceBitmap, 0,0)
+
+
+        # NOTE:  All this hand drawing code below should be refactored into a helper function.
+
+        
+        # Draw hours hand shadow
+        mStep = 6 * self.clockStep
+        angle = hour * 30
+        if angle > 360:
+            angle = angle - 360
+        angle = angle + round(minutes/(mStep*2)) * mStep
+
+        x,y,f = self._getCoords("hand_hours", angle)
+
+        if f and self.clockStyle & SHOW_SHADOWS:
+            drawDC.SetPen(wx.Pen(self.shadowPenColour,
+                                 int(self.handHoursThickness * self.scale),
+                                 wx.SOLID))
+            drawDC.DrawLine(self.centerX + self.shadowDistance,
+                            self.centerY + self.shadowDistance,
+                            x + self.shadowDistance,
+                            y + self.shadowDistance)
+
+        # Draw minutes hand shadow
+        angle = minutes * 6
+        x,y,f = self._getCoords("hand_minutes", angle)
+
+        if f and self.clockStyle & SHOW_SHADOWS:
+            drawDC.SetPen(wx.Pen(self.shadowPenColour,
+                                 int(self.handMinutesThickness * self.scale),
+                                 wx.SOLID))
+            drawDC.DrawLine(self.centerX + self.shadowDistance,
+                            self.centerY + self.shadowDistance,
+                            x + self.shadowDistance,
+                            y + self.shadowDistance)
+
+        # Draw seconds hand shadow if required
+        if seconds >= 0:
+            angle = seconds * 6
+            x,y,f = self._getCoords("hand_seconds", angle)
+            
+            if f and self.clockStyle & SHOW_SHADOWS:
+                drawDC.SetPen(wx.Pen(self.shadowPenColour,
+                                     int(self.handSecondsThickness * self.scale),
+                                     wx.SOLID))
+                drawDC.DrawLine(self.centerX + self.shadowDistance,
+                                self.centerY + self.shadowDistance,
+                                x + self.shadowDistance,
+                                y + self.shadowDistance)
+
+
+        # Draw hours hand
+        angle = hour * 30
+        if angle > 360:
+            angle = angle - 360
+        angle = angle + round(minutes/(mStep*2)) * mStep
+        
+        x,y,f = self._getCoords("hand_hours", angle)
+
+        if f:
+            drawDC.SetPen(wx.Pen(self.handHoursColour,
+                                 int(self.handHoursThickness * self.scale),
+                                 wx.SOLID))
+            drawDC.DrawLine(self.centerX, self.centerY, x, y)
+
+        # Draw minutes hand
+        angle = minutes * 6
+        x,y,f = self._getCoords("hand_minutes", angle)
+
+        if f:
+            drawDC.SetPen(wx.Pen(self.handMinutesColour,
+                                 int(self.handMinutesThickness * self.scale),
+                                 wx.SOLID))
+            drawDC.DrawLine(self.centerX, self.centerY, x, y)
+
+        # Draw seconds hand if required
+        if seconds >= 0:
+            angle = seconds * 6
+            x,y,f = self._getCoords("hand_seconds", angle)
+            if f:
+                drawDC.SetPen(wx.Pen(self.handSecondsColour,
+                                     int(self.handSecondsThickness * self.scale),
+                                     wx.SOLID))
+                drawDC.DrawLine(self.centerX, self.centerY, x, y)
+
+
+
+    def _doDrawFace(self):
+        backgroundBrush = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
+        drawDC = wx.MemoryDC()
+        drawDC.SelectObject(self.faceBitmap)
+        drawDC.SetBackground(backgroundBrush)
+        drawDC.Clear()
+
+        self.handHoursLength = 0.65 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
+        self.handMinutesLength = 0.85 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
+        self.handSecondsLength = 0.85 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
+
+        self.radius_ticks_hours = self.radius_watch - self.shadowDistance - self._getMarkMaxSize("ticks_hours", drawDC)
+        self.radius_ticks_minutes = self.radius_ticks_hours
+        
+        self._calcSteps()
+
+        # Draw the watch...
+        self._drawWatch(drawDC)
+
+        # Draw the marks for hours and minutes...
+        circle = 360
+        mStep = 6 * self.clockStep
+
+        if self.clockStyle & SHOW_SHADOWS:
+            for i in range(0, circle, mStep):
+                for t in self.coords.keys():
+                    if t.find("ticks") > -1:
+                        x,y,f = self._getCoords(t, i)
+                        if f:
+                            self._doDrawTickMark(i, drawDC, t,
+                                                 x + self.shadowDistance,
+                                                 y + self.shadowDistance,
+                                                 True)
+
+        for i in range(0, circle, mStep):
+            for t in self.coords.keys():
+                if t.find("ticks") > -1:
+                    x,y,f = self._getCoords(t, i)
+                    if f:
+                        self._doDrawTickMark(i, drawDC, t, x, y)
+
+
+
+    def _doDrawTickMark(self, angle, drawDC, tipo, x, y, is_a_shadow=None):
+        opts = {"ticks_hours":    [self.tickMarkHoursPen, self.tickMarkHoursBrush, self.markSizeHour, self.tickMarkHoursStyle],
+                "ticks_quarters": [self.tickMarkHoursPen, self.tickMarkHoursBrush, self.markSizeHour, self.tickMarkHoursStyle],
+                "ticks_minutes":  [self.tickMarkMinutesPen, self.tickMarkMinutesBrush, self.markSizeMin, self.tickMarkMinutesStyle]}
+
+        pen, brush, size, style = opts[tipo];
+        size = size * self.scale
+
+        if is_a_shadow:
+            drawDC.SetPen(wx.Pen(self.shadowPenColour, 1, wx.SOLID))
+            drawDC.SetBrush(wx.Brush(self.shadowBrushColour, wx.SOLID))
+            drawDC.SetTextForeground(self.shadowBrushColour)
+        else:
+            drawDC.SetPen(pen)
+            drawDC.SetBrush(brush)
+            drawDC.SetTextForeground(brush.GetColour())
+
+        if style & TICKS_CIRCLE:
+            x, y = self._center2corner(x, y, tipo)
+            drawDC.DrawEllipse(x, y, size, size)
+
+        elif style & TICKS_SQUARE:
+            x, y = self._center2corner(x, y, tipo)
+            drawDC.DrawRectangle(x, y, size, size)
+
+        elif (style & TICKS_DECIMAL) or (style & TICKS_ROMAN):
+            self._draw_rotate_text(drawDC, x, y, tipo, angle)
+
+        elif style & TICKS_POLY:
+             self._draw_rotate_polygon(drawDC, x, y, tipo, angle)
+
+
+    def _draw_rotate_text(self, drawDC, x, y, tipo, angle):
+        text = self._build_text(angle, tipo)
+        lX, lY = self._center2corner(x, y, tipo, drawDC)
+        lX = lX * len(text)
+        angle = 360 - angle
+
+        if self.clockStyle & ROTATE_TICKS:
+            radiansPerDegree = math.pi / 180
+            x = int(x - 
+                    ((math.cos((angle) * radiansPerDegree)*lX) + 
+                     (math.sin((angle) * radiansPerDegree)*lY)))
+            y = int(y - 
+                    ((math.cos((angle) * radiansPerDegree)*lY) - 
+                     (math.sin((angle) * radiansPerDegree)*lX)))
+            drawDC.DrawRotatedText(text, x,y, angle)
+
+        else:
+            x = x - lX
+            y = y - lY
+            drawDC.DrawText(text, x, y)
+
+
+    def _draw_rotate_polygon(self, drawDC, x, y, tipo, angle):
+        if tipo=="ticks_quarters":
+            tipo="ticks_hours"
+            
+        # Add to empty list to prevent system-wide hard freezes under XP...
+        points = {"ticks_hours":self.tickShapeHours+[], "ticks_minutes":self.tickShapeMinutes+[]}[tipo]
+        size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
+
+        maxX = max(map(lambda x:x[0],points))
+        minX = min(map(lambda x:x[0],points))
+        maxY = max(map(lambda x:x[0],points))
+        minY = min(map(lambda x:x[0],points))
+
+        maxB = abs(max(maxX, maxY));
+        f = size / maxB
+
+        orgX = (maxX - minX) / 2.
+        orgY = (maxY - minY) / 2.
+
+        radiansPerDegree = math.pi / 180
+        scaledX = x
+        scaledY = y
+
+        for z in range(0, len(points)):
+            x,y = points[z]
+            x = x * f - orgX * f
+            y = y * f - orgY * f
+            if self.clockStyle & ROTATE_TICKS:
+                m,t = self._rect2pol(x,y)
+                t = t + angle
+                x,y = self._pol2rect(m,t)
+            x = x + scaledX
+            y = y + scaledY
+            points[z] = [int(x), int(y)]
+
+        drawDC.DrawPolygon(points)
+
+
+    def _pol2rect(self, r, w, deg=1):		# radian if deg=0; degree if deg=1
+        if deg:
+    	     w = math.pi * w / 180.0
+        return r * math.cos(w), r * math.sin(w)
+
+
+    def _rect2pol(self, x, y, deg=1):		# radian if deg=0; degree if deg=1
+        if deg:
+    	    return math.hypot(x, y), 180.0 * math.atan2(y, x) / math.pi
+        else:
+    	    return math.hypot(x, y), math.atan2(y, x)
+
+
+    def _center2corner(self, x, y, tipo, drawDC=None):
+        if tipo == "ticks_quarters":
+            tipo = "ticks_hours"
+
+        style = {"ticks_hours":self.tickMarkHoursStyle, "ticks_minutes":self.tickMarkMinutesStyle}[tipo]
+        size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
+
+        if style & TICKS_DECIMAL or style & TICKS_ROMAN:
+            font = {"ticks_hours":self.tickMarkHoursFont, "ticks_minutes":self.tickMarkMinutesFont}[tipo]
+            font.SetPointSize(int(size));
+            drawDC.SetFont(font)
+            lX = drawDC.GetCharWidth() / 2.
+            lY = drawDC.GetCharHeight() / 2.
+            x = lX
+            y = lY
+        else:
+            size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
+            x=x-size/2.;y=y-size/2.
+        return x, y
+
+
+    def _build_text(self, angle, tipo):
+        if tipo == "ticks_quarters":
+            tipo = "ticks_hours"
+        a = angle
+        if a <= 0:
+            a = a + 360
+        divider = {"ticks_hours":30,"ticks_minutes":6}[tipo]
+        a = int(a / divider)
+
+        style = {"ticks_hours":self.tickMarkHoursStyle," ticks_minutes":self.tickMarkMinutesStyle}[tipo]
+        if style & TICKS_ROMAN:
+            text=["I","II","III","IV","V","VI","VII","VIII","IX","X", \
+                  "XI","XII","XIII","XIV","XV","XVI","XVII","XVIII","XIX","XX", \
+                  "XXI","XXII","XXIII","XXIV","XXV","XXVI","XXVII","XXVIII","XXIX","XXX", \
+                  "XXXI","XXXII","XXXIII","XXXIV","XXXV","XXXVI","XXXVII","XXXVIII","XXXIX","XL", \
+                  "XLI","XLII","XLIII","XLIV","XLV","XLVI","XLVII","XLVIII","XLIX","L", \
+                  "LI","LII","LIII","LIV","LV","LVI","LVII","LVIII","LIX","LX"][a-1]
+        else:
+            text = "%s" % a
+
+        return text
+
+
+    def _getMarkMaxSize(self, tipo, drawDC=None):
+        if tipo == "ticks_quarters":
+            tipo = "ticks_hours"
+
+        style = {"ticks_hours":self.tickMarkHoursStyle, "ticks_minutes":self.tickMarkMinutesStyle}[tipo]
+        size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
+
+        if style & TICKS_DECIMAL or style & TICKS_ROMAN:
+            lX = 2 * drawDC.GetCharWidth()
+            lY = drawDC.GetCharHeight()
+            size = math.sqrt(lX**2 + lY**2) * self.scale
+        else:
+            size=math.sqrt(2) * size
+
+        return size
+
+
+    def _drawWatch(self, drawDC):
+        # Draw the watch...
+        if self.watchPen or self.watchBrush:
+            if self.watchPen:
+                drawDC.SetPen(self.watchPen)
+            if self.watchBrush:
+                drawDC.SetBrush(self.watchBrush)
+            else:
+                drawDC.SetBrush(wx.Brush(self.GetBackgroundColour(), wx.SOLID))
+            drawDC.DrawCircle(self.centerX, self.centerY, self.radius_watch)
+
+
+    def _calcSteps(self):
+        # Calcule todos os pontos para:
+        #  - marcas de horas
+        #  - marcas de minutos
+        #  - ponteiro de horas
+        #  - ponteiro de minutos
+        #  - ponteiro de segundos
+
+        circle = 360
+        mStep = 6 * self.clockStep # Step in degrees...
+
+        vq = 90 * (self.clockStyle & SHOW_QUARTERS_TICKS) / SHOW_QUARTERS_TICKS
+        vh = 30 * (self.clockStyle & SHOW_HOURS_TICKS) / SHOW_HOURS_TICKS
+        vm = 1  * (self.clockStyle & SHOW_MINUTES_TICKS) / SHOW_MINUTES_TICKS
+
+        coords = {"ticks_quarters": [self.radius_ticks_hours,  60,vq,{}],
+                  "ticks_hours":    [self.radius_ticks_hours,  60,vh,{}],
+                  "ticks_minutes":  [self.radius_ticks_minutes,60,vm,{}],
+                  "hand_hours":     [self.handHoursLength,     60,1, {}],
+                  "hand_minutes":   [self.handMinutesLength,   60,1, {}],
+                  "hand_seconds":   [self.handSecondsLength,   60,1, {}]}
+
+        radiansPerDegree = math.pi / 180
+
+        for t in coords.keys():
+            for i in range(0, circle+mStep, mStep):
+                radius = coords[t][0]
+                if t == "ticks_minutes":
+                    radius = radius - self.offM
+                step_angle = 360. / coords[t][1]
+                pre = coords[t][2]
+                x = self.centerX + radius * math.sin(i * radiansPerDegree)
+                y = self.centerY + radius * math.cos(i * radiansPerDegree)
+                f = (pre and (i/step_angle == int(i/step_angle)) and (float(i)/pre == int(i/pre)))
+                coords[t][3][i] = [x,y,f]
+
+        if not self.clockStyle & OVERLAP_TICKS:
+            for i in range(0, circle + mStep, mStep):
+                f=coords["ticks_minutes"][3][i][2]
+                if f and \
+                   (coords["ticks_hours"][3].get(i,[0,0,0])[2] or coords["ticks_quarters"][3].get(i,[0,0,0])[2]):
+                    f=False
+                coords["ticks_minutes"][3][i][2]=f
+
+        self.coords = coords
+
+
+    def _getCoords(self, tipo, angle):
+        # Returns coords and 'use flag' based on current angle...
+        k = 360 - (angle + 180)
+        if k <= 0:
+            k = k + 360
+        return self.coords[tipo][3][k]
+
+
+# -----------------------------------------------------
+#
+    def SetTickShapes(self, tsh, tsm=None):
+        """
+        tsh, tsm: [[x0,y0], [x1,y1], ... [xn,yn]]
+
+        Sets lists of lists of points to be used as polygon shapes
+        when using the TICKS_POLY style. If tsm is ommitted,
+        we'll use tsh for both shapes.
+        """
+
+        if not tsm:
+            tsm=tsh
+
+        self.tickShapeHours = tsh
+        self.tickShapeMinutes = tsm
+
+
+    def SetHandWeights(self, h=None, m=None, s=None):
+        """
+        h, m, s: value
+
+        Sets thickness of hands.
+        """
+
+        if h:
+           self.handHoursThickness = h
+        if m:
+           self.handMinutesThickness = m
+        if s:
+           self.handSecondsThickness = s
+
+
+    def SetHandColours(self, h=None, m=None, s=None):
+        """
+        h, m, s: wx.Colour
+
+        Sets colours of hands. If m and s are ommitted,
+        we'll use h for all.
+        """
+
+        if h and not m and not s:
+            m=h
+            s=h
+
+        if h:
+            self.handHoursColour = h
+        if m:
+            self.handMinutesColour = m
+        if s:
+            self.handSecondsColour = s
+
+
+    def SetTickColours(self, h=None, m=None):
+        """
+        h, m: wx.Colour
+
+        Sets colours of ticks. If m is ommitted,
+        we'll use h for both.
+        """
+
+        if not m:
+            m=h
+
+        if h:
+            self.tickMarkHoursPen = wx.Pen(h, 1, wx.SOLID)
+            self.tickMarkHoursBrush = wx.Brush(h, wx.SOLID)
+
+        if m:
+           self.tickMarkMinutesPen = wx.Pen(m, 1, wx.SOLID)
+           self.tickMarkMinutesBrush = wx.Brush(m, wx.SOLID)
+
+
+    def SetTickSizes(self, h=None, m=None):
+        """
+        h, m: value
+
+        Sizes for tick marks.
+        """
+
+        if h:
+            self.markSizeHour = h
+        if m:
+            self.markSizeMin = m
+
+
+    def SetTickFonts(self, h=None, m=None):
+        """
+        h, m: wx.Font
+
+        Fonts for tick marks when using TICKS_DECIMAL or TICKS_ROMAN style.
+        If m is ommitted, we'll use h for both.
+        """
+
+        if not m:
+            m=h
+
+        if h:
+            self.tickMarkHoursFont = h
+            self.tickMarkHoursFont.SetPointSize(self.markSizeHour)
+        if m:
+            self.tickMarkMinutesFont = m
+            self.tickMarkMinutesFont.SetPointSize(self.markSizeMin)
+
+
+    def SetMinutesOffset(self, o):
+        """
+        s = value
+
+        Sets the distance between tick marks for hours and minutes.
+        """
+        self.offM = o
+
+
+    def SetShadowColour(self, s):
+        """
+        s = wx.Colour or (r,g,b) tuple.
+
+        Sets the colour to be used to draw shadows.
+        """
+
+        self.shadowPenColour = self.shadowBrushColour = s
+
+
+    def SetWatchPenBrush(self, p=None, b=None):
+        """
+        p = wx.Pen; b = wx.Brush
+
+        Set the pen and brush for the watch.
+        """
+
+        if p:
+            self.watchPen = p
+        if b:
+            self.watchBrush = b
+
+
+    def SetClockStyle(self, style):
+        """
+        Set the clock style, acording to these options:
+
+            ====================  ================================
+            SHOW_QUARTERS_TICKS   Show marks for hours 3, 6, 9, 12
+            SHOW_HOURS_TICKS      Show marks for all hours
+            SHOW_MINUTES_TICKS    Show marks for minutes
+
+            SHOW_HOURS_HAND       Show hours hand
+            SHOW_MINUTES_HAND     Show minutes hand
+            SHOW_SECONDS_HAND     Show seconds hand
+
+            SHOW_SHADOWS          Show hands and marks shadows
+
+            ROTATE_TICKS          Align tick marks to watch
+            OVERLAP_TICKS         Draw tick marks for minutes even
+                                  when they match the hours marks.
+            ====================  ================================
+        """
+
+        self.clockStyle = style
+
+
+    def SetTickStyles(self, h=None, m=None):
+        """
+        Set the ticks styles, acording to the options below.
+
+            =================   =====================================
+            TICKS_NONE          Don't show tick marks.
+            TICKS_SQUARE        Use squares as tick marks.
+            TICKS_CIRCLE        Use circles as tick marks.
+            TICKS_POLY          Use a polygon as tick marks. The
+                                polygon must be passed using
+                                SetTickShapes, otherwise the default
+                                polygon will be used.
+            TICKS_DECIMAL       Use decimal numbers.
+            TICKS_ROMAN         Use Roman numbers.
+            =================   =====================================
+        """
+
+        if h:
+            self.tickMarkHoursStyle = h
+        if m:
+            self.tickMarkMinutesStyle = m
+#
+# -----------------------------------------------------
+
+
+if __name__ == "__main__":
+    print wx.VERSION_STRING
+    class App(wx.App):
+        def OnInit(self):
+            frame = wx.Frame(None, -1, "AnalogClockWindow", size=(375,375))
+
+            clock = AnalogClockWindow(frame)
+            
+            # Settings below are used by default...
+            #clock.SetClockStyle(SHOW_HOURS_TICKS|SHOW_MINUTES_TICKS|SHOW_SHADOWS|ROTATE_TICKS)
+            #clock.SetTickStyles(TICKS_POLY, TICKS_CIRCLE)
+
+            frame.Centre(wx.BOTH)
+            frame.Show(True)
+            self.SetTopWindow(frame)
+            return True
+
+    theApp = App(0)
+    theApp.MainLoop()
+
+
+#
+##
+### eof

wxPython/wx/lib/analogclockopts.py

@@ -0,0 +1,497 @@
+#----------------------------------------------------------------------
+# Name:        wx.lib.aanalogclockopts
+# Purpose:     An analog clock window - setup frame
+#
+# Author:      E. A. Tacao
+#
+# Created:     15-February-2004
+#----------------------------------------------------------------------
+
+# Originally generated by wx.Glade 0.3.1 on Wed Feb 18 00:05:35 2004
+# Converted to wx namespace by Peter Damoc
+
+
+import wx
+import wx.lib.colourselect as  csel
+import wx.lib.dialogs as  dlgs
+import string
+
+class ACCustomizationFrame(wx.Frame):
+    def __init__(self, parent, id, name, pos=wx.DefaultPosition, size=wx.DefaultSize,
+                 style=wx.DEFAULT_FRAME_STYLE | wx.FRAME_NO_TASKBAR | wx.FRAME_FLOAT_ON_PARENT | wx.WANTS_CHARS):
+        #  k=wx.NewId();ide=map(lambda x: x+k, range(0,100))
+        ide = [wx.NewId() for i in range(100)]
+
+        #kwds["style"] = wx.CAPTION|wx.SYSTEM_MENU
+        #wx.Frame.__init__(self, *args, **kwds)
+        wx.Frame.__init__(self, parent, id, name, pos, size, style)
+        self.parent=parent
+        self.panel_1 = wx.Panel(self, -1)
+        self.notebook_1 = wx.Notebook(self.panel_1, -1, style=0)
+        self.notebook_1_pane_3 = wx.Panel(self.notebook_1, -1)
+        self.notebook_1_pane_2 = wx.Panel(self.notebook_1, -1)
+        self.notebook_1_pane_1 = wx.Panel(self.notebook_1, -1)
+        self.label_top = wx.StaticText(self.panel_1, -1, "Use the options below to change the clock;\nthe main buttons on top of each category reset to its defaults.")
+        self.static_line_1 = wx.StaticLine(self.panel_1, -1)
+        self.button_1 = wx.Button(self.notebook_1_pane_1, ide[1], "SetClockStyle")
+        self.static_line_2 = wx.StaticLine(self.notebook_1_pane_1, -1)
+        self.button_2 = wx.Button(self.notebook_1_pane_1, ide[3], "styles...")
+        self.static_line_3 = wx.StaticLine(self.notebook_1_pane_1, -1, style=wx.LI_VERTICAL)
+        self.button_3 = wx.Button(self.notebook_1_pane_1, ide[2], "SetTickStyles")
+        self.static_line_4 = wx.StaticLine(self.notebook_1_pane_1, -1)
+        self.button_4 = wx.Button(self.notebook_1_pane_1, ide[4], "styles...")
+        self.button_22 = wx.Button(self.notebook_1_pane_1, ide[22], "minutes...")
+        self.static_line_5 = wx.StaticLine(self.notebook_1_pane_1, -1)
+        self.button_5 = wx.Button(self.notebook_1_pane_1, ide[5], "SetShadowColour")
+        self.static_line_6 = wx.StaticLine(self.notebook_1_pane_1, -1)
+        self.button_6 = csel.ColourSelect(self.notebook_1_pane_1, ide[6], "all...")
+        self.static_line_7 = wx.StaticLine(self.notebook_1_pane_1, -1, style=wx.LI_VERTICAL)
+        self.button_7 = wx.Button(self.notebook_1_pane_1, ide[7], "SetWatchPenBrush")
+        self.static_line_8 = wx.StaticLine(self.notebook_1_pane_1, -1)
+        self.button_8 = csel.ColourSelect(self.notebook_1_pane_1, ide[8], "Pen colour...")
+        self.button_9 = csel.ColourSelect(self.notebook_1_pane_1, ide[9], "Brush colour...")
+        self.button_10 = wx.Button(self.notebook_1_pane_2, ide[10], "SetTickColours")
+        self.static_line_8 = wx.StaticLine(self.notebook_1_pane_2, -1)
+        self.button_11 = csel.ColourSelect(self.notebook_1_pane_2, ide[11], "hours...", colour=self.parent.tickMarkHoursPen.GetColour())
+        self.button_12 = csel.ColourSelect(self.notebook_1_pane_2, ide[12], "minutes...", colour=self.parent.tickMarkMinutesPen.GetColour())
+        self.static_line_10 = wx.StaticLine(self.notebook_1_pane_2, -1, style=wx.LI_VERTICAL)
+        self.button_13 = wx.Button(self.notebook_1_pane_2, ide[13], "SetTickSizes")
+        self.static_line_11 = wx.StaticLine(self.notebook_1_pane_2, -1)
+        self.label_1 = wx.StaticText(self.notebook_1_pane_2, -1, "hours")
+        self.spin_ctrl_1 = wx.SpinCtrl(self.notebook_1_pane_2, ide[71], "10", min=1, max=100)
+        self.label_2 = wx.StaticText(self.notebook_1_pane_2, -1, "minutes")
+        self.spin_ctrl_2 = wx.SpinCtrl(self.notebook_1_pane_2, ide[72], "5", min=0, max=100)
+        self.label_3 = wx.StaticText(self.notebook_1_pane_2, -1, "offset")
+        self.spin_ctrl_3 = wx.SpinCtrl(self.notebook_1_pane_2, ide[73], "0", min=0, max=100)
+        self.static_line_12 = wx.StaticLine(self.notebook_1_pane_2, -1, style=wx.LI_VERTICAL)
+        self.button_14 = wx.Button(self.notebook_1_pane_2, ide[14], "SetTickFonts")
+        self.static_line_13 = wx.StaticLine(self.notebook_1_pane_2, -1)
+        self.button_15 = wx.Button(self.notebook_1_pane_2, ide[15], "hours...")
+        self.button_16 = wx.Button(self.notebook_1_pane_2, ide[16], "minutes...")
+        self.button_17 = wx.Button(self.notebook_1_pane_3, ide[17], "SetHandWeights")
+        self.static_line_14 = wx.StaticLine(self.notebook_1_pane_3, -1)
+        self.label_4 = wx.StaticText(self.notebook_1_pane_3, -1, "hours")
+        self.spin_ctrl_4 = wx.SpinCtrl(self.notebook_1_pane_3, ide[74], "5", min=0, max=100)
+        self.label_5 = wx.StaticText(self.notebook_1_pane_3, -1, "minutes")
+        self.spin_ctrl_5 = wx.SpinCtrl(self.notebook_1_pane_3, ide[75], "3", min=0, max=100)
+        self.label_6 = wx.StaticText(self.notebook_1_pane_3, -1, "seconds")
+        self.spin_ctrl_6 = wx.SpinCtrl(self.notebook_1_pane_3, ide[76], "1", min=0, max=100)
+        self.static_line_15 = wx.StaticLine(self.notebook_1_pane_3, -1, style=wx.LI_VERTICAL)
+        self.button_18 = wx.Button(self.notebook_1_pane_3, ide[18], "SetHandColours")
+        self.static_line_16 = wx.StaticLine(self.notebook_1_pane_3, -1)
+        self.button_19 = csel.ColourSelect(self.notebook_1_pane_3, ide[19], "hours...")
+        self.button_20 = csel.ColourSelect(self.notebook_1_pane_3, ide[20], "minutes...")
+        self.button_21 = csel.ColourSelect(self.notebook_1_pane_3, ide[21], "seconds...")
+
+        self.__set_properties()
+        self.__do_layout()
+
+
+        self.Bind(wx.EVT_BUTTON, self.OnEventsHook, id=ide[0], id2=ide[29])
+        self.Bind(csel.EVT_COLOURSELECT, self.OnEventsHook, id=ide[0], id2=ide[29])
+        self.Bind(wx.EVT_SPINCTRL, self.OnEventsHook, id=ide[71], id2=ide[80])
+        self.Bind(wx.EVT_RADIOBUTTON, self.OnEventsHook, id=ide[51], id2=ide[60])
+        self.Bind(wx.EVT_WINDOW_DESTROY, self.OnQuit)
+
+        self.ide=ide
+
+    def __set_properties(self):
+        #self.SetTitle("AnalogClock Test")
+        self.spin_ctrl_1.SetSize((50, -1))
+        self.spin_ctrl_2.SetSize((50, -1))
+        self.spin_ctrl_3.SetSize((50, -1))
+        self.spin_ctrl_4.SetSize((50, -1))
+        self.spin_ctrl_5.SetSize((50, -1))
+        self.spin_ctrl_6.SetSize((50, -1))
+
+
+    def __do_layout(self):
+        sizer_frame = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_main = wx.BoxSizer(wx.VERTICAL)
+        sizer_25 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_26 = wx.StaticBoxSizer(wx.StaticBox(self.notebook_1_pane_3, -1, ""), wx.VERTICAL)
+        sizer_27 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_31 = wx.BoxSizer(wx.VERTICAL)
+        sizer_33 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_32 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_28 = wx.BoxSizer(wx.VERTICAL)
+        sizer_30 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_29 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_12 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_13 = wx.StaticBoxSizer(wx.StaticBox(self.notebook_1_pane_2, -1, ""), wx.VERTICAL)
+        sizer_14 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_22 = wx.BoxSizer(wx.VERTICAL)
+        sizer_24 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_23 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_18 = wx.BoxSizer(wx.VERTICAL)
+        sizer_21 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_20 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_19 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_15 = wx.BoxSizer(wx.VERTICAL)
+        sizer_17 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_16 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_2 = wx.StaticBoxSizer(wx.StaticBox(self.notebook_1_pane_1, -1, ""), wx.VERTICAL)
+        sizer_8 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_11 = wx.BoxSizer(wx.VERTICAL)
+        sizer_12b = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_9 = wx.BoxSizer(wx.VERTICAL)
+        sizer_10 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_6 = wx.BoxSizer(wx.VERTICAL)
+        sizer_7 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_4 = wx.BoxSizer(wx.VERTICAL)
+        sizer_5 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_main.Add(self.label_top, 0, wx.LEFT|wx.TOP, 5)
+        sizer_main.Add(self.static_line_1, 0, wx.TOP|wx.BOTTOM|wx.EXPAND, 10)
+        sizer_4.Add(self.button_1, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_4.Add(self.static_line_2, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_5.Add(self.button_2, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_4.Add(sizer_5, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_3.Add(sizer_4, 1, wx.EXPAND, 0)
+        sizer_3.Add(self.static_line_3, 0, wx.EXPAND, 0)
+        sizer_6.Add(self.button_3, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_6.Add(self.static_line_4, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_7.Add(self.button_4, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_7.Add(self.button_22, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_6.Add(sizer_7, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_3.Add(sizer_6, 1, wx.EXPAND, 0)
+        sizer_2.Add(sizer_3, 1, wx.EXPAND, 0)
+        sizer_2.Add(self.static_line_5, 0, wx.EXPAND, 0)
+        sizer_9.Add(self.button_5, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_9.Add(self.static_line_6, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_10.Add(self.button_6, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_9.Add(sizer_10, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_8.Add(sizer_9, 1, wx.EXPAND, 0)
+        sizer_8.Add(self.static_line_7, 0, wx.EXPAND, 0)
+        sizer_11.Add(self.button_7, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_11.Add(self.static_line_8, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_12b.Add(self.button_8, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_12b.Add(self.button_9, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_11.Add(sizer_12b, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_8.Add(sizer_11, 1, wx.EXPAND, 0)
+        sizer_2.Add(sizer_8, 1, wx.EXPAND, 0)
+        sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
+        self.notebook_1_pane_1.SetAutoLayout(1)
+        self.notebook_1_pane_1.SetSizer(sizer_1)
+        sizer_1.Fit(self.notebook_1_pane_1)
+        sizer_1.SetSizeHints(self.notebook_1_pane_1)
+        sizer_15.Add(self.button_10, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(self.static_line_8, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_16.Add(self.button_11, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(sizer_16, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_17.Add(self.button_12, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(sizer_17, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_15, 1, wx.EXPAND, 0)
+        sizer_14.Add(self.static_line_10, 0, wx.EXPAND, 0)
+        sizer_18.Add(self.button_13, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(self.static_line_11, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_19.Add(self.label_1, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_19.Add(self.spin_ctrl_1, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_19, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_20.Add(self.label_2, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_20.Add(self.spin_ctrl_2, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_20, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_21.Add(self.label_3, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_21.Add(self.spin_ctrl_3, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_21, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_18, 1, wx.EXPAND, 0)
+        sizer_14.Add(self.static_line_12, 0, wx.EXPAND, 0)
+        sizer_22.Add(self.button_14, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(self.static_line_13, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_23.Add(self.button_15, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(sizer_23, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_24.Add(self.button_16, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(sizer_24, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_22, 1, wx.EXPAND, 0)
+        sizer_13.Add(sizer_14, 1, wx.EXPAND, 0)
+        sizer_12.Add(sizer_13, 1, wx.EXPAND, 0)
+        self.notebook_1_pane_2.SetAutoLayout(1)
+        self.notebook_1_pane_2.SetSizer(sizer_12)
+        sizer_12.Fit(self.notebook_1_pane_2)
+        sizer_12.SetSizeHints(self.notebook_1_pane_2)
+        sizer_28.Add(self.button_17, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(self.static_line_14, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_29.Add(self.label_4, 0, wx.ALL|wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.spin_ctrl_4, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.label_5, 0, wx.ALL|wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.spin_ctrl_5, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(sizer_29, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_30.Add(self.label_6, 0, wx.ALL|wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_30.Add(self.spin_ctrl_6, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(sizer_30, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_27.Add(sizer_28, 1, wx.EXPAND, 0)
+        sizer_27.Add(self.static_line_15, 0, wx.EXPAND, 0)
+        sizer_31.Add(self.button_18, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(self.static_line_16, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 20)
+        sizer_32.Add(self.button_19, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_32.Add(self.button_20, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(sizer_32, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_33.Add(self.button_21, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(sizer_33, 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        sizer_27.Add(sizer_31, 1, wx.EXPAND, 0)
+        sizer_26.Add(sizer_27, 1, wx.EXPAND, 0)
+        sizer_25.Add(sizer_26, 1, wx.EXPAND, 0)
+        self.notebook_1_pane_3.SetAutoLayout(1)
+        self.notebook_1_pane_3.SetSizer(sizer_25)
+        sizer_25.Fit(self.notebook_1_pane_3)
+        sizer_25.SetSizeHints(self.notebook_1_pane_3)
+        self.notebook_1.AddPage(self.notebook_1_pane_1, "Clock")
+        self.notebook_1.AddPage(self.notebook_1_pane_2, "Ticks")
+        self.notebook_1.AddPage(self.notebook_1_pane_3, "Hands")
+        sizer_main.Add(wx.NotebookSizer(self.notebook_1), 1, wx.LEFT|wx.RIGHT|wx.BOTTOM|wx.EXPAND, 5)
+        self.panel_1.SetAutoLayout(1)
+        self.panel_1.SetSizer(sizer_main)
+        sizer_main.Fit(self.panel_1)
+        sizer_main.SetSizeHints(self.panel_1)
+        sizer_frame.Add(self.panel_1, 1, wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 0)
+        self.SetAutoLayout(1)
+        self.SetSizer(sizer_frame)
+        sizer_frame.Fit(self)
+        sizer_frame.SetSizeHints(self)
+        self.Layout()
+        self.UpdateWidgets()
+
+    def UpdateAll(self):
+        self.UpdateWidgets()
+        self.parent.OnSize(None)
+
+    def UpdateWidgets(self):
+        self.button_6.SetColour(self.parent.shadowPenColour)
+
+        bc=self.parent.watchPen
+        if bc:
+            bc=bc.GetColour()
+        else:
+            bc=self.parent.GetBackgroundColour()
+        self.button_8.SetColour(bc)
+
+        bc=self.parent.watchBrush
+        if bc:
+            bc=bc.GetColour()
+        else:
+            bc=self.parent.GetBackgroundColour()
+        self.button_9.SetColour(bc)
+
+        self.button_11.SetColour(self.parent.tickMarkHoursPen.GetColour())
+        self.button_12.SetColour(self.parent.tickMarkMinutesPen.GetColour())
+        self.button_19.SetColour(self.parent.handHoursColour)
+        self.button_20.SetColour(self.parent.handMinutesColour)
+        self.button_21.SetColour(self.parent.handSecondsColour)
+        
+        self.spin_ctrl_1.SetValue(self.parent.markSizeHour)
+        self.spin_ctrl_2.SetValue(self.parent.markSizeMin)
+        self.spin_ctrl_3.SetValue(self.parent.offM)
+        self.spin_ctrl_4.SetValue(self.parent.handHoursThickness)
+        self.spin_ctrl_5.SetValue(self.parent.handMinutesThickness)
+        self.spin_ctrl_6.SetValue(self.parent.handSecondsThickness)
+
+
+    def gfid(self, id, lista):
+        return self.ide.index(id) in lista
+        #  for x in lista:
+            #  if id==self.ide[x]:
+                #  f=True
+                #  break
+        #  else:
+            #  f=False
+        #  return f
+
+    def OnEventsHook(self, evt):
+        id=evt.GetId()
+
+        if self.gfid(id, [6,8,9,11,12,19,20,21,23]):
+            self.OnSelectColour(evt)
+            
+        elif self.gfid(id, [15,16]):
+            self.OnSelectFont(evt)
+
+        elif self.gfid(id, [71,72,73,74,75,76]):
+            self.OnSpinChange(evt)
+            
+        elif self.gfid(id, [3,4,22]):
+            self.OnChangeStyle(evt)
+
+        elif self.gfid(id, [1,2,5,7,10,13,14,17,18]):
+            self.OnDefaults(evt)
+
+    def OnSelectColour(self, evt):
+        id=evt.GetId();colour=evt.GetValue()
+
+        if id==self.ide[6]:
+            self.parent.SetShadowColour(colour)
+        elif id==self.ide[8]:
+            self.parent.SetWatchPenBrush(p=wx.Pen(colour, 1, wx.SOLID))
+        elif id==self.ide[9]:
+            self.parent.SetWatchPenBrush(b=wx.Brush(colour, wx.SOLID))
+        elif id==self.ide[11]:
+            self.parent.SetTickColours(h=colour)
+        elif id==self.ide[12]:
+            self.parent.SetTickColours(m=colour)
+        elif id==self.ide[19]:
+            self.parent.SetHandColours(h=colour)
+        elif id==self.ide[20]:
+            self.parent.SetHandColours(m=colour)
+        elif id==self.ide[21]:
+            self.parent.SetHandColours(s=colour)
+
+
+        self.UpdateAll()
+
+
+
+    def OnSelectFont(self, evt):
+        id=evt.GetId()
+        if id==self.ide[15]:
+            font=self.parent.tickMarkHoursFont;font.SetPointSize(self.parent.markSizeHour)
+            colour=self.parent.tickMarkHoursPen.GetColour()
+        else:
+            font=self.parent.tickMarkMinutesFont;font.SetPointSize(self.parent.markSizeMin)
+            colour=self.parent.tickMarkMinutesPen.GetColour()
+
+        data = wx.FontData()
+        data.EnableEffects(True)
+        data.SetColour(colour)
+        data.SetInitialFont(font)
+
+        dlg = wx.FontDialog(self, data)
+        if dlg.ShowModal() == wx.ID_OK:
+            data = dlg.GetFontData()
+            font = data.GetChosenFont()
+            colour = data.GetColour()
+            if id==self.ide[15]:
+                self.parent.SetTickFonts(h=font)
+                self.parent.SetTickColours(h=colour.Get())
+            else:
+                self.parent.SetTickFonts(m=font)
+                self.parent.SetTickColours(m=colour.Get())
+        dlg.Destroy()
+
+        self.UpdateAll()
+
+    def OnSpinChange(self, evt):
+        id=evt.GetId();v=evt.GetInt()
+        if id==self.ide[71]:
+            self.parent.SetTickSizes(h=v)
+        if id==self.ide[72]:
+            self.parent.SetTickSizes(m=v)
+        if id==self.ide[73]:
+            self.parent.SetMinutesOffset(v)
+        if id==self.ide[74]:
+            self.parent.SetHandWeights(h=v)
+        if id==self.ide[75]:
+            self.parent.SetHandWeights(m=v)
+        if id==self.ide[76]:
+            self.parent.SetHandWeights(s=v)
+
+        self.UpdateAll()
+
+    def OnChangeStyle(self, evt):
+        id=evt.GetId()
+
+        if id==self.ide[3]:
+            x="""SHOW_QUARTERS_TICKS
+                 SHOW_HOURS_TICKS
+                 SHOW_MINUTES_TICKS
+                 ROTATE_TICKS
+                 SHOW_HOURS_HAND
+                 SHOW_MINUTES_HAND
+                 SHOW_SECONDS_HAND
+                 SHOW_SHADOWS
+                 OVERLAP_TICKS""".split()
+            m=map(lambda f: (self.parent.clockStyle & f)/f, map(lambda f: 2**x.index(f),x))
+
+            dlg = dlgs.MultipleChoiceDialog(self,
+                                         "Select some styles for the clock:",
+                                         "Styles", x)
+            for i in range(0,len(m)):
+                if m[i]:
+                    dlg.lbox.SetSelection(i)
+
+            if (dlg.ShowModal() == wx.ID_OK):
+                v=reduce(lambda x,y:x+y,map(lambda f: 2**f,dlg.GetValue()))
+                self.parent.SetClockStyle(v)
+
+        elif id==self.ide[4]:
+            x="""TICKS_NONE
+                 TICKS_SQUARE
+                 TICKS_CIRCLE
+                 TICKS_POLY
+                 TICKS_DECIMAL
+                 TICKS_ROMAN""".split()
+            m=map(lambda f: (self.parent.tickMarkHoursStyle & f)/f, map(lambda f: 2**x.index(f),x))
+
+            dlg = wx.SingleChoiceDialog(self,
+                                       "Select a style for the hours:",
+                                       "Styles", x, wx.CHOICEDLG_STYLE)
+            for i in range(0,len(m)):
+                if m[i]:
+                    dlg.SetSelection(i)
+
+            if dlg.ShowModal() == wx.ID_OK:
+                v=2**dlg.GetSelection()
+                self.parent.SetTickStyles(h=v)
+            dlg.Destroy()
+
+        elif id==self.ide[22]:
+            tipo="for the minutes"
+            x="""TICKS_NONE
+                 TICKS_SQUARE
+                 TICKS_CIRCLE
+                 TICKS_POLY
+                 TICKS_DECIMAL
+                 TICKS_ROMAN""".split()
+            m=map(lambda f: (self.parent.tickMarkMinutesStyle & f)/f, map(lambda f: 2**x.index(f),x))
+
+            dlg = wx.SingleChoiceDialog(self,
+                                       "Select a style for the minutes:",
+                                       "Styles", x, wx.CHOICEDLG_STYLE)
+            for i in range(0,len(m)):
+                if m[i]:
+                    dlg.SetSelection(i)
+
+            if dlg.ShowModal() == wx.ID_OK:
+                v=2**dlg.GetSelection()
+                self.parent.SetTickStyles(m=v)
+            dlg.Destroy()
+
+        self.UpdateAll()
+
+    def OnDefaults(self, evt):
+        id=evt.GetId()
+        if id==self.ide[1]:
+            self.parent.SetClockStyle(142)
+        elif id==self.ide[2]:
+            self.parent.SetTickStyles(8, 4)
+        elif id==self.ide[5]:
+            self.parent.SetShadowColour((128,128,128))
+        elif id==self.ide[7]:
+            colour=self.parent.GetBackgroundColour()
+            self.parent.SetWatchPenBrush(p=wx.Pen(colour, 1, wx.SOLID), b=wx.Brush(colour, wx.SOLID))
+        elif id==self.ide[10]:
+            colour=(0, 0, 0)
+            self.parent.SetTickColours(h=colour, m=colour)
+        elif id==self.ide[13]:
+            self.parent.SetTickSizes(h=10, m=5)
+            self.parent.SetMinutesOffset(0)
+        elif id==self.ide[14]:
+            self.parent.SetTickFonts(wx.Font(1, wx.SWISS, wx.NORMAL, wx.BOLD))
+        elif id==self.ide[17]:
+            self.parent.SetHandWeights(h=5, m=3, s=1)
+        elif id==self.ide[18]:
+            colour=(0, 0, 0)
+            self.parent.SetHandColours(h=colour, m=colour, s=colour)
+
+        self.UpdateAll()
+
+
+    def OnQuit(self, evt):
+        self.parent.prefs_open=False
+
+
+#
+##
+### eof
+
+
+