]> git.saurik.com Git - wxWidgets.git/blob - wxPython/wx/lib/analogclock.py
Fix or add some DoGetBestSize's
[wxWidgets.git] / wxPython / wx / lib / analogclock.py
1 # -*- coding: iso-8859-1 -*-
2 #----------------------------------------------------------------------
3 # Name: wx.lib.analogclock
4 # Purpose: A simple analog clock window
5 #
6 # Author: several folks on wxPython-users
7 #
8 # Created: 16-April-2003
9 # RCS-ID: $Id$
10 # Copyright: (c) 2003 by Total Control Software
11 # Licence: wxWindows license
12 #----------------------------------------------------------------------
13 # 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
14 #
15 # o Updated for wx namespace
16 # o Tested with updated demo and with builtin test.
17 #
18 # 15-February-2004 - E. A. Tacao
19 #
20 # o Many ehnacements
21 #
22
23
24 import math
25 import sys
26 import string
27 import time
28
29 import wx
30
31 from analogclockopts import ACCustomizationFrame
32
33
34 # self.clockStyle:
35 SHOW_QUARTERS_TICKS = 1
36 SHOW_HOURS_TICKS = 2
37 SHOW_MINUTES_TICKS = 4
38 ROTATE_TICKS = 8
39 SHOW_HOURS_HAND = 16
40 SHOW_MINUTES_HAND = 32
41 SHOW_SECONDS_HAND = 64
42 SHOW_SHADOWS = 128
43 OVERLAP_TICKS = 256
44
45 # self.tickMarkHoursStyle and self.tickMarkMinutesStyle:
46 TICKS_NONE = 1
47 TICKS_SQUARE = 2
48 TICKS_CIRCLE = 4
49 TICKS_POLY = 8
50 TICKS_DECIMAL = 16
51 TICKS_ROMAN = 32
52
53
54 class AnalogClockWindow(wx.PyWindow):
55 """An analog clock window"""
56
57 def __init__(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
58 style=0, name="clock"):
59
60 # Initialize the wxWindow...
61 wx.PyWindow.__init__(self, parent, ID, pos, size, style, name)
62
63 # Initialize some variables and defaults...
64 self.clockStep = 1
65 self.prefs_open = False
66
67 self.tickShapeHours = self.tickShapeMinutes= [[0,0],
68 [1,-1],
69 [2,0],
70 [1,4]]
71 self.handHoursThickness = 5
72 self.handHoursColour = (0, 0, 0)
73
74 self.handMinutesThickness = 3
75 self.handMinutesColour = (0, 0, 0)
76
77 self.handSecondsThickness = 1
78 self.handSecondsColour = (0, 0, 0)
79
80 self.tickMarkHoursPen = wx.Pen((0, 0, 0), 1, wx.SOLID)
81 self.tickMarkHoursBrush = wx.Brush((0, 0, 0), wx.SOLID)
82 self.markSizeHour = 10
83 self.tickMarkHoursFont = wx.Font(0, wx.SWISS, wx.NORMAL, wx.BOLD)
84 self.tickMarkHoursFont.SetPointSize(self.markSizeHour)
85
86 self.tickMarkMinutesPen = wx.Pen((0, 0, 0), 1, wx.SOLID)
87 self.tickMarkMinutesBrush = wx.Brush((0, 0, 0), wx.SOLID)
88 self.markSizeMin = 6
89 self.tickMarkMinutesFont = wx.Font(self.markSizeMin, wx.SWISS, wx.NORMAL, wx.BOLD)
90
91 self.offM = 0
92
93 self.shadowPenColour = self.shadowBrushColour = (128,128,128)
94
95 self.watchPen = None
96 self.watchBrush = None
97
98 self.clockStyle = SHOW_HOURS_TICKS | SHOW_MINUTES_TICKS | SHOW_SHADOWS | ROTATE_TICKS
99 self.handsStyle = SHOW_SECONDS_HAND
100
101 self.tickMarkHoursStyle = TICKS_POLY
102 self.tickMarkMinutesStyle = TICKS_CIRCLE
103
104 self.currentTime=None
105
106 # Make an initial bitmap for the face, it will be updated and
107 # painted at the first EVT_SIZE event.
108 W, H = size
109 self.faceBitmap = wx.EmptyBitmap(max(W,1), max(H,1))
110
111 # Set event handlers...
112 self.Bind(wx.EVT_PAINT, self.OnPaint)
113 self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x: None)
114 self.Bind(wx.EVT_SIZE, self.OnSize)
115 self.Bind(wx.EVT_TIMER, self.OnTimerExpire)
116 self.Bind(wx.EVT_WINDOW_DESTROY, self.OnQuit)
117 self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
118 self.Bind(wx.EVT_RIGHT_UP, self.OnRightClick)
119
120
121 # Initialize the timer that drives the update of the clock
122 # face. Update every half second to ensure that there is at
123 # least one true update during each realtime second.
124 self.timer = wx.Timer(self)
125 self.timer.Start(500)
126
127 def DoGetBestSize(self):
128 return wx.Size(25,25)
129
130 def OnPaint(self, event):
131 self._doDrawHands(wx.BufferedPaintDC(self), True)
132
133
134 def OnTimerExpire(self, event):
135 size = self.GetClientSize()
136 dc = wx.BufferedDC(wx.ClientDC(self), size)
137 self._doDrawHands(dc, True)
138
139
140 def OnQuit(self, event):
141 self.timer.Stop()
142 del self.timer
143
144
145 def OnRightDown(self, event):
146 self.x = event.GetX()
147 self.y = event.GetY()
148 event.Skip()
149
150
151 def OnRightClick(self, event):
152 # only do this part the first time so the events are only bound once
153 if not hasattr(self, "popupID1"):
154 self.popupID1 = wx.NewId()
155 self.popupID2 = wx.NewId()
156 self.Bind(wx.EVT_MENU, self.OnPopupOne, id=self.popupID1)
157 self.Bind(wx.EVT_MENU, self.OnPopupTwo, id=self.popupID2)
158
159 # make a menu
160 sm = wx.Menu()
161
162 sm.Append(self.popupID1, "Customize...")
163 sm.Append(self.popupID2, "About...")
164
165 # If there already a setup window open, we must not appear...
166 if not self.prefs_open:
167 # Popup the menu. If an item is selected then its handler
168 # will be called before PopupMenu returns.
169 self.PopupMenu(sm, (self.x,self.y))
170 sm.Destroy()
171
172
173 def OnPopupOne(self, event):
174 self.prefs_open=True
175 frame = ACCustomizationFrame(self, -1, "AnalogClock Preferences")
176 frame.Show(True)
177
178
179 def OnPopupTwo(self, event):
180 dlg = wx.MessageDialog(self, "AnalogClockWindow\n\nby Several folks on wxPython-users\nwith enhancements from E. A. Tacão",
181 'About', wx.OK | wx.ICON_INFORMATION)
182 dlg.ShowModal()
183 dlg.Destroy()
184
185
186 def OnSize(self, event):
187 # The faceBitmap init is done here, to make sure the buffer is always
188 # the same size as the Window
189 size = self.GetClientSize()
190 self.faceBitmap = wx.EmptyBitmap(size.width, size.height)
191
192 # Update drawing coordinates...
193 new_dim = size.Get()
194 if not hasattr(self,"dim"):
195 self.dim = new_dim
196
197 x,y=[0,1]
198 self.scale = min([float(new_dim[x]) / self.dim[x],
199 float(new_dim[y]) / self.dim[y]])
200
201 self.centerX = self.faceBitmap.GetWidth() / 2
202 self.centerY = self.faceBitmap.GetHeight() / 2
203
204 self.shadowDistance = 2 * self.scale
205
206 self.radius_watch = min(self.centerX, self.centerY)
207
208 self._doDrawFace()
209
210
211
212 def _doDrawHands(self, drawDC, force=0):
213 currentTime = list(time.localtime(time.time())[3:6])
214
215 if not (self.handsStyle & SHOW_SECONDS_HAND):
216 currentTime[2]=-1
217
218 if not (force or currentTime != self.currentTime):
219 return
220 self.currentTime = currentTime
221 hour, minutes, seconds = currentTime
222
223 # Start by drawing the face bitmap
224 drawDC.DrawBitmap(self.faceBitmap, (0,0))
225
226
227 # NOTE: All this hand drawing code below should be refactored into a helper function.
228
229
230 # Draw hours hand shadow
231 mStep = 6 * self.clockStep
232 angle = hour * 30
233 if angle > 360:
234 angle = angle - 360
235 angle = angle + round(minutes/(mStep*2)) * mStep
236
237 x,y,f = self._getCoords("hand_hours", angle)
238
239 if f and self.clockStyle & SHOW_SHADOWS:
240 drawDC.SetPen(wx.Pen(self.shadowPenColour,
241 int(self.handHoursThickness * self.scale),
242 wx.SOLID))
243 drawDC.DrawLineXY(int(self.centerX + self.shadowDistance),
244 int(self.centerY + self.shadowDistance),
245 int(x + self.shadowDistance),
246 int(y + self.shadowDistance))
247
248 # Draw minutes hand shadow
249 angle = minutes * 6
250 x,y,f = self._getCoords("hand_minutes", angle)
251
252 if f and self.clockStyle & SHOW_SHADOWS:
253 drawDC.SetPen(wx.Pen(self.shadowPenColour,
254 int(self.handMinutesThickness * self.scale),
255 wx.SOLID))
256 drawDC.DrawLineXY(int(self.centerX + self.shadowDistance),
257 int(self.centerY + self.shadowDistance),
258 int(x + self.shadowDistance),
259 int(y + self.shadowDistance))
260
261 # Draw seconds hand shadow if required
262 if seconds >= 0:
263 angle = seconds * 6
264 x,y,f = self._getCoords("hand_seconds", angle)
265
266 if f and self.clockStyle & SHOW_SHADOWS:
267 drawDC.SetPen(wx.Pen(self.shadowPenColour,
268 int(self.handSecondsThickness * self.scale),
269 wx.SOLID))
270 drawDC.DrawLineXY(int(self.centerX + self.shadowDistance),
271 int(self.centerY + self.shadowDistance),
272 int(x + self.shadowDistance),
273 int(y + self.shadowDistance))
274
275
276 # Draw hours hand
277 angle = hour * 30
278 if angle > 360:
279 angle = angle - 360
280 angle = angle + round(minutes/(mStep*2)) * mStep
281
282 x,y,f = self._getCoords("hand_hours", angle)
283
284 if f:
285 drawDC.SetPen(wx.Pen(self.handHoursColour,
286 int(self.handHoursThickness * self.scale),
287 wx.SOLID))
288 drawDC.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(y))
289
290 # Draw minutes hand
291 angle = minutes * 6
292 x,y,f = self._getCoords("hand_minutes", angle)
293
294 if f:
295 drawDC.SetPen(wx.Pen(self.handMinutesColour,
296 int(self.handMinutesThickness * self.scale),
297 wx.SOLID))
298 drawDC.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(y))
299
300 # Draw seconds hand if required
301 if seconds >= 0:
302 angle = seconds * 6
303 x,y,f = self._getCoords("hand_seconds", angle)
304 if f:
305 drawDC.SetPen(wx.Pen(self.handSecondsColour,
306 int(self.handSecondsThickness * self.scale),
307 wx.SOLID))
308 drawDC.DrawLineXY(int(self.centerX), int(self.centerY), int(x), int(y))
309
310
311
312 def _doDrawFace(self):
313 backgroundBrush = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
314 drawDC = wx.MemoryDC()
315 drawDC.SelectObject(self.faceBitmap)
316 drawDC.SetBackground(backgroundBrush)
317 drawDC.Clear()
318
319 self.handHoursLength = 0.65 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
320 self.handMinutesLength = 0.85 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
321 self.handSecondsLength = 0.85 * (self.radius_watch - self._getMarkMaxSize("ticks_hours", drawDC))
322
323 self.radius_ticks_hours = self.radius_watch - self.shadowDistance - self._getMarkMaxSize("ticks_hours", drawDC)
324 self.radius_ticks_minutes = self.radius_ticks_hours
325
326 self._calcSteps()
327
328 # Draw the watch...
329 self._drawWatch(drawDC)
330
331 # Draw the marks for hours and minutes...
332 circle = 360
333 mStep = 6 * self.clockStep
334
335 if self.clockStyle & SHOW_SHADOWS:
336 for i in range(0, circle, mStep):
337 for t in self.coords.keys():
338 if t.find("ticks") > -1:
339 x,y,f = self._getCoords(t, i)
340 if f:
341 self._doDrawTickMark(i, drawDC, t,
342 x + self.shadowDistance,
343 y + self.shadowDistance,
344 True)
345
346 for i in range(0, circle, mStep):
347 for t in self.coords.keys():
348 if t.find("ticks") > -1:
349 x,y,f = self._getCoords(t, i)
350 if f:
351 self._doDrawTickMark(i, drawDC, t, x, y)
352
353
354
355 def _doDrawTickMark(self, angle, drawDC, tipo, x, y, is_a_shadow=None):
356 opts = {"ticks_hours": [self.tickMarkHoursPen, self.tickMarkHoursBrush, self.markSizeHour, self.tickMarkHoursStyle],
357 "ticks_quarters": [self.tickMarkHoursPen, self.tickMarkHoursBrush, self.markSizeHour, self.tickMarkHoursStyle],
358 "ticks_minutes": [self.tickMarkMinutesPen, self.tickMarkMinutesBrush, self.markSizeMin, self.tickMarkMinutesStyle]}
359
360 pen, brush, size, style = opts[tipo];
361 size = size * self.scale
362
363 if is_a_shadow:
364 drawDC.SetPen(wx.Pen(self.shadowPenColour, 1, wx.SOLID))
365 drawDC.SetBrush(wx.Brush(self.shadowBrushColour, wx.SOLID))
366 drawDC.SetTextForeground(self.shadowBrushColour)
367 else:
368 drawDC.SetPen(pen)
369 drawDC.SetBrush(brush)
370 drawDC.SetTextForeground(brush.GetColour())
371
372 if style & TICKS_CIRCLE:
373 x, y = self._center2corner(x, y, tipo)
374 drawDC.DrawEllipse((x, y), (int(size), int(size)))
375
376 elif style & TICKS_SQUARE:
377 x, y = self._center2corner(x, y, tipo)
378 drawDC.DrawRectangle((x, y), (int(size), int(size)))
379
380 elif (style & TICKS_DECIMAL) or (style & TICKS_ROMAN):
381 self._draw_rotate_text(drawDC, x, y, tipo, angle)
382
383 elif style & TICKS_POLY:
384 self._draw_rotate_polygon(drawDC, x, y, tipo, angle)
385
386
387 def _draw_rotate_text(self, drawDC, x, y, tipo, angle):
388 text = self._build_text(angle, tipo)
389 lX, lY = self._center2corner(x, y, tipo, drawDC)
390 lX = lX * len(text)
391 angle = 360 - angle
392
393 if self.clockStyle & ROTATE_TICKS:
394 radiansPerDegree = math.pi / 180
395 x = int(x -
396 ((math.cos((angle) * radiansPerDegree)*lX) +
397 (math.sin((angle) * radiansPerDegree)*lY)))
398 y = int(y -
399 ((math.cos((angle) * radiansPerDegree)*lY) -
400 (math.sin((angle) * radiansPerDegree)*lX)))
401 drawDC.DrawRotatedText(text, (x,y), angle)
402
403 else:
404 x = x - lX
405 y = y - lY
406 drawDC.DrawText(text, (x, y))
407
408
409 def _draw_rotate_polygon(self, drawDC, x, y, tipo, angle):
410 if tipo=="ticks_quarters":
411 tipo="ticks_hours"
412
413 # Add to empty list to prevent system-wide hard freezes under XP...
414 points = {"ticks_hours":self.tickShapeHours+[], "ticks_minutes":self.tickShapeMinutes+[]}[tipo]
415 size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
416
417 maxX = max(map(lambda x:x[0],points))
418 minX = min(map(lambda x:x[0],points))
419 maxY = max(map(lambda x:x[0],points))
420 minY = min(map(lambda x:x[0],points))
421
422 maxB = abs(max(maxX, maxY));
423 f = size / maxB
424
425 orgX = (maxX - minX) / 2.
426 orgY = (maxY - minY) / 2.
427
428 radiansPerDegree = math.pi / 180
429 scaledX = x
430 scaledY = y
431
432 for z in range(0, len(points)):
433 x,y = points[z]
434 x = x * f - orgX * f
435 y = y * f - orgY * f
436 if self.clockStyle & ROTATE_TICKS:
437 m,t = self._rect2pol(x,y)
438 t = t + angle
439 x,y = self._pol2rect(m,t)
440 x = x + scaledX
441 y = y + scaledY
442 points[z] = [int(x), int(y)]
443
444 drawDC.DrawPolygon(points)
445
446
447 def _pol2rect(self, r, w, deg=1): # radian if deg=0; degree if deg=1
448 if deg:
449 w = math.pi * w / 180.0
450 return r * math.cos(w), r * math.sin(w)
451
452
453 def _rect2pol(self, x, y, deg=1): # radian if deg=0; degree if deg=1
454 if deg:
455 return math.hypot(x, y), 180.0 * math.atan2(y, x) / math.pi
456 else:
457 return math.hypot(x, y), math.atan2(y, x)
458
459
460 def _center2corner(self, x, y, tipo, drawDC=None):
461 if tipo == "ticks_quarters":
462 tipo = "ticks_hours"
463
464 style = {"ticks_hours":self.tickMarkHoursStyle, "ticks_minutes":self.tickMarkMinutesStyle}[tipo]
465 size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
466
467 if style & TICKS_DECIMAL or style & TICKS_ROMAN:
468 font = {"ticks_hours":self.tickMarkHoursFont, "ticks_minutes":self.tickMarkMinutesFont}[tipo]
469 font.SetPointSize(int(size));
470 drawDC.SetFont(font)
471 lX = drawDC.GetCharWidth() / 2.
472 lY = drawDC.GetCharHeight() / 2.
473 x = lX
474 y = lY
475 else:
476 size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
477 x=x-size/2.;y=y-size/2.
478 return x, y
479
480
481 def _build_text(self, angle, tipo):
482 if tipo == "ticks_quarters":
483 tipo = "ticks_hours"
484 a = angle
485 if a <= 0:
486 a = a + 360
487 divider = {"ticks_hours":30,"ticks_minutes":6}[tipo]
488 a = int(a / divider)
489
490 style = {"ticks_hours":self.tickMarkHoursStyle," ticks_minutes":self.tickMarkMinutesStyle}[tipo]
491 if style & TICKS_ROMAN:
492 text=["I","II","III","IV","V","VI","VII","VIII","IX","X", \
493 "XI","XII","XIII","XIV","XV","XVI","XVII","XVIII","XIX","XX", \
494 "XXI","XXII","XXIII","XXIV","XXV","XXVI","XXVII","XXVIII","XXIX","XXX", \
495 "XXXI","XXXII","XXXIII","XXXIV","XXXV","XXXVI","XXXVII","XXXVIII","XXXIX","XL", \
496 "XLI","XLII","XLIII","XLIV","XLV","XLVI","XLVII","XLVIII","XLIX","L", \
497 "LI","LII","LIII","LIV","LV","LVI","LVII","LVIII","LIX","LX"][a-1]
498 else:
499 text = "%s" % a
500
501 return text
502
503
504 def _getMarkMaxSize(self, tipo, drawDC=None):
505 if tipo == "ticks_quarters":
506 tipo = "ticks_hours"
507
508 style = {"ticks_hours":self.tickMarkHoursStyle, "ticks_minutes":self.tickMarkMinutesStyle}[tipo]
509 size = self.scale * {"ticks_hours":self.markSizeHour, "ticks_minutes":self.markSizeMin}[tipo]
510
511 if style & TICKS_DECIMAL or style & TICKS_ROMAN:
512 lX = 2 * drawDC.GetCharWidth()
513 lY = drawDC.GetCharHeight()
514 size = math.sqrt(lX**2 + lY**2) * self.scale
515 else:
516 size=math.sqrt(2) * size
517
518 return size
519
520
521 def _drawWatch(self, drawDC):
522 # Draw the watch...
523 if self.watchPen or self.watchBrush:
524 if self.watchPen:
525 drawDC.SetPen(self.watchPen)
526 if self.watchBrush:
527 drawDC.SetBrush(self.watchBrush)
528 else:
529 drawDC.SetBrush(wx.Brush(self.GetBackgroundColour(), wx.SOLID))
530 drawDC.DrawCircle((self.centerX, self.centerY), self.radius_watch)
531
532
533 def _calcSteps(self):
534 # Calcule todos os pontos para:
535 # - marcas de horas
536 # - marcas de minutos
537 # - ponteiro de horas
538 # - ponteiro de minutos
539 # - ponteiro de segundos
540
541 circle = 360
542 mStep = 6 * self.clockStep # Step in degrees...
543
544 vq = 90 * (self.clockStyle & SHOW_QUARTERS_TICKS) / SHOW_QUARTERS_TICKS
545 vh = 30 * (self.clockStyle & SHOW_HOURS_TICKS) / SHOW_HOURS_TICKS
546 vm = 1 * (self.clockStyle & SHOW_MINUTES_TICKS) / SHOW_MINUTES_TICKS
547
548 coords = {"ticks_quarters": [self.radius_ticks_hours, 60,vq,{}],
549 "ticks_hours": [self.radius_ticks_hours, 60,vh,{}],
550 "ticks_minutes": [self.radius_ticks_minutes,60,vm,{}],
551 "hand_hours": [self.handHoursLength, 60,1, {}],
552 "hand_minutes": [self.handMinutesLength, 60,1, {}],
553 "hand_seconds": [self.handSecondsLength, 60,1, {}]}
554
555 radiansPerDegree = math.pi / 180
556
557 for t in coords.keys():
558 for i in range(0, circle+mStep, mStep):
559 radius = coords[t][0]
560 if t == "ticks_minutes":
561 radius = radius - self.offM
562 step_angle = 360. / coords[t][1]
563 pre = coords[t][2]
564 x = self.centerX + radius * math.sin(i * radiansPerDegree)
565 y = self.centerY + radius * math.cos(i * radiansPerDegree)
566 f = (pre and (i/step_angle == int(i/step_angle)) and (float(i)/pre == int(i/pre)))
567 coords[t][3][i] = [x,y,f]
568
569 if not self.clockStyle & OVERLAP_TICKS:
570 for i in range(0, circle + mStep, mStep):
571 f=coords["ticks_minutes"][3][i][2]
572 if f and \
573 (coords["ticks_hours"][3].get(i,[0,0,0])[2] or coords["ticks_quarters"][3].get(i,[0,0,0])[2]):
574 f=False
575 coords["ticks_minutes"][3][i][2]=f
576
577 self.coords=coords
578
579
580 def _getCoords(self, tipo, angle):
581 # Returns coords and 'use flag' based on current angle...
582 k = 360 - (angle + 180)
583 if k <= 0:
584 k = k + 360
585 return self.coords[tipo][3][k]
586
587
588 # -----------------------------------------------------
589 #
590 def SetTickShapes(self, tsh, tsm=None):
591 """
592 tsh, tsm: [[x0,y0], [x1,y1], ... [xn,yn]]
593
594 Sets lists of lists of points to be used as polygon shapes
595 when using the TICKS_POLY style. If tsm is ommitted,
596 we'll use tsh for both shapes.
597 """
598
599 if not tsm:
600 tsm=tsh
601
602 self.tickShapeHours = tsh
603 self.tickShapeMinutes = tsm
604
605
606 def SetHandWeights(self, h=None, m=None, s=None):
607 """
608 h, m, s: value
609
610 Sets thickness of hands.
611 """
612
613 if h:
614 self.handHoursThickness = h
615 if m:
616 self.handMinutesThickness = m
617 if s:
618 self.handSecondsThickness = s
619
620
621 def SetHandColours(self, h=None, m=None, s=None):
622 """
623 h, m, s: wx.Colour
624
625 Sets colours of hands. If m and s are ommitted,
626 we'll use h for all.
627 """
628
629 if h and not m and not s:
630 m=h
631 s=h
632
633 if h:
634 self.handHoursColour = h
635 if m:
636 self.handMinutesColour = m
637 if s:
638 self.handSecondsColour = s
639
640
641 def SetTickColours(self, h=None, m=None):
642 """
643 h, m: wx.Colour
644
645 Sets colours of ticks. If m is ommitted,
646 we'll use h for both.
647 """
648
649 if not m:
650 m=h
651
652 if h:
653 self.tickMarkHoursPen = wx.Pen(h, 1, wx.SOLID)
654 self.tickMarkHoursBrush = wx.Brush(h, wx.SOLID)
655
656 if m:
657 self.tickMarkMinutesPen = wx.Pen(m, 1, wx.SOLID)
658 self.tickMarkMinutesBrush = wx.Brush(m, wx.SOLID)
659
660
661 def SetTickSizes(self, h=None, m=None):
662 """
663 h, m: value
664
665 Sizes for tick marks.
666 """
667
668 if h:
669 self.markSizeHour = h
670 if m:
671 self.markSizeMin = m
672
673
674 def SetTickFonts(self, h=None, m=None):
675 """
676 h, m: wx.Font
677
678 Fonts for tick marks when using TICKS_DECIMAL or TICKS_ROMAN style.
679 If m is ommitted, we'll use h for both.
680 """
681
682 if not m:
683 m=h
684
685 if h:
686 self.tickMarkHoursFont = h
687 self.tickMarkHoursFont.SetPointSize(self.markSizeHour)
688 if m:
689 self.tickMarkMinutesFont = m
690 self.tickMarkMinutesFont.SetPointSize(self.markSizeMin)
691
692
693 def SetMinutesOffset(self, o):
694 """
695 s = value
696
697 Sets the distance between tick marks for hours and minutes.
698 """
699 self.offM = o
700
701
702 def SetShadowColour(self, s):
703 """
704 s = wx.Colour or (r,g,b) tuple.
705
706 Sets the colour to be used to draw shadows.
707 """
708
709 self.shadowPenColour = self.shadowBrushColour = s
710
711
712 def SetWatchPenBrush(self, p=None, b=None):
713 """
714 p = wx.Pen; b = wx.Brush
715
716 Set the pen and brush for the watch.
717 """
718
719 if p:
720 self.watchPen = p
721 if b:
722 self.watchBrush = b
723
724
725 def SetClockStyle(self, style):
726 """
727 Set the clock style, acording to the options:
728
729 SHOW_QUARTERS_TICKS - Show marks for hours 3, 6, 9, 12
730 SHOW_HOURS_TICKS - Show marks for all hours
731 SHOW_MINUTES_TICKS - Show marks for minutes
732
733 SHOW_HOURS_HAND - Show hours hand
734 SHOW_MINUTES_HAND - Show minutes hand
735 SHOW_SECONDS_HAND - Show seconds hand
736
737 SHOW_SHADOWS - Show hands and marks shadows
738
739 ROTATE_TICKS - Align tick marks to watch
740 OVERLAP_TICKS - Draw tick marks for minutes even
741 when they match the hours marks.
742 """
743
744 self.clockStyle = style
745
746
747 def SetTickStyles(self, h=None, m=None):
748 """
749 Set the ticks styles, acording to the options below.
750
751 TICKS_NONE = Don't show tick marks.
752 TICKS_SQUARE = Use squares as tick marks.
753 TICKS_CIRCLE = Use circles as tick marks.
754 TICKS_POLY = Use a polygon as tick marks. The polygon
755 must be passed using SetTickShapes,
756 otherwise the default polygon will be used.
757 TICKS_DECIMAL = Use decimal numbers.
758 TICKS_ROMAN = Use Roman numbers.
759 """
760
761 if h:
762 self.tickMarkHoursStyle = h
763 if m:
764 self.tickMarkMinutesStyle = m
765 #
766 # -----------------------------------------------------
767
768
769 if __name__ == "__main__":
770 print wx.VERSION_STRING
771 class App(wx.App):
772 def OnInit(self):
773 frame = wx.Frame(None, -1, "AnalogClockWindow", size=(375,375))
774
775 clock = AnalogClockWindow(frame)
776
777 # Settings below are used by default...
778 #clock.SetClockStyle(SHOW_HOURS_TICKS|SHOW_MINUTES_TICKS|SHOW_SHADOWS|ROTATE_TICKS)
779 #clock.SetTickStyles(TICKS_POLY, TICKS_CIRCLE)
780
781 frame.Centre(wx.BOTH)
782 frame.Show(True)
783 self.SetTopWindow(frame)
784 return True
785
786 theApp = App(0)
787 theApp.MainLoop()
788
789
790 #
791 ##
792 ### eof