Updated the AnalogClockWindow with many enhancements from from

E. A. Tacão.

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

diff --git a/wxPython/demo/AnalogClockWindow.py b/wxPython/demo/AnalogClockWindow.py
index aa0afeb7c0d41b34383ef9f9dd52ea113fd84737..285771490793602eb403e7b51df552741ac21a83 100644 (file)
--- a/wxPython/demo/AnalogClockWindow.py
+++ b/wxPython/demo/AnalogClockWindow.py
@@ -1,6 +1,9 @@
 
 

-import  wx
-import  wx.lib.analogclock  as  aclock
+
+
+import wx
+from wx.lib import analogclock as ac
+

 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 


@@ -9,36 +12,56 @@ class TestPanel(wx.Panel):
         self.log = log
         wx.Panel.__init__(self, parent, -1)
 
         self.log = log
         wx.Panel.__init__(self, parent, -1)
 

-        # A red background with blue hands and white markings
-        c1 = aclock.AnalogClockWindow(self)
+        # A mostly default clock
+        c1 = ac.AnalogClockWindow(self)

         c1.SetBackgroundColour("RED")
         c1.SetBackgroundColour("RED")

-        c1.SetHandsColour("BLUE")
-        c1.SetTickMarkColours("WHITE")
-
-        # A white background with red hands and blue markings
-        c2 = aclock.AnalogClockWindow(self)
+        c1.SetHandColours("BLUE")
+        c1.SetTickColours("WHITE")
+        c1.SetTickSizes(h=5, m=2)
+
+        
+        # A clock with roman numerals, shown only at the quarter
+        # marks, and a separatly coloured watch face.
+        c2 = ac.AnalogClockWindow(self)

         c2.SetBackgroundColour("WHITE")
         c2.SetBackgroundColour("WHITE")

-        c2.SetHandsColour("RED")
-        c2.SetTickMarkColours("BLUE")
-
-        # A blue background with white hands and red markings
-        c3 = aclock.AnalogClockWindow(self)
+        c2.SetHandColours("RED")
+        c2.SetTickColours("BLUE")
+        c2.SetTickStyles(ac.TICKS_ROMAN)
+        c2.SetClockStyle(ac.SHOW_QUARTERS_TICKS | ac.SHOW_SHADOWS)
+        c2.SetWatchPenBrush(p=wx.Pen((238, 238, 227), 1, wx.SOLID),
+                            b=wx.Brush("CADET BLUE", wx.SOLID))
+        c2.SetTickSizes(h=12)
+
+        # A clock with rotated decimal numbers, shown at all twelve
+        # hour marks
+        c3 = ac.AnalogClockWindow(self)

         c3.SetBackgroundColour("BLUE")
         c3.SetBackgroundColour("BLUE")

-        c3.SetHandsColour("WHITE")
-        c3.SetTickMarkColours("RED")
+        c3.SetHandColours("WHITE")
+        c3.SetTickColours("RED")
+        c3.SetTickStyles(h=ac.TICKS_DECIMAL)
+        c3.SetClockStyle(ac.SHOW_HOURS_TICKS | ac.ROTATE_TICKS)
+        c3.SetTickSizes(h=14)

 
 

-        # Raised border, circular tick marks.
-        c4 = aclock.AnalogClockWindow(self, style=wx.RAISED_BORDER)
-        c4.SetTickMarkStyle(aclock.AnalogClockWindow.TICKS_CIRCLE)
+        # a plain clock, with square hour and round minute marks, no
+        # shadow raised border
+        c4 = ac.AnalogClockWindow(self, style=wx.RAISED_BORDER)
+        c4.SetTickStyles(h=ac.TICKS_SQUARE, m=ac.TICKS_CIRCLE)
+        c4.SetClockStyle(ac.SHOW_HOURS_TICKS | ac.SHOW_MINUTES_TICKS)
+        c4.SetTickSizes(h=5, m=2)

 
 

-        # No tick marks
-        c5 = aclock.AnalogClockWindow(self)
-        c5.SetTickMarkStyle(aclock.AnalogClockWindow.TICKS_NONE)

 
 

-        # Sunken into window
-        c6 = aclock.AnalogClockWindow(self, style=wx.SUNKEN_BORDER)
+        # no minute tick marks
+        c5 = ac.AnalogClockWindow(self)
+        c5.SetTickStyles(h=ac.TICKS_CIRCLE)
+        c5.SetClockStyle(ac.SHOW_HOURS_TICKS | ac.SHOW_SHADOWS | ac.ROTATE_TICKS)
+        c5.SetTickSizes(h=5, m=2)

 
 

-        # layout the clocks in a grid sizer
+        # sunken border
+        c6 = ac.AnalogClockWindow(self, style=wx.SUNKEN_BORDER)
+        c6.SetTickSizes(h=5, m=2)
+
+
+        # layout the clocks in a grid

         gs = wx.GridSizer(2, 3, 4, 4)
         gs.Add(c1, 0, wx.EXPAND)
         gs.Add(c2, 0, wx.EXPAND)
         gs = wx.GridSizer(2, 3, 4, 4)
         gs.Add(c1, 0, wx.EXPAND)
         gs.Add(c2, 0, wx.EXPAND)


@@ -49,7 +72,7 @@ class TestPanel(wx.Panel):
 
         # put it in another sizer for a border
         sizer = wx.BoxSizer(wx.VERTICAL)
 
         # put it in another sizer for a border
         sizer = wx.BoxSizer(wx.VERTICAL)

-        sizer.Add(gs, 1, wx.EXPAND|wx.ALL, 10)
+        sizer.Add(gs, 1, wx.EXPAND | wx.ALL, 10)

 
         self.SetSizer(sizer)
 
 
         self.SetSizer(sizer)
 


@@ -69,10 +92,13 @@ overview = """<html><body>
 
 This is a nice little clock class that was contributed to by several
 members of the wxPython-users group.
 
 This is a nice little clock class that was contributed to by several
 members of the wxPython-users group.

-
+<p>
+Check the options available by right-clicking the clock.

 </body></html>
 """
 
 </body></html>
 """
 

+
+

 if __name__ == '__main__':
     import sys,os
     import run
 if __name__ == '__main__':
     import sys,os
     import run

diff --git a/wxPython/docs/CHANGES.txt b/wxPython/docs/CHANGES.txt
index c093795f207d0fd8fc962e7c1b51517f7af5231b..d902cd154690026b8ba5b79fbe71ead4136d0a55 100644 (file)
--- a/wxPython/docs/CHANGES.txt
+++ b/wxPython/docs/CHANGES.txt
@@ -51,6 +51,11 @@ want to put them.
 The wxWave class has been renamed to wxSound, and now has a slightly
 different API.
 
 The wxWave class has been renamed to wxSound, and now has a slightly
 different API.
 

+Updated the AnalogClockWindow with many enhancements from from
+E. A. Tacão.
+
+
+

 
 
 2.4.2.4
 
 
 2.4.2.4

diff --git a/wxPython/wx/lib/analogclock.py b/wxPython/wx/lib/analogclock.py
index 6bd878f3feaa907cf9b438132d2c6284fda331b7..55622d2dba6461b8c46a4b2556ad71b61a53f83b 100644 (file)
--- a/wxPython/wx/lib/analogclock.py
+++ b/wxPython/wx/lib/analogclock.py
@@ -1,5 +1,6 @@
+# -*- coding: iso-8859-1 -*-

 #----------------------------------------------------------------------
 #----------------------------------------------------------------------

-# Name:        wxPython.lib.analogclock
+# Name:        wx.lib.analogclock

 # Purpose:     A simple analog clock window
 #
 # Author:      several folks on wxPython-users
 # Purpose:     A simple analog clock window
 #
 # Author:      several folks on wxPython-users


@@ -14,188 +15,766 @@
 # o Updated for wx namespace
 # o Tested with updated demo and with builtin test.
 # 
 # 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  string
-import  sys
-import  time

 
 

-import  wx
+import math
+import sys
+import string
+import time
+
+import wx
+
+from analogclockopts import ACCustomizationFrame

 
 

-class AnalogClockWindow(wx.Window):
-    """A simple analog clock window"""

 
 

-    TICKS_NONE   = 0
-    TICKS_SQUARE = 1
-    TICKS_CIRCLE = 2
+# 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.Window):
+    """An analog clock window"""

 
     def __init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
                  style=0, name="clock"):
 
     def __init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
                  style=0, name="clock"):

-
+        

         # Initialize the wxWindow...
         wx.Window.__init__(self, parent, ID, pos, size, style, name)
 
         # Initialize the wxWindow...
         wx.Window.__init__(self, parent, ID, pos, size, style, name)
 

-        # Initialize the default clock settings...
-        self.minuteMarks = 60
-        self.hourMarks = 12
-        self.tickMarksBrushC = self.GetForegroundColour()
-        self.tickMarksPenC   = self.GetForegroundColour()
-        self.tickMarkStyle = self.TICKS_SQUARE
+        # 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

 
         # 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))
 
 
         # 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))
 

-        # 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)
-

         # 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)
         # 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)         

 
 
 
 

-    def SetTickMarkStyle(self, style):
-        """
-        Set the style of the marks around the edge of the clock.
-        Options are TICKS_NONE, TICKS_SQUARE, and TICKS_CIRCLE
-        """
-        self.tickMarkStyle = style
+        # 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 SetTickMarkColours(self, brushC, penC="BLACK"):
-        """
-        Set the brush colour and optionally the pen colour of
-        the marks around the edge of the clock.
-        """
-        self.tickMarksBrushC = brushC
-        self.tickMarksPenC   = penC
+    def OnPaint(self, event):
+        self._doDrawHands(wx.BufferedPaintDC(self), 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()
+

 
 

-    SetTickMarkColour = SetTickMarkColours
+    def OnPopupOne(self, event):
+        self.prefs_open=True
+        frame = ACCustomizationFrame(self, -1, "AnalogClock Preferences")
+        frame.Show(True)

 
 
 
 

-    def SetHandsColour(self, c):
-        """An alias for SetForegroundColour"""
-        self.SetForegroundColour(c)  # the hands just use the foreground colour
+    def OnPopupTwo(self, event):
+        dlg = wx.MessageDialog(self, "AnalogClockWindow\n\nby Several folks on wxPython-users\nwith enhancements from E. A. Tacão",
+                          'About', wx.OK | wx.ICON_INFORMATION)
+        dlg.ShowModal()
+        dlg.Destroy()

 
 
 
 

-    # Using the current settings, render the points and line endings for the
-    # circle inside the specified device context.  In this case, the DC is
-    # a memory based device context that will be blitted to the actual
-    # display DC inside the OnPaint() event handler.

     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()
         self.faceBitmap = wx.EmptyBitmap(size.width, size.height)
     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()
         self.faceBitmap = wx.EmptyBitmap(size.width, size.height)

-        self.DrawFace()

 
 

+        # Update drawing coordinates...
+        new_dim = size.Get()
+        if not hasattr(self,"dim"):
+            self.dim = new_dim

 
 

-    def OnPaint(self, event):
-        self.DrawHands(wx.PaintDC(self))
+        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

 
 

-    def OnQuit(self, event):
-        self.timer.Stop()
-        del self.timer
+        self.shadowDistance = 2 * self.scale

 
 

+        self.radius_watch = min(self.centerX, self.centerY)

 
 

-    def OnTimerExpire(self, event):
-        self.DrawHands(wx.ClientDC(self))
-
-
-    def DrawHands(self, drawDC):
-        # Start by drawing the face bitmap
-        drawDC.DrawBitmap(self.faceBitmap, (0,0))
+        self._doDrawFace()
+        

 
 

-        currentTime = time.localtime(time.time())
-        hour, minutes, seconds = currentTime[3:6]

 
 

-        W,H = self.faceBitmap.GetWidth(), self.faceBitmap.GetHeight()
-        centerX = W / 2
-        centerY = H / 2
+    def _doDrawHands(self, drawDC, force=0):
+        currentTime = list(time.localtime(time.time())[3:6])

 
 

-        radius = min(centerX, centerY)
-        hour += minutes / 60.0 # added so the hour hand moves continuously
-        x, y = self.point(hour, 12, (radius * .65))
-        hourX, hourY = (x + centerX), (centerY - y)
-        x, y = self.point(minutes, 60, (radius * .85))
-        minutesX, minutesY = (x + centerX), (centerY - y)
-        x, y = self.point(seconds, 60, (radius * .85))
-        secondsX, secondsY = (x + centerX), (centerY - y)
+        if not (self.handsStyle & SHOW_SECONDS_HAND):
+            currentTime[2]=-1

 
 

-        # Draw the hour hand...
-        drawDC.SetPen(wx.Pen(self.GetForegroundColour(), 5, wx.SOLID))
-        drawDC.DrawLine((centerX, centerY), (hourX, hourY))
+        if not (force or currentTime != self.currentTime):
+            return
+        self.currentTime = currentTime
+        hour, minutes, seconds = currentTime

 
 

-        # Draw the minutes hand...
-        drawDC.SetPen(wx.Pen(self.GetForegroundColour(), 3, wx.SOLID))
-        drawDC.DrawLine((centerX, centerY), (minutesX, minutesY))
-
-        # Draw the seconds hand...
-        drawDC.SetPen(wx.Pen(self.GetForegroundColour(), 1, wx.SOLID))
-        drawDC.DrawLine((centerX, centerY), (secondsX, secondsY))
+        # Start by drawing the face bitmap
+        drawDC.DrawBitmap(self.faceBitmap, (0,0))

 
 
 
 

-    # Draw the specified set of line marks inside the clock face for the
-    # hours or minutes...
-    def DrawFace(self):
+        # 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.DrawLineXY(int(self.centerX + self.shadowDistance),
+                              int(self.centerY + self.shadowDistance),
+                              int(x + self.shadowDistance),
+                              int(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.DrawLineXY(int(self.centerX + self.shadowDistance),
+                              int(self.centerY + self.shadowDistance),
+                              int(x + self.shadowDistance),
+                              int(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.DrawLineXY(int(self.centerX + self.shadowDistance),
+                                  int(self.centerY + self.shadowDistance),
+                                  int(x + self.shadowDistance),
+                                  int(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.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(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.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(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.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(y))
+
+
+
+    def _doDrawFace(self):

         backgroundBrush = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
         drawDC = wx.MemoryDC()
         drawDC.SelectObject(self.faceBitmap)
         drawDC.SetBackground(backgroundBrush)
         drawDC.Clear()
 
         backgroundBrush = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
         drawDC = wx.MemoryDC()
         drawDC.SelectObject(self.faceBitmap)
         drawDC.SetBackground(backgroundBrush)
         drawDC.Clear()
 

-        W,H = self.faceBitmap.GetWidth(), self.faceBitmap.GetHeight()
-        centerX = W / 2
-        centerY = H / 2
+        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...
 
         # Draw the marks for hours and minutes...

-        self.DrawTimeMarks(drawDC, self.minuteMarks, centerX, centerY, 4)
-        self.DrawTimeMarks(drawDC, self.hourMarks, centerX, centerY, 9)
+        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), (int(size), int(size)))
+
+        elif style & TICKS_SQUARE:
+            x, y = self._center2corner(x, y, tipo)
+            drawDC.DrawRectangle((x, y), (int(size), int(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]]

 
 

-    def DrawTimeMarks(self, drawDC, markCount, centerX, centerY, markSize):
-        for i in range(markCount):
-            x, y = self.point(i + 1, markCount, min(centerX,centerY) - 16)
-            scaledX = x + centerX - markSize/2
-            scaledY = centerY - y - markSize/2
+        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.
+        """

 
 

-            drawDC.SetBrush(wx.Brush(self.tickMarksBrushC, wx.SOLID))
-            drawDC.SetPen(wx.Pen(self.tickMarksPenC, 1, wx.SOLID))
+        if not tsm:
+            tsm=tsh

 
 

-            if self.tickMarkStyle != self.TICKS_NONE:
-                if self.tickMarkStyle == self.TICKS_CIRCLE:
-                    drawDC.DrawEllipse((scaledX - 2, scaledY), (markSize, markSize))
-                else:
-                    drawDC.DrawRectangle((scaledX - 3, scaledY), (markSize, markSize))
+        self.tickShapeHours = tsh
+        self.tickShapeMinutes = tsm

 
 
 
 

-    def point(self, tick, range, radius):
-        angle = tick * (360.0 / range)
-        radiansPerDegree = math.pi / 180
-        pointX = int(round(radius * math.sin(angle * radiansPerDegree)))
-        pointY = int(round(radius * math.cos(angle * radiansPerDegree)))
-        return wx.Point(pointX, pointY)
+    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 the 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__":
 
 
 if __name__ == "__main__":

+    print wx.VERSION_STRING

     class App(wx.App):
         def OnInit(self):
     class App(wx.App):
         def OnInit(self):

-            frame = wx.Frame(None, -1, "AnalogClockWindow Test", size=(375,375))
+            frame = wx.Frame(None, -1, "AnalogClockWindow", size=(375,375))

 
             clock = AnalogClockWindow(frame)
 
             clock = AnalogClockWindow(frame)

-            clock.SetTickMarkColours("RED")
-            clock.SetHandsColour("WHITE")
-            clock.SetBackgroundColour("BLUE")
+            
+            # 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)
 
             frame.Centre(wx.BOTH)
             frame.Show(True)


@@ -206,4 +785,6 @@ if __name__ == "__main__":
     theApp.MainLoop()
 
 
     theApp.MainLoop()
 
 

-
+#
+##
+### eof

diff --git a/wxPython/wx/lib/analogclockopts.py b/wxPython/wx/lib/analogclockopts.py
new file mode 100644 (file)
index 0000000..d05ea71
--- /dev/null
+++ b/wxPython/wx/lib/analogclockopts.py
@@ -0,0 +1,501 @@
+#----------------------------------------------------------------------
+# Name:        wxPython.lib.YAanalogclockOpts
+# Purpose:     An analog clock window - setup frame
+#
+# Author:      E. A. Tacao
+#
+# Created:     15-February-2004
+#----------------------------------------------------------------------
+
+# generated by wxGlade 0.3.1 on Wed Feb 18 00:05:35 2004
+
+from wxPython.wx import *
+from wxPython.lib.dialogs import wxMultipleChoiceDialog
+from wxPython.lib.colourselect import ColourSelect, wxEVT_COMMAND_COLOURSELECT
+import string
+
+class ACCustomizationFrame(wxFrame):
+    def __init__(self, parent, id, name, pos=wxDefaultPosition, size=wxDefaultSize,
+                 style=wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT | wxWANTS_CHARS):
+        k=wxNewId();ide=map(lambda x: x+k, range(0,100))
+        # begin wxGlade: ACCustomizationFrame.__init__
+        #kwds["style"] = wxCAPTION|wxSYSTEM_MENU
+        #wxFrame.__init__(self, *args, **kwds)
+        wxFrame.__init__(self, parent, id, name, pos, size, style)
+        self.parent=parent
+        self.panel_1 = wxPanel(self, -1)
+        self.notebook_1 = wxNotebook(self.panel_1, -1, style=0)
+        self.notebook_1_pane_3 = wxPanel(self.notebook_1, -1)
+        self.notebook_1_pane_2 = wxPanel(self.notebook_1, -1)
+        self.notebook_1_pane_1 = wxPanel(self.notebook_1, -1)
+        self.label_top = wxStaticText(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 = wxStaticLine(self.panel_1, -1)
+        self.button_1 = wxButton(self.notebook_1_pane_1, ide[1], "SetClockStyle")
+        self.static_line_2 = wxStaticLine(self.notebook_1_pane_1, -1)
+        self.button_2 = wxButton(self.notebook_1_pane_1, ide[3], "styles...")
+        self.static_line_3 = wxStaticLine(self.notebook_1_pane_1, -1, style=wxLI_VERTICAL)
+        self.button_3 = wxButton(self.notebook_1_pane_1, ide[2], "SetTickStyles")
+        self.static_line_4 = wxStaticLine(self.notebook_1_pane_1, -1)
+        self.button_4 = wxButton(self.notebook_1_pane_1, ide[4], "styles...")
+        self.button_22 = wxButton(self.notebook_1_pane_1, ide[22], "minutes...")
+        self.static_line_5 = wxStaticLine(self.notebook_1_pane_1, -1)
+        self.button_5 = wxButton(self.notebook_1_pane_1, ide[5], "SetShadowColour")
+        self.static_line_6 = wxStaticLine(self.notebook_1_pane_1, -1)
+        self.button_6 = ColourSelect(self.notebook_1_pane_1, ide[6], "all...")
+        self.static_line_7 = wxStaticLine(self.notebook_1_pane_1, -1, style=wxLI_VERTICAL)
+        self.button_7 = wxButton(self.notebook_1_pane_1, ide[7], "SetWatchPenBrush")
+        self.static_line_8 = wxStaticLine(self.notebook_1_pane_1, -1)
+        self.button_8 = ColourSelect(self.notebook_1_pane_1, ide[8], "Pen colour...")
+        self.button_9 = ColourSelect(self.notebook_1_pane_1, ide[9], "Brush colour...")
+        self.button_10 = wxButton(self.notebook_1_pane_2, ide[10], "SetTickColours")
+        self.static_line_8 = wxStaticLine(self.notebook_1_pane_2, -1)
+        self.button_11 = ColourSelect(self.notebook_1_pane_2, ide[11], "hours...", colour=self.parent.tickMarkHoursPen.GetColour())
+        self.button_12 = ColourSelect(self.notebook_1_pane_2, ide[12], "minutes...", colour=self.parent.tickMarkMinutesPen.GetColour())
+        self.static_line_10 = wxStaticLine(self.notebook_1_pane_2, -1, style=wxLI_VERTICAL)
+        self.button_13 = wxButton(self.notebook_1_pane_2, ide[13], "SetTickSizes")
+        self.static_line_11 = wxStaticLine(self.notebook_1_pane_2, -1)
+        self.label_1 = wxStaticText(self.notebook_1_pane_2, -1, "hours")
+        self.spin_ctrl_1 = wxSpinCtrl(self.notebook_1_pane_2, ide[71], "10", min=1, max=100)
+        self.label_2 = wxStaticText(self.notebook_1_pane_2, -1, "minutes")
+        self.spin_ctrl_2 = wxSpinCtrl(self.notebook_1_pane_2, ide[72], "5", min=0, max=100)
+        self.label_3 = wxStaticText(self.notebook_1_pane_2, -1, "offset")
+        self.spin_ctrl_3 = wxSpinCtrl(self.notebook_1_pane_2, ide[73], "0", min=0, max=100)
+        self.static_line_12 = wxStaticLine(self.notebook_1_pane_2, -1, style=wxLI_VERTICAL)
+        self.button_14 = wxButton(self.notebook_1_pane_2, ide[14], "SetTickFonts")
+        self.static_line_13 = wxStaticLine(self.notebook_1_pane_2, -1)
+        self.button_15 = wxButton(self.notebook_1_pane_2, ide[15], "hours...")
+        self.button_16 = wxButton(self.notebook_1_pane_2, ide[16], "minutes...")
+        self.button_17 = wxButton(self.notebook_1_pane_3, ide[17], "SetHandWeights")
+        self.static_line_14 = wxStaticLine(self.notebook_1_pane_3, -1)
+        self.label_4 = wxStaticText(self.notebook_1_pane_3, -1, "hours")
+        self.spin_ctrl_4 = wxSpinCtrl(self.notebook_1_pane_3, ide[74], "5", min=0, max=100)
+        self.label_5 = wxStaticText(self.notebook_1_pane_3, -1, "minutes")
+        self.spin_ctrl_5 = wxSpinCtrl(self.notebook_1_pane_3, ide[75], "3", min=0, max=100)
+        self.label_6 = wxStaticText(self.notebook_1_pane_3, -1, "seconds")
+        self.spin_ctrl_6 = wxSpinCtrl(self.notebook_1_pane_3, ide[76], "1", min=0, max=100)
+        self.static_line_15 = wxStaticLine(self.notebook_1_pane_3, -1, style=wxLI_VERTICAL)
+        self.button_18 = wxButton(self.notebook_1_pane_3, ide[18], "SetHandColours")
+        self.static_line_16 = wxStaticLine(self.notebook_1_pane_3, -1)
+        self.button_19 = ColourSelect(self.notebook_1_pane_3, ide[19], "hours...")
+        self.button_20 = ColourSelect(self.notebook_1_pane_3, ide[20], "minutes...")
+        self.button_21 = ColourSelect(self.notebook_1_pane_3, ide[21], "seconds...")
+
+        self.__set_properties()
+        self.__do_layout()
+        # end wxGlade
+
+        EVT_COMMAND_RANGE(self, ide[0], ide[29],
+                          wxEVT_COMMAND_BUTTON_CLICKED, self.OnEventsHook)
+        EVT_COMMAND_RANGE(self, ide[0], ide[29],
+                          wxEVT_COMMAND_COLOURSELECT, self.OnEventsHook)
+        EVT_COMMAND_RANGE(self, ide[71], ide[80],
+                          wxEVT_COMMAND_SPINCTRL_UPDATED, self.OnEventsHook)
+        EVT_COMMAND_RANGE(self, ide[51], ide[60],
+                          wxEVT_COMMAND_RADIOBUTTON_SELECTED, self.OnEventsHook)
+        EVT_WINDOW_DESTROY(self, self.OnQuit)
+
+        self.ide=ide
+
+    def __set_properties(self):
+        # begin wxGlade: ACCustomizationFrame.__set_properties
+        #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))
+        # end wxGlade
+
+    def __do_layout(self):
+        # begin wxGlade: ACCustomizationFrame.__do_layout
+        sizer_frame = wxBoxSizer(wxHORIZONTAL)
+        sizer_main = wxBoxSizer(wxVERTICAL)
+        sizer_25 = wxBoxSizer(wxHORIZONTAL)
+        sizer_26 = wxStaticBoxSizer(wxStaticBox(self.notebook_1_pane_3, -1, ""), wxVERTICAL)
+        sizer_27 = wxBoxSizer(wxHORIZONTAL)
+        sizer_31 = wxBoxSizer(wxVERTICAL)
+        sizer_33 = wxBoxSizer(wxHORIZONTAL)
+        sizer_32 = wxBoxSizer(wxHORIZONTAL)
+        sizer_28 = wxBoxSizer(wxVERTICAL)
+        sizer_30 = wxBoxSizer(wxHORIZONTAL)
+        sizer_29 = wxBoxSizer(wxHORIZONTAL)
+        sizer_12 = wxBoxSizer(wxHORIZONTAL)
+        sizer_13 = wxStaticBoxSizer(wxStaticBox(self.notebook_1_pane_2, -1, ""), wxVERTICAL)
+        sizer_14 = wxBoxSizer(wxHORIZONTAL)
+        sizer_22 = wxBoxSizer(wxVERTICAL)
+        sizer_24 = wxBoxSizer(wxHORIZONTAL)
+        sizer_23 = wxBoxSizer(wxHORIZONTAL)
+        sizer_18 = wxBoxSizer(wxVERTICAL)
+        sizer_21 = wxBoxSizer(wxHORIZONTAL)
+        sizer_20 = wxBoxSizer(wxHORIZONTAL)
+        sizer_19 = wxBoxSizer(wxHORIZONTAL)
+        sizer_15 = wxBoxSizer(wxVERTICAL)
+        sizer_17 = wxBoxSizer(wxHORIZONTAL)
+        sizer_16 = wxBoxSizer(wxHORIZONTAL)
+        sizer_1 = wxBoxSizer(wxHORIZONTAL)
+        sizer_2 = wxStaticBoxSizer(wxStaticBox(self.notebook_1_pane_1, -1, ""), wxVERTICAL)
+        sizer_8 = wxBoxSizer(wxHORIZONTAL)
+        sizer_11 = wxBoxSizer(wxVERTICAL)
+        sizer_12b = wxBoxSizer(wxHORIZONTAL)
+        sizer_9 = wxBoxSizer(wxVERTICAL)
+        sizer_10 = wxBoxSizer(wxHORIZONTAL)
+        sizer_3 = wxBoxSizer(wxHORIZONTAL)
+        sizer_6 = wxBoxSizer(wxVERTICAL)
+        sizer_7 = wxBoxSizer(wxHORIZONTAL)
+        sizer_4 = wxBoxSizer(wxVERTICAL)
+        sizer_5 = wxBoxSizer(wxHORIZONTAL)
+        sizer_main.Add(self.label_top, 0, wxLEFT|wxTOP, 5)
+        sizer_main.Add(self.static_line_1, 0, wxTOP|wxBOTTOM|wxEXPAND, 10)
+        sizer_4.Add(self.button_1, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_4.Add(self.static_line_2, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_5.Add(self.button_2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_4.Add(sizer_5, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_3.Add(sizer_4, 1, wxEXPAND, 0)
+        sizer_3.Add(self.static_line_3, 0, wxEXPAND, 0)
+        sizer_6.Add(self.button_3, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_6.Add(self.static_line_4, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_7.Add(self.button_4, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_7.Add(self.button_22, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_6.Add(sizer_7, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_3.Add(sizer_6, 1, wxEXPAND, 0)
+        sizer_2.Add(sizer_3, 1, wxEXPAND, 0)
+        sizer_2.Add(self.static_line_5, 0, wxEXPAND, 0)
+        sizer_9.Add(self.button_5, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_9.Add(self.static_line_6, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_10.Add(self.button_6, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_9.Add(sizer_10, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_8.Add(sizer_9, 1, wxEXPAND, 0)
+        sizer_8.Add(self.static_line_7, 0, wxEXPAND, 0)
+        sizer_11.Add(self.button_7, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_11.Add(self.static_line_8, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_12b.Add(self.button_8, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_12b.Add(self.button_9, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_11.Add(sizer_12b, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_8.Add(sizer_11, 1, wxEXPAND, 0)
+        sizer_2.Add(sizer_8, 1, wxEXPAND, 0)
+        sizer_1.Add(sizer_2, 1, wxEXPAND, 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, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(self.static_line_8, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_16.Add(self.button_11, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(sizer_16, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_17.Add(self.button_12, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_15.Add(sizer_17, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_15, 1, wxEXPAND, 0)
+        sizer_14.Add(self.static_line_10, 0, wxEXPAND, 0)
+        sizer_18.Add(self.button_13, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(self.static_line_11, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_19.Add(self.label_1, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_19.Add(self.spin_ctrl_1, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_19, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_20.Add(self.label_2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_20.Add(self.spin_ctrl_2, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_20, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_21.Add(self.label_3, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_21.Add(self.spin_ctrl_3, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_18.Add(sizer_21, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_18, 1, wxEXPAND, 0)
+        sizer_14.Add(self.static_line_12, 0, wxEXPAND, 0)
+        sizer_22.Add(self.button_14, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(self.static_line_13, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_23.Add(self.button_15, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(sizer_23, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_24.Add(self.button_16, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_22.Add(sizer_24, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_14.Add(sizer_22, 1, wxEXPAND, 0)
+        sizer_13.Add(sizer_14, 1, wxEXPAND, 0)
+        sizer_12.Add(sizer_13, 1, wxEXPAND, 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, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(self.static_line_14, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_29.Add(self.label_4, 0, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.spin_ctrl_4, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.label_5, 0, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_29.Add(self.spin_ctrl_5, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(sizer_29, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_30.Add(self.label_6, 0, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_30.Add(self.spin_ctrl_6, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_28.Add(sizer_30, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_27.Add(sizer_28, 1, wxEXPAND, 0)
+        sizer_27.Add(self.static_line_15, 0, wxEXPAND, 0)
+        sizer_31.Add(self.button_18, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(self.static_line_16, 0, wxLEFT|wxRIGHT|wxEXPAND, 20)
+        sizer_32.Add(self.button_19, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_32.Add(self.button_20, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(sizer_32, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_33.Add(self.button_21, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5)
+        sizer_31.Add(sizer_33, 1, wxALIGN_CENTER_HORIZONTAL, 0)
+        sizer_27.Add(sizer_31, 1, wxEXPAND, 0)
+        sizer_26.Add(sizer_27, 1, wxEXPAND, 0)
+        sizer_25.Add(sizer_26, 1, wxEXPAND, 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(wxNotebookSizer(self.notebook_1), 1, wxLEFT|wxRIGHT|wxBOTTOM|wxEXPAND, 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, wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 0)
+        self.SetAutoLayout(1)
+        self.SetSizer(sizer_frame)
+        sizer_frame.Fit(self)
+        sizer_frame.SetSizeHints(self)
+        self.Layout()
+        # end wxGlade
+
+        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):
+        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=wxPen(colour, 1, wxSOLID))
+        elif id==self.ide[9]:
+            self.parent.SetWatchPenBrush(b=wxBrush(colour, wxSOLID))
+        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 = wxFontData()
+        data.EnableEffects(True)
+        data.SetColour(colour)
+        data.SetInitialFont(font)
+
+        dlg = wxFontDialog(self, data)
+        if dlg.ShowModal() == wxID_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 = wxMultipleChoiceDialog(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() == wxID_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 = wxSingleChoiceDialog(self,
+                                       "Select a style for the hours:",
+                                       "Styles", x, wxCHOICEDLG_STYLE)
+            for i in range(0,len(m)):
+                if m[i]:
+                    dlg.SetSelection(i)
+
+            if dlg.ShowModal() == wxID_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 = wxSingleChoiceDialog(self,
+                                       "Select a style for the minutes:",
+                                       "Styles", x, wxCHOICEDLG_STYLE)
+            for i in range(0,len(m)):
+                if m[i]:
+                    dlg.SetSelection(i)
+
+            if dlg.ShowModal() == wxID_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=wxPen(colour, 1, wxSOLID), b=wxBrush(colour, wxSOLID))
+        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(wxFont(1, wxSWISS, wxNORMAL, wxBOLD))
+        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
+
+