# -*- 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ã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