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