wxPython/wx/lib/calendar.py

   1 #----------------------------------------------------------------------------
   2 # Name:         calendar.py
   3 # Purpose:      Calendar display control
   4 #
   5 # Author:       Lorne White (email: lorne.white@telusplanet.net)
   6 #
   7 # Created:
   8 # Version       0.92
   9 # Date:         Nov 26, 2001
  10 # Licence:      wxWindows license
  11 #----------------------------------------------------------------------------
  12 # 12/01/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  13 #
  14 # o Updated for wx namespace
  15 # o Tested with updated demo
  16 # o Added new event type EVT_CALENDAR. The reason for this is that the original
  17 #   library used a hardcoded ID of 2100 for generating events. This makes it
  18 #   very difficult to fathom when trying to decode the code since there's no
  19 #   published API. Creating the new event binder might seem like overkill -
  20 #   after all, you might ask, why not just use a new event ID and be done with
  21 #   it? However, a consistent interface is very useful at times; also it makes
  22 #   it clear that we're not just hunting for mouse clicks -- we're hunting
  23 #   wabbit^H^H^H^H (sorry bout that) for calender-driven mouse clicks. So
  24 #   that's my sad story. Shoot me if you must :-)
  25 # o There's still one deprecation warning buried in here somewhere, but I
  26 #   haven't been able to find it yet. It only occurs when displaying a
  27 #   print preview, and only the first time. It *could* be an error in the
  28 #   demo, I suppose.
  29 #
  30 #   Here's the traceback:
  31 #
  32 #   C:\Python\lib\site-packages\wx\core.py:949: DeprecationWarning:
  33 #       integer argument expected, got float
  34 #   newobj = _core.new_Rect(*args, **kwargs)
  35 #
  36 # 12/17/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  37 #
  38 # o A few style-guide nips and tucks
  39 # o Renamed wxCalendar to Calendar
  40 # o Couple of bugfixes
  41 #
  42 # 06/02/2004 - Joerg "Adi" Sieker adi@sieker.info
  43 #
  44 # o Changed color handling, use dictionary instead of members.
  45 #   This causes all color changes to be ignored if they manipluate the members directly.
  46 #   SetWeekColor and other method color methods were adapted to use the new dictionary.
  47 # o Added COLOR_* constants
  48 # o Added SetColor method for Calendar class
  49 # o Added 3D look of week header
  50 # o Added colors for 3D look of header
  51 # o Fixed width calculation.
  52 #   Because of rounding difference the total width and height of the
  53 #   calendar could be up to 6 pixels to small. The last column and row
  54 #   are now wider/taller by the missing amount.
  55 # o Added SetTextAlign method to wxCalendar. This exposes logic
  56 #   which was already there.
  57 # o Fixed CalDraw.SetMarg which set set_x_st and set_y_st which don't get used anywhere.
  58 #   Instead set set_x_mrg and set_y_mrg
  59 # o Changed default X and Y Margin to 0.
  60 # o Added wxCalendar.SetMargin.
  61 #
  62 # 17/03/2004 - Joerg "Adi" Sieker adi@sieker.info
  63 # o Added keyboard navigation to the control.
  64 #   Use the cursor keys to navigate through the ages. :)
  65 #   The Home key function as go to today
  66 # o select day is now a filled rect instead of just an outline
  67
  68 import wx
  69
  70 from CDate import *
  71
  72 CalDays = [6, 0, 1, 2, 3, 4, 5]
  73 AbrWeekday = {6:"Sun", 0:"Mon", 1:"Tue", 2:"Wed", 3:"Thu", 4:"Fri", 5:"Sat"}
  74 _MIDSIZE = 180
  75
  76 COLOR_GRID_LINES = "grid_lines"
  77 COLOR_BACKGROUND = "background"
  78 COLOR_SELECTION_FONT = "selection_font"
  79 COLOR_SELECTION_BACKGROUND = "selection_background"
  80 COLOR_BORDER = "border"
  81 COLOR_HEADER_BACKGROUND = "header_background"
  82 COLOR_HEADER_FONT = "header_font"
  83 COLOR_WEEKEND_BACKGROUND = "weekend_background"
  84 COLOR_WEEKEND_FONT = "weekend_font"
  85 COLOR_FONT = "font"
  86 COLOR_3D_LIGHT = "3d_light"
  87 COLOR_3D_DARK = "3d_dark"
  88 COLOR_HIGHLIGHT_FONT = "highlight_font"
  89 COLOR_HIGHLIGHT_BACKGROUND = "highlight_background"
  90
  91 BusCalDays = [0, 1, 2, 3, 4, 5, 6]
  92
  93 # Calendar click event - added 12/1/03 by jmg (see above)
  94 wxEVT_COMMAND_PYCALENDAR_DAY_CLICKED = wx.NewEventType()
  95 EVT_CALENDAR = wx.PyEventBinder(wxEVT_COMMAND_PYCALENDAR_DAY_CLICKED, 1)
  96
  97 def GetMonthList():
  98     monthlist = []
  99     for i in range(13):
 100         name = Month[i]
 101         if name != None:
 102             monthlist.append(name)
 103     return monthlist
 104
 105 def MakeColor(in_color):
 106     try:
 107         color = wxNamedColour(in_color)
 108     except:
 109         color = in_color
 110     return color
 111
 112 def DefaultColors():
 113     colors = {}
 114     colors[COLOR_GRID_LINES] = 'BLACK'
 115     colors[COLOR_BACKGROUND] = 'WHITE'
 116     colors[COLOR_SELECTION_FONT]  =  wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
 117     colors[COLOR_SELECTION_BACKGROUND] =wx.Colour(255,255,225)
 118     colors[COLOR_BORDER] = 'BLACK'
 119     colors[COLOR_HEADER_BACKGROUND] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
 120     colors[COLOR_HEADER_FONT] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
 121     colors[COLOR_WEEKEND_BACKGROUND] = 'LIGHT GREY'
 122     colors[COLOR_WEEKEND_FONT] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
 123     colors[COLOR_FONT] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
 124     colors[COLOR_3D_LIGHT] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNHIGHLIGHT)
 125     colors[COLOR_3D_DARK] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)
 126     colors[COLOR_HIGHLIGHT_FONT]  =  wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT)
 127     colors[COLOR_HIGHLIGHT_BACKGROUND] = wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHT)
 128     return colors
 129 # calendar drawing routing
 130
 131 class CalDraw:
 132     def __init__(self, parent):
 133         self.pwidth = 1
 134         self.pheight = 1
 135         try:
 136             self.scale = parent.scale
 137         except:
 138             self.scale = 1
 139
 140         self.gridx = []
 141         self.gridy = []
 142
 143         self.DefParms()
 144
 145     def DefParms(self):
 146         self.num_auto = True    # auto scale of the cal number day size
 147         self.num_size = 12      # default size of calendar if no auto size
 148         self.max_num_size = 12  # maximum size for calendar number
 149
 150         self.num_align_horz = wx.ALIGN_CENTRE    # alignment of numbers
 151         self.num_align_vert = wx.ALIGN_CENTRE
 152         self.num_indent_horz = 0     # points indent from position, used to offset if not centered
 153         self.num_indent_vert = 0
 154
 155         self.week_auto = True       # auto scale of week font text
 156         self.week_size = 10
 157         self.max_week_size = 12
 158
 159         self.colors = DefaultColors()
 160
 161         self.font = wx.SWISS
 162         self.bold = wx.NORMAL
 163
 164         self.hide_title = False
 165         self.hide_grid = False
 166         self.outer_border = True
 167
 168         self.title_offset = 0
 169         self.cal_week_scale = 0.7
 170         self.show_weekend = False
 171         self.cal_type = "NORMAL"
 172
 173     def SetWeekColor(self, font_color, week_color):
 174         # set font and background color for week title
 175         self.colors[COLOR_HEADER_FONT] = MakeColor(font_color)
 176         self.colors[COLOR_HEADER_BACKGROUND] = MakeColor(week_color)
 177         self.colors[COLOR_3D_LIGHT] = MakeColor(week_color)
 178         self.colors[COLOR_3D_DARK] = MakeColor(week_color)
 179
 180     def SetSize(self, size):
 181         self.set_sizew = size[0]
 182         self.set_sizeh = size[1]
 183
 184     def InitValues(self):       # default dimensions of various elements of the calendar
 185         self.rg = {}
 186         self.cal_sel = {}
 187         self.set_cy_st = 0      # start position
 188         self.set_cx_st = 0
 189
 190         self.set_y_mrg = 1      # start of vertical draw default
 191         self.set_x_mrg = 1
 192         self.set_y_end = 1
 193     def SetPos(self, xpos, ypos):
 194         self.set_cx_st = xpos
 195         self.set_cy_st = ypos
 196
 197     def SetMarg(self, xmarg, ymarg):
 198         self.set_x_mrg = xmarg
 199         self.set_y_mrg = ymarg
 200         self.set_y_end = ymarg
 201
 202     def InitScale(self):        # scale position values
 203         self.sizew = int(self.set_sizew * self.pwidth)
 204         self.sizeh = int(self.set_sizeh * self.pheight)
 205
 206         self.cx_st = int(self.set_cx_st * self.pwidth)       # draw start position
 207         self.cy_st = int(self.set_cy_st * self.pheight)
 208
 209         self.x_mrg = int(self.set_x_mrg * self.pwidth)         # calendar draw margins
 210         self.y_mrg = int(self.set_y_mrg * self.pheight)
 211         self.y_end = int(self.set_y_end * self.pheight)
 212
 213     def DrawCal(self, DC, sel_lst=[]):
 214         self.InitScale()
 215
 216         self.DrawBorder(DC)
 217
 218         if self.hide_title is False:
 219             self.DrawMonth(DC)
 220
 221         self.Center()
 222
 223         self.DrawGrid(DC)
 224         self.GetRect()
 225         if self.show_weekend is True:       # highlight weekend dates
 226             self.SetWeekEnd()
 227
 228         self.AddSelect(sel_lst)     # overrides the weekend highlight
 229
 230         self.DrawSel(DC)      # highlighted days
 231         self.DrawWeek(DC)
 232         self.DrawNum(DC)
 233
 234     def AddSelect(self, list, cfont=None, cbackgrd = None):
 235         if cfont is None:
 236             cfont = self.colors[COLOR_SELECTION_FONT]      # font digit color
 237         if cbackgrd is None:
 238             cbackgrd = self.colors[COLOR_SELECTION_BACKGROUND]     # select background color
 239
 240         for val in list:
 241             self.cal_sel[val] = (cfont, cbackgrd)
 242
 243     # draw border around the outside of the main display rectangle
 244     def DrawBorder(self, DC, transparent = False):
 245         if self.outer_border is True:
 246             if transparent == False:
 247                 brush = wx.Brush(MakeColor(self.colors[COLOR_BACKGROUND]), wx.SOLID)
 248             else:
 249                 brush = wx.TRANSPARENT_BRUSH
 250             DC.SetBrush(brush)
 251             DC.SetPen(wx.Pen(MakeColor(self.colors[COLOR_BORDER])))
 252             # full display window area
 253             rect = wx.Rect(self.cx_st, self.cy_st, self.sizew, self.sizeh)
 254             DC.DrawRectangleRect(rect)
 255
 256     def DrawFocusIndicator(self, DC):
 257         if self.outer_border is True:
 258             DC.SetBrush(wx.TRANSPARENT_BRUSH)
 259             DC.SetPen(wx.Pen(MakeColor(self.colors[COLOR_HIGHLIGHT_BACKGROUND]), style=wx.DOT))
 260             # full display window area
 261             rect = wx.Rect(self.cx_st, self.cy_st, self.sizew, self.sizeh)
 262             DC.DrawRectangleRect(rect)
 263
 264     def DrawNumVal(self):
 265         self.DrawNum()
 266
 267     # calculate the calendar days and offset position
 268     def SetCal(self, year, month):
 269         self.InitValues()       # reset initial values
 270
 271         self.year = year
 272         self.month = month
 273
 274         day = 1
 275         t = Date(year, month, day)
 276         dow = self.dow = t.day_of_week     # start day in month
 277         dim = self.dim = t.days_in_month   # number of days in month
 278
 279         if self.cal_type == "NORMAL":
 280             start_pos = dow+1
 281         else:
 282             start_pos = dow
 283
 284         self.st_pos = start_pos
 285
 286         self.cal_days = []
 287         for i in range(start_pos):
 288             self.cal_days.append('')
 289
 290         i = 1
 291         while i <= dim:
 292             self.cal_days.append(str(i))
 293             i = i + 1
 294
 295         self.end_pos = dow + dim
 296
 297         return start_pos
 298
 299     def SetWeekEnd(self, font_color=None, backgrd = None):
 300         if font_color != None:
 301             self.SetColor(COLOR_WEEKEND_FONT, MakeColor(font_color))
 302         if backgrd != None:
 303             self.SetColor(COLOR_WEEKEND_BACKGROUND, MakeColor(backgrd))
 304
 305         date = 6 - int(self.dow)     # start day of first saturday
 306
 307         while date <= self.dim:
 308             self.cal_sel[date] = (self.GetColor(COLOR_WEEKEND_FONT), self.GetColor(COLOR_WEEKEND_BACKGROUND))  # Saturday
 309             date = date + 1
 310
 311             if date <= self.dim:
 312                 self.cal_sel[date] = (self.GetColor(COLOR_WEEKEND_FONT), self.GetColor(COLOR_WEEKEND_BACKGROUND))      # Sunday
 313                 date = date + 6
 314             else:
 315                 date = date + 7
 316
 317     # get the display rectange list of the day grid
 318     def GetRect(self):
 319         cnt = 0
 320         h = 0
 321         w = 0
 322         for y in self.gridy[1:-1]:
 323             if y == self.gridy[-2]:
 324                 h = h + self.restH
 325
 326             for x in self.gridx[:-1]:
 327                 assert type(y) == int
 328                 assert type(x) == int
 329
 330                 w = self.cellW
 331                 h = self.cellH
 332
 333                 if x == self.gridx[-2]:
 334                     w = w + self.restW
 335
 336                 rect = wx.Rect(x, y, w+1, h+1)  # create rect region
 337
 338                 self.rg[cnt] = rect
 339                 cnt = cnt + 1
 340
 341         return self.rg
 342
 343     def GetCal(self):
 344         return self.cal_days
 345
 346     def GetOffset(self):
 347         return self.st_pos
 348
 349     # month and year title
 350     def DrawMonth(self, DC):
 351         month = Month[self.month]
 352
 353         sizef = 11
 354         if self.sizeh < _MIDSIZE:
 355             sizef = 10
 356
 357         f = wx.Font(sizef, self.font, wx.NORMAL, self.bold)
 358         DC.SetFont(f)
 359
 360         tw,th = DC.GetTextExtent(month)
 361         adjust = self.cx_st + (self.sizew-tw)/2
 362         DC.DrawText(month, adjust, self.cy_st + th)
 363
 364         year = str(self.year)
 365         tw,th = DC.GetTextExtent(year)
 366         adjust =  self.sizew - tw - self.x_mrg
 367
 368         self.title_offset = th * 2
 369
 370         f = wx.Font(sizef, self.font, wx.NORMAL, self.bold)
 371         DC.SetFont(f)
 372         DC.DrawText(year, self.cx_st + adjust, self.cy_st + th)
 373
 374     def DrawWeek(self, DC):     # draw the week days
 375         # increase by 1 to include all gridlines
 376         width  = self.gridx[1] - self.gridx[0] + 1
 377         height = self.gridy[1] - self.gridy[0] + 1
 378         rect_w = self.gridx[-1] - self.gridx[0]
 379
 380         f = wx.Font(10, self.font, wx.NORMAL, self.bold)      # initial font setting
 381
 382         if self.week_auto == True:
 383             test_size = self.max_week_size      # max size
 384             test_day = ' Sun '
 385             while test_size > 2:
 386                 f.SetPointSize(test_size)
 387                 DC.SetFont(f)
 388                 tw,th = DC.GetTextExtent(test_day)
 389
 390                 if tw < width and th < height:
 391                     break
 392
 393                 test_size = test_size - 1
 394         else:
 395             f.SetPointSize(self.week_size)   # set fixed size
 396             DC.SetFont(f)
 397
 398         DC.SetTextForeground(MakeColor(self.colors[COLOR_HEADER_FONT]))
 399
 400         cnt_x = 0
 401         cnt_y = 0
 402
 403         brush = wx.Brush(MakeColor(self.colors[COLOR_HEADER_BACKGROUND]), wx.SOLID)
 404         DC.SetBrush(brush)
 405
 406         if self.cal_type == "NORMAL":
 407             cal_days = CalDays
 408         else:
 409             cal_days = BusCalDays
 410
 411         for val in cal_days:
 412             if val == cal_days[-1]:
 413                 width = width + self.restW
 414
 415             day = AbrWeekday[val]
 416
 417             if self.sizew < 200:
 418                 day = day[0]
 419
 420             dw,dh = DC.GetTextExtent(day)
 421
 422             diffx = (width-dw)/2
 423             diffy = (height-dh)/2
 424
 425             x = self.gridx[cnt_x]
 426             y = self.gridy[cnt_y]
 427             pointXY = (x, y)
 428             pointWH = (width, height)
 429             if self.hide_grid == False:
 430                 pen = wx.Pen(MakeColor(self.GetColor(COLOR_GRID_LINES)), 1, wx.SOLID)
 431             else:
 432                 pen = wx.Pen(MakeColor(self.GetColor(COLOR_BACKGROUND)), 1, wx.SOLID)
 433             DC.SetPen(pen)
 434             DC.DrawRectanglePointSize( pointXY, pointWH)
 435
 436             old_pen = DC.GetPen()
 437
 438             pen = wx.Pen(MakeColor(self.colors[COLOR_3D_LIGHT]), 1, wx.SOLID)
 439             DC.SetPen(pen)
 440             # draw the horizontal hilight
 441             startPoint = wx.Point(x + 1 , y + 1)
 442             endPoint   = wx.Point(x + width - 1, y + 1)
 443             DC.DrawLinePoint(startPoint, endPoint )
 444
 445             # draw the vertical hilight
 446             startPoint = wx.Point(x + 1 , y + 1)
 447             endPoint   = wx.Point(x + 1, y + height - 2)
 448             DC.DrawLinePoint(startPoint, endPoint )
 449
 450             pen = wx.Pen(MakeColor(self.colors[COLOR_3D_DARK]), 1, wx.SOLID)
 451             DC.SetPen(pen)
 452
 453             # draw the horizontal lowlight
 454             startPoint = wx.Point(x + 1, y + height - 2)
 455             endPoint   = wx.Point(x + width - 1, y + height - 2)
 456             DC.DrawLinePoint(startPoint, endPoint )
 457
 458             # draw the vertical lowlight
 459             startPoint = wx.Point(x + width - 2 , y + 2)
 460             endPoint   = wx.Point(x + width - 2, y + height - 2)
 461             DC.DrawLinePoint(startPoint, endPoint )
 462
 463             pen = wx.Pen(MakeColor(self.colors[COLOR_FONT]), 1, wx.SOLID)
 464
 465             DC.SetPen(pen)
 466
 467             point = (x+diffx, y+diffy)
 468             DC.DrawTextPoint(day, point)
 469             cnt_x = cnt_x + 1
 470
 471     def _CalcFontSize(self, DC, f):
 472         if self.num_auto == True:
 473             test_size = self.max_num_size      # max size
 474             test_day = ' 99 '
 475
 476             while test_size > 2:
 477                 f.SetPointSize(test_size)
 478                 DC.SetFont(f)
 479                 tw,th = DC.GetTextExtent(test_day)
 480
 481                 if tw < self.cellW and th < self.cellH:
 482                     sizef = test_size
 483                     break
 484                 test_size = test_size - 1
 485         else:
 486             f.SetPointSize(self.num_size)   # set fixed size
 487             DC.SetFont(f)
 488
 489     # draw the day numbers
 490     def DrawNum(self, DC):
 491         f = wx.Font(10, self.font, wx.NORMAL, self.bold)      # initial font setting
 492         self._CalcFontSize(DC, f)
 493
 494         cnt_x = 0
 495         cnt_y = 1
 496         for val in self.cal_days:
 497             x = self.gridx[cnt_x]
 498             y = self.gridy[cnt_y]
 499
 500             self._DrawDayText(x, y, val, f, DC)
 501
 502             if cnt_x < 6:
 503                 cnt_x = cnt_x + 1
 504             else:
 505                 cnt_x = 0
 506                 cnt_y = cnt_y + 1
 507
 508     def _DrawDayText(self, x, y, text, font, DC):
 509
 510         try:
 511             num_val = int(text)
 512             num_color = self.cal_sel[num_val][0]
 513         except:
 514             num_color = self.colors[COLOR_FONT]
 515
 516         DC.SetTextForeground(MakeColor(num_color))
 517         DC.SetFont(font)
 518
 519         tw,th = DC.GetTextExtent(text)
 520
 521         if self.num_align_horz == wx.ALIGN_CENTRE:
 522             adj_h = (self.cellW - tw)/2
 523         elif self.num_align_horz == wx.ALIGN_RIGHT:
 524             adj_h = self.cellW - tw
 525         else:
 526             adj_h = 0   # left alignment
 527
 528         adj_h = adj_h + self.num_indent_horz
 529
 530         if self.num_align_vert == wx.ALIGN_CENTRE:
 531             adj_v = (self.cellH - th)/2
 532         elif self.num_align_vert == wx.ALIGN_BOTTOM:
 533             adj_v = self.cellH - th
 534         else:
 535             adj_v = 0   # left alignment
 536
 537         adj_v = adj_v + self.num_indent_vert
 538
 539         DC.DrawTextPoint(text, (x+adj_h, y+adj_v))
 540
 541     def DrawDayText(self, DC, key):
 542         f = wx.Font(10, self.font, wx.NORMAL, self.bold)      # initial font setting
 543         self._CalcFontSize(DC, f)
 544
 545         if key > self.end_pos:
 546             key = self.end_pos
 547
 548         val = self.cal_days[key]
 549         cnt_x = key % 7
 550         cnt_y = int(key / 7)+1
 551         x = self.gridx[cnt_x]
 552         y = self.gridy[cnt_y]
 553         self._DrawDayText(x, y, val, f, DC)
 554
 555
 556     # calculate the dimensions in the center of the drawing area
 557     def Center(self):
 558         borderW = self.x_mrg * 2
 559         borderH = self.y_mrg + self.y_end + self.title_offset
 560
 561         self.cellW = int((self.sizew - borderW)/7)
 562         self.cellH = int((self.sizeh - borderH)/7)
 563
 564         self.restW = ((self.sizew - borderW)%7 ) - 1
 565
 566         # week title adjustment
 567         self.weekHdrCellH = int(self.cellH * self.cal_week_scale)
 568         # recalculate the cell height exkl. the week header and
 569         # subtracting the size
 570         self.cellH = int((self.sizeh - borderH - self.weekHdrCellH)/6)
 571
 572         self.restH = ((self.sizeh - borderH - self.weekHdrCellH)%6 ) - 1
 573         self.calW = self.cellW * 7
 574         self.calH = self.cellH * 6 + self.weekHdrCellH
 575
 576     # highlighted selected days
 577     def DrawSel(self, DC):
 578
 579         for key in self.cal_sel.keys():
 580             sel_color = self.cal_sel[key][1]
 581             brush = wx.Brush(MakeColor(sel_color), wx.SOLID)
 582             DC.SetBrush(brush)
 583
 584             if self.hide_grid is False:
 585                 DC.SetPen(wx.Pen(MakeColor(self.colors[COLOR_GRID_LINES]), 0))
 586             else:
 587                 DC.SetPen(wx.Pen(MakeColor(self.colors[COLOR_BACKGROUND]), 0))
 588
 589             nkey = key + self.st_pos -1
 590             rect = self.rg[nkey]
 591
 592             DC.DrawRectangleRect(rect)
 593
 594     # calculate and draw the grid lines
 595     def DrawGrid(self, DC):
 596         DC.SetPen(wx.Pen(MakeColor(self.colors[COLOR_GRID_LINES]), 0))
 597
 598         self.gridx = []
 599         self.gridy = []
 600
 601         self.x_st = self.cx_st + self.x_mrg
 602         # start postion of draw
 603         self.y_st = self.cy_st + self.y_mrg + self.title_offset
 604
 605         x1 = self.x_st
 606         y1 = self.y_st
 607         y2 = y1 + self.calH + self.restH
 608
 609         for i in range(8):
 610             if i == 7:
 611                 x1 = x1 + self.restW
 612
 613             if self.hide_grid is False:
 614                 DC.DrawLinePoint((x1, y1), (x1, y2))
 615
 616             self.gridx.append(x1)
 617
 618             x1 = x1 + self.cellW
 619
 620         x1 = self.x_st
 621         y1 = self.y_st
 622         x2 = x1 + self.calW + self.restW
 623
 624         for i in range(8):
 625             if i == 7:
 626                 y1 = y1 + self.restH
 627
 628             if self.hide_grid is False:
 629                 DC.DrawLinePoint((x1, y1), (x2, y1))
 630
 631             self.gridy.append(y1)
 632
 633             if i == 0:
 634                 y1 = y1 + self.weekHdrCellH
 635             else:
 636                 y1 = y1 + self.cellH
 637
 638     def GetColor(self, name):
 639         return MakeColor(self.colors[name])
 640
 641     def SetColor(self, name, value):
 642         self.colors[name] = MakeColor(value)
 643
 644 class PrtCalDraw(CalDraw):
 645     def InitValues(self):
 646         self.rg = {}
 647         self.cal_sel = {}
 648         # start draw border location
 649         self.set_cx_st = 1.0
 650         self.set_cy_st = 1.0
 651
 652         # draw offset position
 653         self.set_y_mrg = 0.2
 654         self.set_x_mrg = 0.2
 655         self.set_y_end = 0.2
 656
 657     # calculate the dimensions in the center of the drawing area
 658     def SetPSize(self, pwidth, pheight):
 659         self.pwidth = int(pwidth)/self.scale
 660         self.pheight = int(pheight)/self.scale
 661
 662     def SetPreview(self, preview):
 663         self.preview = preview
 664
 665 class Calendar( wx.PyControl ):
 666     def __init__(self, parent, id, pos=wx.DefaultPosition, size=wx.Size(200,200),
 667                    style= 0, validator=wx.DefaultValidator,
 668                    name= "calendar"):
 669         wx.PyControl.__init__(self, parent, id, pos, size, style | wx.WANTS_CHARS, validator, name)
 670
 671         self.hasFocus = False
 672         # set the calendar control attributes
 673
 674         self.hide_grid = False
 675         self.hide_title = False
 676         self.show_weekend = False
 677         self.cal_type = "NORMAL"
 678         self.outer_border = True
 679         self.num_align_horz = wx.ALIGN_CENTRE
 680         self.num_align_vert = wx.ALIGN_CENTRE
 681         self.colors = DefaultColors()
 682         self.set_x_mrg = 1
 683         self.set_y_mrg = 1
 684         self.set_y_end = 1
 685
 686         self.select_list = []
 687
 688         self.SetBackgroundColour(MakeColor(self.colors[COLOR_BACKGROUND]))
 689         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftEvent)
 690         self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDEvent)
 691         self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightEvent)
 692         self.Bind(wx.EVT_RIGHT_DCLICK, self.OnRightDEvent)
 693         self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
 694         self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
 695         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
 696
 697         self.sel_key = None      #  last used by
 698         self.sel_lst = []        # highlighted selected days
 699
 700         # default calendar for current month
 701         self.SetNow()
 702
 703         self.size = None
 704         self.set_day = None
 705
 706         self.Bind(wx.EVT_PAINT, self.OnPaint)
 707         self.Bind(wx.EVT_SIZE, self.OnSize)
 708
 709     def AcceptsFocus(self):
 710         return self.IsShown() and self.IsEnabled()
 711
 712     def GetColor(self, name):
 713         return MakeColor(self.colors[name])
 714
 715     def SetColor(self, name, value):
 716         self.colors[name] = MakeColor(value)
 717
 718     # control some of the main calendar attributes
 719
 720     def HideTitle(self):
 721         self.hide_title = True
 722
 723     def HideGrid(self):
 724         self.hide_grid = True
 725
 726     # determine the calendar rectangle click area and draw a selection
 727
 728     def ProcessClick(self, event):
 729         self.x, self.y = event.GetX(), event.GetY()
 730         key = self.GetDayHit(self.x, self.y)
 731         self.SelectDay(key)
 732
 733     # tab mouse click events and process
 734
 735     def OnLeftEvent(self, event):
 736         self.click = 'LEFT'
 737         self.shiftkey = event.ShiftDown()
 738         self.ctrlkey = event.ControlDown()
 739         self.ProcessClick(event)
 740
 741     def OnLeftDEvent(self, event):
 742         self.click = 'DLEFT'
 743         self.ProcessClick(event)
 744
 745     def OnRightEvent(self, event):
 746         self.click = 'RIGHT'
 747         self.ProcessClick(event)
 748
 749     def OnRightDEvent(self, event):
 750         self.click = 'DRIGHT'
 751         self.ProcessClick(event)
 752
 753     def OnSetFocus(self, event):
 754         self.hasFocus = True
 755         self.DrawFocusIndicator(True)
 756
 757     def OnKillFocus(self, event):
 758         self.hasFocus = False
 759         self.DrawFocusIndicator(False)
 760
 761     def OnKeyDown(self, event):
 762         if not self.hasFocus:
 763             event.Skip()
 764             return
 765
 766         key_code = event.KeyCode()
 767
 768         if key_code == wx.WXK_TAB:
 769             forward = not event.ShiftDown()
 770             ne = wx.NavigationKeyEvent()
 771             ne.SetDirection(forward)
 772             ne.SetCurrentFocus(self)
 773             ne.SetEventObject(self)
 774             self.GetParent().GetEventHandler().ProcessEvent(ne)
 775             event.Skip()
 776             return
 777
 778         delta = None
 779
 780         if key_code == wx.WXK_UP:
 781             delta = -7
 782         elif key_code == wx.WXK_DOWN:
 783             delta = 7
 784         elif key_code == wx.WXK_LEFT:
 785             delta = -1
 786         elif key_code == wx.WXK_RIGHT:
 787             delta = 1
 788         elif key_code == wx.WXK_HOME:
 789             curDate = wx.DateTimeFromDMY(int(self.cal_days[self.sel_key]),self.month - 1,self.year)
 790             newDate = wx.DateTime_Now()
 791             ts = newDate - curDate
 792             delta =  ts.GetDays()
 793
 794         if delta <> None:
 795             curDate = wx.DateTimeFromDMY(int(self.cal_days[self.sel_key]),self.month - 1,self.year)
 796             timeSpan = wx.TimeSpan_Days(delta)
 797             newDate = curDate + timeSpan
 798
 799             if curDate.GetMonth() == newDate.GetMonth():
 800                 self.set_day = newDate.GetDay()
 801                 key = self.sel_key + delta
 802                 self.SelectDay(key)
 803             else:
 804                 self.month = newDate.GetMonth() + 1
 805                 self.year = newDate.GetYear()
 806                 self.set_day = newDate.GetDay()
 807                 self.sel_key = None
 808                 self.DoDrawing(wx.ClientDC(self))
 809
 810         event.Skip()
 811
 812     def SetSize(self, set_size):
 813         self.size = set_size
 814
 815     def SetSelDay(self, sel):
 816         # list of highlighted days
 817         self.sel_lst = sel
 818
 819     # get the current date
 820     def SetNow(self):
 821         dt = now()
 822         self.month = dt.month
 823         self.year = dt.year
 824         self.day = dt.day
 825
 826     # set the current day
 827     def SetCurrentDay(self):
 828         self.SetNow()
 829         self.set_day = self.day
 830
 831     # get the date, day, month, year set in calendar
 832
 833     def GetDate(self):
 834         return self.day, self.month, self.year
 835
 836     def GetDay(self):
 837         return self.day
 838
 839     def GetMonth(self):
 840         return self.month
 841
 842     def GetYear(self):
 843         return self.year
 844
 845     # set the day, month, and year
 846
 847     def SetDayValue(self, day):
 848         self.set_day = day
 849
 850     def SetMonth(self, month):
 851         if month >= 1 and month <= 12:
 852             self.month = month
 853         else:
 854             self.month = 1
 855         self.set_day = None
 856
 857     def SetYear(self, year):
 858         self.year = year
 859
 860     # increment year and month
 861
 862     def IncYear(self):
 863         self.year = self.year + 1
 864         self.set_day = None
 865
 866     def DecYear(self):
 867         self.year = self.year - 1
 868         self.set_day = None
 869
 870     def IncMonth(self):
 871         self.month = self.month + 1
 872         if self.month > 12:
 873             self.month = 1
 874             self.year = self.year + 1
 875         self.set_day = None
 876
 877     def DecMonth(self):
 878         self.month = self.month - 1
 879         if self.month < 1:
 880             self.month = 12
 881             self.year = self.year - 1
 882         self.set_day = None
 883
 884     # test to see if the selection has a date and create event
 885
 886     def TestDay(self, key):
 887         try:
 888             self.day = int(self.cal_days[key])
 889         except:
 890             return None
 891
 892         if self.day == "":
 893             return None
 894         else:
 895             # Changed 12/1/03 by jmg (see above) to support 2.5 event binding
 896             evt = wx.PyCommandEvent(wxEVT_COMMAND_PYCALENDAR_DAY_CLICKED, self.GetId())
 897             evt.click, evt.day, evt.month, evt.year = self.click, self.day, self.month, self.year
 898             evt.shiftkey = self.shiftkey
 899             evt.ctrlkey = self.ctrlkey
 900             self.GetEventHandler().ProcessEvent(evt)
 901
 902             self.set_day = self.day
 903             return key
 904
 905     # find the clicked area rectangle
 906
 907     def GetDayHit(self, mx, my):
 908         for key in self.rg.keys():
 909             val = self.rg[key]
 910             ms_rect = wx.Rect(mx, my, 1, 1)
 911             if wx.IntersectRect(ms_rect, val) is not None:
 912                 result = self.TestDay(key)
 913                 return result
 914
 915         return None
 916
 917     # calendar drawing
 918
 919     def SetWeekColor(self, font_color, week_color):
 920         # set font and background color for week title
 921         self.colors[COLOR_HEADER_FONT] = MakeColor(font_color)
 922         self.colors[COLOR_HEADER_BACKGROUND] = MakeColor(week_color)
 923         self.colors[COLOR_3D_LIGHT] = MakeColor(week_color)
 924         self.colors[COLOR_3D_DARK] = MakeColor(week_color)
 925
 926     def SetTextAlign(self, vert, horz):
 927         self.num_align_horz = horz
 928         self.num_align_vert = vert
 929
 930     def AddSelect(self, list, font_color, back_color):
 931         list_val = [list, font_color, back_color]
 932         self.select_list.append(list_val)
 933
 934     def ShowWeekEnd(self):
 935         # highlight weekend
 936         self.show_weekend = True
 937
 938     def SetBusType(self):
 939         self.cal_type = "BUS"
 940
 941     def OnSize(self, evt):
 942         self.Refresh(False)
 943         evt.Skip()
 944
 945     def OnPaint(self, event):
 946         DC = wx.PaintDC(self)
 947         self.DoDrawing(DC)
 948
 949     def DoDrawing(self, DC):
 950         #DC = wx.PaintDC(self)
 951         DC.BeginDrawing()
 952
 953         try:
 954             cal = self.caldraw
 955         except:
 956             self.caldraw = CalDraw(self)
 957             cal = self.caldraw
 958
 959         cal.hide_grid = self.hide_grid
 960         cal.hide_title = self.hide_title
 961         cal.show_weekend = self.show_weekend
 962         cal.cal_type = self.cal_type
 963         cal.outer_border = self.outer_border
 964         cal.num_align_horz = self.num_align_horz
 965         cal.num_align_vert = self.num_align_vert
 966         cal.colors = self.colors
 967
 968         if self.size is None:
 969             size = self.GetClientSize()
 970         else:
 971             size = self.size
 972
 973         # drawing attributes
 974
 975         cal.SetSize(size)
 976         cal.SetCal(self.year, self.month)
 977
 978         # these have to set after SetCal as SetCal would overwrite them again.
 979         cal.set_x_mrg = self.set_x_mrg
 980         cal.set_y_mrg = self.set_y_mrg
 981         cal.set_y_end = self.set_y_end
 982
 983         for val in self.select_list:
 984             cal.AddSelect(val[0], val[1], val[2])
 985
 986         cal.DrawCal(DC, self.sel_lst)
 987
 988         self.rg = cal.GetRect()
 989         self.cal_days = cal.GetCal()
 990         self.st_pos = cal.GetOffset()
 991         self.ymax = DC.MaxY()
 992
 993         if self.set_day != None:
 994             self.SetDay(self.set_day)
 995
 996         DC.EndDrawing()
 997
 998     # draw the selection rectangle
 999     def DrawFocusIndicator(self, draw):
1000         DC = wx.ClientDC(self)
1001         try:
1002             if draw == True:
1003                 self.caldraw.DrawFocusIndicator(DC)
1004             else:
1005                 self.caldraw.DrawBorder(DC,True)
1006         except:
1007             pass
1008
1009     def DrawRect(self, key, bgcolor = 'WHITE', fgcolor= 'PINK',width = 0):
1010         if key == None:
1011             return
1012
1013         DC = wx.ClientDC(self)
1014         DC.BeginDrawing()
1015
1016         brush = wx.Brush(MakeColor(bgcolor))
1017         DC.SetBrush(brush)
1018
1019         DC.SetPen(wx.TRANSPARENT_PEN)
1020
1021         rect = self.rg[key]
1022         DC.DrawRectangle(rect.x+1, rect.y+1, rect.width-2, rect.height-2)
1023
1024         self.caldraw.DrawDayText(DC,key)
1025
1026         DC.EndDrawing()
1027
1028     def DrawRectOrg(self, key, fgcolor = 'BLACK', width = 0):
1029         if key == None:
1030             return
1031
1032         DC = wx.ClientDC(self)
1033         DC.BeginDrawing()
1034
1035         brush = wx.Brush(wx.Colour(0, 0xFF, 0x80), wx.TRANSPARENT)
1036         DC.SetBrush(brush)
1037
1038         try:
1039             DC.SetPen(wx.Pen(MakeColor(fgcolor), width))
1040         except:
1041             DC.SetPen(wx.Pen(MakeColor(self.GetColor(COLOR_GRID_LINES)), width))
1042
1043         rect = self.rg[key]
1044         DC.DrawRectangleRect(rect)
1045
1046         DC.EndDrawing()
1047
1048     # set the day selection
1049
1050     def SetDay(self, day):
1051         d = day + self.st_pos - 1
1052         self.SelectDay(d)
1053
1054     def IsDayInWeekend(self, key):
1055         try:
1056             t = Date(self.year, self.month, 1)
1057
1058             day = self.cal_days[key]
1059             day = int(day) + t.day_of_week
1060
1061             if day % 7 == 6 or day % 7 == 0:
1062                 return True
1063         except:
1064             return False
1065
1066     def SelectDay(self, key):
1067         sel_size = 1
1068         # clear large selection
1069
1070         if self.sel_key != None:
1071             (cfont, bgcolor) = self.__GetColorsForDay(self.sel_key)
1072             self.DrawRect(self.sel_key, bgcolor,cfont, sel_size)
1073
1074         self.DrawRect(key, self.GetColor(COLOR_HIGHLIGHT_BACKGROUND), self.GetColor(COLOR_HIGHLIGHT_FONT), sel_size)
1075
1076         # store last used by
1077         self.sel_key = key
1078         self.select_day = None
1079
1080     def ClearDsp(self):
1081         self.Clear()
1082     def SetMargin(self, xmarg, ymarg):
1083         self.set_x_mrg = xmarg
1084         self.set_y_mrg = ymarg
1085         self.set_y_end = ymarg
1086     def __GetColorsForDay(self, key):
1087         cfont   = self.GetColor(COLOR_FONT)
1088         bgcolor = self.GetColor(COLOR_BACKGROUND)
1089
1090         if self.IsDayInWeekend(key) is True and self.show_weekend is True:
1091             cfont   = self.GetColor(COLOR_WEEKEND_FONT)
1092             bgcolor = self.GetColor(COLOR_WEEKEND_BACKGROUND)
1093
1094         try:
1095             dayIdx = int(self.cal_days[key])
1096             (cfont, bgcolor) = self.caldraw.cal_sel[dayIdx]
1097         except:
1098             pass
1099
1100         return (cfont, bgcolor)
1101
1102 class CalenDlg(wx.Dialog):
1103     def __init__(self, parent, month=None, day = None, year=None):
1104         wx.Dialog.__init__(self, parent, -1, "Event Calendar", wx.DefaultPosition, (280, 360))
1105
1106         # set the calendar and attributes
1107         self.calend = Calendar(self, -1, (20, 60), (240, 200))
1108
1109         if month == None:
1110             self.calend.SetCurrentDay()
1111             start_month = self.calend.GetMonth()
1112             start_year = self.calend.GetYear()
1113         else:
1114             self.calend.month = start_month = month
1115             self.calend.year = start_year = year
1116             self.calend.SetDayValue(day)
1117
1118         self.calend.HideTitle()
1119         self.ResetDisplay()
1120
1121         # get month list from DateTime
1122         monthlist = GetMonthList()
1123
1124         # select the month
1125         self.date = wx.ComboBox(self, -1, Month[start_month], (20, 20), (90, -1),
1126                                 monthlist, wx.CB_DROPDOWN)
1127         self.Bind(wx.EVT_COMBOBOX, self.EvtComboBox, self.date)
1128
1129         # alternate spin button to control the month
1130         h = self.date.GetSize().height
1131         self.m_spin = wx.SpinButton(self, -1, (130, 20), (h*2, h), wx.SP_VERTICAL)
1132         self.m_spin.SetRange(1, 12)
1133         self.m_spin.SetValue(start_month)
1134         self.Bind(wx.EVT_SPIN, self.OnMonthSpin, self.m_spin)
1135
1136         # spin button to control the year
1137         self.dtext = wx.TextCtrl(self, -1, str(start_year), (160, 20), (60, -1))
1138         h = self.dtext.GetSize().height
1139
1140         self.y_spin = wx.SpinButton(self, -1, (220, 20), (h*2, h), wx.SP_VERTICAL)
1141         self.y_spin.SetRange(1980, 2010)
1142         self.y_spin.SetValue(start_year)
1143
1144         self.Bind(wx.EVT_SPIN, self.OnYrSpin, self.y_spin)
1145         self.Bind(EVT_CALENDAR, self.MouseClick, self.calend)
1146
1147         x_pos = 50
1148         y_pos = 280
1149         but_size = (60, 25)
1150
1151         btn = wx.Button(self, -1, ' Ok ', (x_pos, y_pos), but_size)
1152         self.Bind(wx.EVT_BUTTON, self.OnOk, btn)
1153
1154         btn = wx.Button(self, -1, ' Close ', (x_pos + 120, y_pos), but_size)
1155         self.Bind(wx.EVT_BUTTON, self.OnCancel, btn)
1156
1157     def OnOk(self, event):
1158         self.EndModal(wx.ID_OK)
1159
1160     def OnCancel(self, event):
1161         self.EndModal(wx.ID_CANCEL)
1162
1163     # log the mouse clicks
1164     def MouseClick(self, evt):
1165         self.month = evt.month
1166         # result click type and date
1167         self.result = [evt.click, str(evt.day), Month[evt.month], str(evt.year)]
1168
1169         if evt.click == 'DLEFT':
1170             self.EndModal(wx.ID_OK)
1171
1172     # month and year spin selection routines
1173     def OnMonthSpin(self, event):
1174         month = event.GetPosition()
1175         self.date.SetValue(Month[month])
1176         self.calend.SetMonth(month)
1177         self.calend.Refresh()
1178
1179     def OnYrSpin(self, event):
1180         year = event.GetPosition()
1181         self.dtext.SetValue(str(year))
1182         self.calend.SetYear(year)
1183         self.calend.Refresh()
1184
1185     def EvtComboBox(self, event):
1186         name = event.GetString()
1187         monthval = self.date.FindString(name)
1188         self.m_spin.SetValue(monthval+1)
1189
1190         self.calend.SetMonth(monthval+1)
1191         self.ResetDisplay()
1192
1193     # set the calendar for highlighted days
1194
1195     def ResetDisplay(self):
1196         month = self.calend.GetMonth()
1197         self.calend.Refresh()
1198
1199
1200