Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated wx.lib.calendar with many fixes and enhancements from Joerg

Browse Source 
"Adi" Sieker.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_4_BRANCH@25982 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2004-02-27 23:21:37 +00:00
parent 3d808368e3
commit 42e5385fcc
1 changed files with 385 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

581
wxPython/wxPython/lib/calendar.py
View File

@@ -1,4 +1,3 @@
#----------------------------------------------------------------------------
# Name: calendar.py # Name: calendar.py
# Purpose: Calendar display control # Purpose: Calendar display control
# #
@@ -9,20 +8,51 @@
# Date: Nov 26, 2001 # Date: Nov 26, 2001
# Licence: wxWindows license # Licence: wxWindows license
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# 06/02/2004 - Joerg "Adi" Sieker adi@sieker.info
#
# o Changed color handling, use dictionary instead of members.
# This causes all color changes to be ignored if they manipluate the members directly.
# SetWeekColor and other method color methods were adapted to use the new dictionary.
# o Added COLOR_* constants
# o Added SetColor method for Calendar class
# o Added 3D look of week header
# o Added colors for 3D look of header
# o Fixed width calculation.
# Because of rounding difference the total width and height of the
# calendar could be up to 6 pixels to small. The last column and row
# are now wider/taller by the missing amount.
# o Added SetTextAlign method to wxCalendar. This exposes logic
# which was already there.
# o Fixed CalDraw.SetMarg which set set_x_st and set_y_st which don't get used anywhere.
# Instead set set_x_mrg and set_y_mrg
# o Changed default X and Y Margin to 1.
# o Added wxCalendar.SetMargin.
from wxPython.wx import * from wxPython.wx import *
from CDate import * from CDate import *
CalDays = [6, 0, 1, 2, 3, 4, 5] CalDays = [6, 0, 1, 2, 3, 4, 5]
AbrWeekday = {6:"Sun", 0:"Mon", 1:"Tue", 2:"Wed", 3:"Thu", 4:"Fri", 5:"Sat"} AbrWeekday = {6:"Sun", 0:"Mon", 1:"Tue", 2:"Wed", 3:"Thu", 4:"Fri", 5:"Sat"}
_MIDSIZE = 180 _MIDSIZE = 180
COLOR_GRID_LINES = "grid_lines"
COLOR_BACKGROUND = "background"
COLOR_SELECTION_FONT = "selection_font"
COLOR_SELECTION_BACKGROUND = "selection_background"
COLOR_BORDER = "border"
COLOR_HEADER_BACKGROUND = "header_background"
COLOR_HEADER_FONT = "header_font"
COLOR_WEEKEND_BACKGROUND = "weekend_background"
COLOR_WEEKEND_FONT = "weekend_font"
COLOR_FONT = "font"
COLOR_3D_LIGHT = "3d_light"
COLOR_3D_DARK = "3d_dark"
COLOR_HIGHLIGHT_FONT = "highlight_font"
COLOR_HIGHLIGHT_BACKGROUND = "highlight_background"
BusCalDays = [0, 1, 2, 3, 4, 5, 6] BusCalDays = [0, 1, 2, 3, 4, 5, 6]
# calendar drawing routing
def GetMonthList(): def GetMonthList():
monthlist = [] monthlist = []
for i in range(13): for i in range(13):
@@ -31,6 +61,33 @@ def GetMonthList():
monthlist.append(name) monthlist.append(name)
return monthlist return monthlist
def MakeColor(in_color):
try:
color = wxNamedColour(in_color)
except:
color = in_color
return color
def DefaultColors():
colors = {}
colors[COLOR_GRID_LINES] = 'BLACK'
colors[COLOR_BACKGROUND] = 'WHITE'
colors[COLOR_SELECTION_FONT] = wxSystemSettings_GetColour(wxSYS_COLOUR_WINDOWTEXT)
colors[COLOR_SELECTION_BACKGROUND] = wxColor(255,255,225)
colors[COLOR_BORDER] = 'BLACK'
colors[COLOR_HEADER_BACKGROUND] = wxSystemSettings_GetColour(wxSYS_COLOUR_3DFACE)
colors[COLOR_HEADER_FONT] = wxSystemSettings_GetColour(wxSYS_COLOUR_WINDOWTEXT)
colors[COLOR_WEEKEND_BACKGROUND] = 'LIGHT GREY'
colors[COLOR_WEEKEND_FONT] = wxSystemSettings_GetColour(wxSYS_COLOUR_WINDOWTEXT)
colors[COLOR_FONT] = wxSystemSettings_GetColour(wxSYS_COLOUR_WINDOWTEXT)
colors[COLOR_3D_LIGHT] = wxSystemSettings_GetColour(wxSYS_COLOUR_BTNHIGHLIGHT)
colors[COLOR_3D_DARK] = wxSystemSettings_GetColour(wxSYS_COLOUR_BTNSHADOW)
colors[COLOR_HIGHLIGHT_FONT] = 'PINK'
colors[COLOR_HIGHLIGHT_BACKGROUND] = 'RED'
return colors
# calendar drawing routing
class CalDraw: class CalDraw:
def __init__(self, parent): def __init__(self, parent):
self.pwidth = 1 self.pwidth = 1
@@ -40,6 +97,9 @@ class CalDraw:
except: except:
self.scale = 1 self.scale = 1
self.gridx = []
self.gridy = []
self.DefParms() self.DefParms()
def DefParms(self): def DefParms(self):
@@ -56,16 +116,7 @@ class CalDraw:
self.week_size = 10 self.week_size = 10
self.max_week_size = 12 self.max_week_size = 12
self.grid_color = 'BLACK' # grid and selection colors self.colors = DefaultColors()
self.back_color = 'WHITE'
self.sel_color = 'RED'
self.high_color = 'LIGHT BLUE'
self.border_color = 'BLACK'
self.week_color = 'LIGHT GREY'
self.week_font_color = 'BLACK' # font colors
self.day_font_color = 'BLACK'
self.font = wxSWISS self.font = wxSWISS
self.bold = wxNORMAL self.bold = wxNORMAL
@@ -78,14 +129,17 @@ class CalDraw:
self.cal_week_scale = 0.7 self.cal_week_scale = 0.7
self.show_weekend = False self.show_weekend = False
self.cal_type = "NORMAL" self.cal_type = "NORMAL"
def SetWeekColor(self, font_color, week_color): # set font and background color for week title def SetWeekColor(self, font_color, week_color):
self.week_font_color = font_color # set font and background color for week title
self.week_color = week_color self.colors[COLOR_HEADER_FONT] = MakeColor(font_color)
self.colors[COLOR_HEADER_BACKGROUND] = MakeColor(week_color)
self.colors[COLOR_3D_LIGHT] = MakeColor(week_color)
self.colors[COLOR_3D_DARK] = MakeColor(week_color)
def SetSize(self, size): def SetSize(self, size):
self.set_sizew = size.width self.set_sizew = size[0]
self.set_sizeh = size.height self.set_sizeh = size[1]
def InitValues(self): # default dimensions of various elements of the calendar def InitValues(self): # default dimensions of various elements of the calendar
self.rg = {} self.rg = {}
@@ -93,41 +147,41 @@ class CalDraw:
self.set_cy_st = 0 # start position self.set_cy_st = 0 # start position
self.set_cx_st = 0 self.set_cx_st = 0
self.set_y_mrg = 15 # start of vertical draw default self.set_y_mrg = 1 # start of vertical draw default
self.set_x_mrg = 10 self.set_x_mrg = 1
self.set_y_end = 10 self.set_y_end = 1
def SetPos(self, xpos, ypos): def SetPos(self, xpos, ypos):
self.set_cx_st = xpos self.set_cx_st = xpos
self.set_cy_st = ypos self.set_cy_st = ypos
def SetMarg(self, xmarg, ymarg): def SetMarg(self, xmarg, ymarg):
self.set_x_st = xmarg self.set_x_mrg = xmarg
self.set_y_st = ymarg self.set_y_mrg = ymarg
self.set_y_end = ymarg self.set_y_end = ymarg
def InitScale(self): # scale position values def InitScale(self): # scale position values
self.sizew = self.set_sizew * self.pwidth self.sizew = int(self.set_sizew * self.pwidth)
self.sizeh = self.set_sizeh * self.pheight self.sizeh = int(self.set_sizeh * self.pheight)
self.cx_st = self.set_cx_st * self.pwidth # draw start position self.cx_st = int(self.set_cx_st * self.pwidth) # draw start position
self.cy_st = self.set_cy_st * self.pheight self.cy_st = int(self.set_cy_st * self.pheight)
self.x_mrg = self.set_x_mrg * self.pwidth # calendar draw margins self.x_mrg = int(self.set_x_mrg * self.pwidth) # calendar draw margins
self.y_mrg = self.set_y_mrg * self.pheight self.y_mrg = int(self.set_y_mrg * self.pheight)
self.y_end = self.set_y_end * self.pheight self.y_end = int(self.set_y_end * self.pheight)
def DrawCal(self, DC, sel_lst=[]): def DrawCal(self, DC, sel_lst=[]):
self.DC = DC
self.InitScale() self.InitScale()
self.DrawBorder() self.DrawBorder(DC)
if self.hide_title is False: if self.hide_title is False:
self.DrawMonth() self.DrawMonth(DC)
self.Center() self.Center()
self.DrawGrid() self.DrawGrid(DC)
self.GetRect() self.GetRect()
if self.show_weekend is True: # highlight weekend dates if self.show_weekend is True: # highlight weekend dates
@@ -135,33 +189,32 @@ class CalDraw:
self.AddSelect(sel_lst) # overrides the weekend highlight self.AddSelect(sel_lst) # overrides the weekend highlight
self.DrawSel() # highlighted days self.DrawSel(DC) # highlighted days
self.DrawWeek() self.DrawWeek(DC)
self.DrawNum() self.DrawNum(DC)
def AddSelect(self, list, cfont=None, cbackgrd = None): def AddSelect(self, list, cfont=None, cbackgrd = None):
if cfont is None: if cfont is None:
cfont = self.sel_color # font digit color cfont = self.colors[COLOR_SELECTION_FONT] # font digit color
if cbackgrd is None: if cbackgrd is None:
cbackgrd = self.high_color # select background color cbackgrd = self.colors[COLOR_SELECTION_BACKGROUND] # select background color
for val in list: for val in list:
self.cal_sel[val] = (cfont, cbackgrd) self.cal_sel[val] = (cfont, cbackgrd)
def DrawBorder(self): # draw border around the outside of the main display rectangle def DrawBorder(self, DC): # draw border around the outside of the main display rectangle
brush = wxBrush(wxNamedColour(self.back_color), wxSOLID) brush = wxBrush(MakeColor(self.colors[COLOR_BACKGROUND]), wxSOLID)
self.DC.SetBrush(brush) DC.SetBrush(brush)
self.DC.SetPen(wxPen(wxNamedColour(self.border_color), 1)) DC.SetPen(wxPen(MakeColor(self.colors[COLOR_BORDER]), 1))
if self.outer_border is True: if self.outer_border is True:
rect = wxRect(self.cx_st, self.cy_st, self.sizew, self.sizeh) # full display window area rect = wxRect(self.cx_st, self.cy_st, self.sizew, self.sizeh) # full display window area
self.DC.DrawRectangle(rect.x, rect.y, rect.width, rect.height) DC.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
def DrawNumVal(self): def DrawNumVal(self):
self.DrawNum() self.DrawNum()
# calculate the calendar days and offset position # calculate the calendar days and offset position
def SetCal(self, year, month): def SetCal(self, year, month):
self.InitValues() # reset initial values self.InitValues() # reset initial values
@@ -172,6 +225,7 @@ class CalDraw:
t = Date(year, month, day) t = Date(year, month, day)
dow = self.dow = t.day_of_week # start day in month dow = self.dow = t.day_of_week # start day in month
dim = self.dim = t.days_in_month # number of days in month dim = self.dim = t.days_in_month # number of days in month
if self.cal_type == "NORMAL": if self.cal_type == "NORMAL":
start_pos = dow+1 start_pos = dow+1
else: else:
@@ -179,22 +233,30 @@ class CalDraw:
self.st_pos = start_pos self.st_pos = start_pos
self.cal = [] self.cal_days = []
for i in range(start_pos): for i in range(start_pos):
self.cal.append('') self.cal_days.append('')
i = 1 i = 1
while i <= dim: while i <= dim:
self.cal.append(str(i)) self.cal_days.append(str(i))
i = i + 1 i = i + 1
return start_pos return start_pos
def SetWeekEnd(self, font_color='BLACK', backgrd = 'LIGHT GREY'): def SetWeekEnd(self, font_color=None, backgrd = None):
if font_color != None:
self.SetColor(COLOR_WEEKEND_FONT, MakeColor(font_color))
if backgrd != None:
self.SetColor(COLOR_WEEKEND_BACKGROUND, MakeColor(backgrd))
date = 6 - int(self.dow) # start day of first saturday date = 6 - int(self.dow) # start day of first saturday
while date <= self.dim: while date <= self.dim:
self.cal_sel[date] = (font_color, backgrd) # Saturday self.cal_sel[date] = (self.GetColor(COLOR_WEEKEND_FONT), self.GetColor(COLOR_WEEKEND_BACKGROUND)) # Saturday
date = date + 1 date = date + 1
if date <= self.dim: if date <= self.dim:
self.cal_sel[date] = (font_color, backgrd) # Sunday self.cal_sel[date] = (self.GetColor(COLOR_WEEKEND_FONT), self.GetColor(COLOR_WEEKEND_BACKGROUND)) # Sunday
date = date + 6 date = date + 6
else: else:
date = date + 7 date = date + 7
@@ -202,19 +264,33 @@ class CalDraw:
def GetRect(self): # get the display rectange list of the day grid def GetRect(self): # get the display rectange list of the day grid
cnt = 0 cnt = 0
for y in self.gridy[1:-1]: for y in self.gridy[1:-1]:
if y == self.gridy[-2]:
h = h + self.restH
for x in self.gridx[:-1]: for x in self.gridx[:-1]:
rect = wxRect(x, y, self.dl_w, self.dl_h) # create rect region assert type(y) == int
assert type(x) == int
w = self.cellW
h = self.cellH
if x == self.gridx[-2]:
w = w + self.restW
rect = wxRect(x, y, w+1, h+1) # create rect region
self.rg[cnt] = rect self.rg[cnt] = rect
cnt = cnt + 1 cnt = cnt + 1
return self.rg return self.rg
def GetCal(self): def GetCal(self):
return self.cal return self.cal_days
def GetOffset(self): def GetOffset(self):
return self.st_pos return self.st_pos
def DrawMonth(self): # month and year title def DrawMonth(self, DC): # month and year title
month = Month[self.month] month = Month[self.month]
sizef = 11 sizef = 11
@@ -222,50 +298,54 @@ class CalDraw:
sizef = 10 sizef = 10
f = wxFont(sizef, self.font, wxNORMAL, self.bold) f = wxFont(sizef, self.font, wxNORMAL, self.bold)
self.DC.SetFont(f) DC.SetFont(f)
tw,th = self.DC.GetTextExtent(month) tw,th = DC.GetTextExtent(month)
adjust = self.cx_st + (self.sizew-tw)/2 adjust = self.cx_st + (self.sizew-tw)/2
self.DC.DrawText(month, adjust, self.cy_st + th) DC.DrawText(month, adjust, self.cy_st + th)
year = str(self.year) year = str(self.year)
tw,th = self.DC.GetTextExtent(year) tw,th = DC.GetTextExtent(year)
adjust = self.sizew - tw - self.x_mrg adjust = self.sizew - tw - self.x_mrg
self.title_offset = th * 2 self.title_offset = th * 2
f = wxFont(sizef, self.font, wxNORMAL, self.bold) f = wxFont(sizef, self.font, wxNORMAL, self.bold)
self.DC.SetFont(f) DC.SetFont(f)
self.DC.DrawText(year, self.cx_st + adjust, self.cy_st + th) DC.DrawText(year, self.cx_st + adjust, self.cy_st + th)
def DrawWeek(self): # draw the week days def DrawWeek(self, DC): # draw the week days
width = self.gridx[1]-self.gridx[0] # increase by to include all gridlines
height = self.gridy[1] - self.gridy[0] width = self.gridx[1] - self.gridx[0] + 1
rect_w = self.gridx[7]-self.gridx[0] height = self.gridy[1] - self.gridy[0] + 1
rect_w = self.gridx[-1] - self.gridx[0]
f = wxFont(10, self.font, wxNORMAL, self.bold) # initial font setting f = wxFont(10, self.font, wxNORMAL, self.bold) # initial font setting
if self.week_auto == True: if self.week_auto == True:
test_size = self.max_week_size # max size test_size = self.max_week_size # max size
test_day = ' Sun ' test_day = ' Sun '
while test_size > 2: while test_size > 2:
f.SetPointSize(test_size) f.SetPointSize(test_size)
self.DC.SetFont(f) DC.SetFont(f)
tw,th = self.DC.GetTextExtent(test_day) tw,th = DC.GetTextExtent(test_day)
if tw < width and th < height: if tw < width and th < height:
break break
test_size = test_size - 1 test_size = test_size - 1
else: else:
f.SetPointSize(self.week_size) # set fixed size f.SetPointSize(self.week_size) # set fixed size
self.DC.SetFont(f) DC.SetFont(f)
self.DC.SetTextForeground(wxNamedColour(self.week_font_color)) DC.SetTextForeground(MakeColor(self.colors[COLOR_HEADER_FONT]))
cnt_x = 0 cnt_x = 0
cnt_y = 0 cnt_y = 0
brush = wxBrush(wxNamedColour(self.week_color), wxSOLID) brush = wxBrush(MakeColor(self.colors[COLOR_HEADER_BACKGROUND]), wxSOLID)
self.DC.SetBrush(brush)
# self.DC.DrawRectangle(self.gridx[0], self.gridy[0], rect_w+1, height) DC.SetBrush(brush)
if self.cal_type == "NORMAL": if self.cal_type == "NORMAL":
cal_days = CalDays cal_days = CalDays
@@ -273,134 +353,212 @@ class CalDraw:
cal_days = BusCalDays cal_days = BusCalDays
for val in cal_days: for val in cal_days:
if val == cal_days[-1]:
width = width + self.restW
day = AbrWeekday[val] day = AbrWeekday[val]
if self.sizew < 200: if self.sizew < 200:
day = day[0] day = day[0]
dw,dh = self.DC.GetTextExtent(day)
dw,dh = DC.GetTextExtent(day)
diffx = (width-dw)/2 diffx = (width-dw)/2
diffy = (height-dh)/2 diffy = (height-dh)/2
x = self.gridx[cnt_x] x = self.gridx[cnt_x]
y = self.gridy[cnt_y] y = self.gridy[cnt_y]
self.DC.DrawRectangle(self.gridx[cnt_x], self.gridy[0], width+1, height) pointXY = (x, y)
self.DC.DrawText(day, x+diffx, y+diffy) pointWH = (width, height)
if self.hide_grid == False:
pen = wxPen(MakeColor(self.GetColor(COLOR_GRID_LINES)), 1, wxSOLID)
else:
pen = wxPen(MakeColor(self.GetColor(COLOR_BACKGROUND)), 1, wxSOLID)
DC.SetPen(pen)
DC.DrawRectangle(pointXY[0], pointXY[1], pointWH[0], pointWH[1])
# pen = wxPen(MakeColor('GREEN'), 1, wxSOLID)
pen = wxPen(MakeColor(self.colors[COLOR_3D_LIGHT]), 1, wxSOLID)
DC.SetPen(pen)
# draw the horizontal hilight
startPoint = wxPoint(x +1 , y + 1)
endPoint = wxPoint(x + width - 1, y + 1)
DC.DrawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y )
# draw the vertical hilight
startPoint = wxPoint(x + 1 , y + 1)
endPoint = wxPoint(x + 1, y + height - 2)
DC.DrawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y )
# pen = wxPen(MakeColor('RED'), 1, wxSOLID)
pen = wxPen(MakeColor(self.colors[COLOR_3D_DARK]), 1, wxSOLID)
DC.SetPen(pen)
# draw the horizontal lowlight
startPoint = wxPoint(x + 1, y + height - 2)
endPoint = wxPoint(x + width - 1, y + height - 2)
DC.DrawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y )
# draw the vertical lowlight
startPoint = wxPoint(x + width - 2 , y + 2)
endPoint = wxPoint(x + width - 2, y + height - 2)
DC.DrawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y )
pen = wxPen(MakeColor(self.colors[COLOR_FONT]), 1, wxSOLID)
DC.SetPen(pen)
DC.DrawText(day, x+diffx, y+diffy)
cnt_x = cnt_x + 1 cnt_x = cnt_x + 1
def DrawNum(self): # draw the day numbers def DrawNum(self, DC): # draw the day numbers
f = wxFont(10, self.font, wxNORMAL, self.bold) # initial font setting f = wxFont(10, self.font, wxNORMAL, self.bold) # initial font setting
if self.num_auto == True: if self.num_auto == True:
test_size = self.max_num_size # max size test_size = self.max_num_size # max size
test_day = ' 99 ' test_day = ' 99 '
while test_size > 2: while test_size > 2:
f.SetPointSize(test_size) f.SetPointSize(test_size)
self.DC.SetFont(f) DC.SetFont(f)
tw,th = self.DC.GetTextExtent(test_day) tw,th = DC.GetTextExtent(test_day)
if tw < self.dl_w and th < self.dl_h:
if tw < self.cellW and th < self.cellH:
sizef = test_size sizef = test_size
break break
test_size = test_size - 1 test_size = test_size - 1
else: else:
f.SetPointSize(self.num_size) # set fixed size f.SetPointSize(self.num_size) # set fixed size
self.DC.SetFont(f) DC.SetFont(f)
cnt_x = 0 cnt_x = 0
cnt_y = 1 cnt_y = 1
for val in self.cal: for val in self.cal_days:
x = self.gridx[cnt_x] x = self.gridx[cnt_x]
y = self.gridy[cnt_y] y = self.gridy[cnt_y]
try: self.DrawDayText(x, y, val, f, DC)
num_val = int(val)
num_color = self.cal_sel[num_val][0]
except:
num_color = self.day_font_color
self.DC.SetTextForeground(wxNamedColour(num_color))
self.DC.SetFont(f)
tw,th = self.DC.GetTextExtent(val)
if self.num_align_horz == wxALIGN_CENTRE:
adj_h = (self.dl_w - tw)/2
elif self.num_align_horz == wxALIGN_RIGHT:
adj_h = self.dl_w - tw
else:
adj_h = 0 # left alignment
adj_h = adj_h + self.num_indent_horz
if self.num_align_vert == wxALIGN_CENTRE:
adj_v = (self.dl_h - th)/2
elif self.num_align_horz == wxALIGN_RIGHT:
adj_v = self.dl_h - th
else:
adj_v = 0 # left alignment
adj_v = adj_v + self.num_indent_vert
self.DC.DrawText(val, x+adj_h, y+adj_v)
if cnt_x < 6: if cnt_x < 6:
cnt_x = cnt_x + 1 cnt_x = cnt_x + 1
else: else:
cnt_x = 0 cnt_x = 0
cnt_y = cnt_y + 1 cnt_y = cnt_y + 1
def DrawDayText(self, x, y, text, font, DC):
try:
num_val = int(text)
num_color = self.cal_sel[num_val][0]
except:
num_color = self.colors[COLOR_FONT]
DC.SetTextForeground(MakeColor(num_color))
DC.SetFont(font)
tw,th = DC.GetTextExtent(text)
if self.num_align_horz == wxALIGN_CENTRE:
adj_h = (self.cellW - tw)/2
elif self.num_align_horz == wxALIGN_RIGHT:
adj_h = self.cellW - tw
else:
adj_h = 0 # left alignment
adj_h = adj_h + self.num_indent_horz
if self.num_align_vert == wxALIGN_CENTRE:
adj_v = (self.cellH - th)/2
elif self.num_align_vert == wxALIGN_BOTTOM:
adj_v = self.cellH - th
else:
adj_v = 0 # left alignment
adj_v = adj_v + self.num_indent_vert
DC.DrawText(text, x+adj_h, y+adj_v)
def Center(self): # calculate the dimensions in the center of the drawing area def Center(self): # calculate the dimensions in the center of the drawing area
bdw = self.x_mrg * 2 borderW = self.x_mrg * 2
bdh = self.y_mrg + self.y_end + self.title_offset borderH = self.y_mrg + self.y_end + self.title_offset
self.dl_w = int((self.sizew-bdw)/7) self.cellW = int((self.sizew - borderW)/7)
self.dl_h = int((self.sizeh-bdh)/7) self.cellH = int((self.sizeh - borderH)/7)
self.restW = ((self.sizew - borderW)%7 ) - 1
self.weekHdrCellH = int(self.cellH * self.cal_week_scale) # week title adjustment
# recalculate the cell height exkl. the week header and
# subtracting the size
self.cellH = int((self.sizeh - borderH - self.weekHdrCellH)/6)
self.dl_th = int(self.dl_h*self.cal_week_scale) # week title adjustment self.restH = ((self.sizeh - borderH - self.weekHdrCellH)%6 ) - 1
self.cwidth = self.dl_w * 7 self.calW = self.cellW * 7
self.cheight = self.dl_h * 6 + self.dl_th self.calH = self.cellH * 6 + self.weekHdrCellH
def DrawSel(self): # highlighted selected days def DrawSel(self, DC): # highlighted selected days
for key in self.cal_sel.keys(): for key in self.cal_sel.keys():
sel_color = self.cal_sel[key][1] sel_color = self.cal_sel[key][1]
brush = wxBrush(wxNamedColour(sel_color), wxSOLID) brush = wxBrush(MakeColor(sel_color), wxSOLID)
self.DC.SetBrush(brush) DC.SetBrush(brush)
if self.hide_grid is False: if self.hide_grid is False:
self.DC.SetPen(wxPen(wxNamedColour(self.grid_color), 0)) DC.SetPen(wxPen(MakeColor(self.colors[COLOR_GRID_LINES]), 0))
else: else:
self.DC.SetPen(wxPen(wxNamedColour(self.back_color), 0)) DC.SetPen(wxPen(MakeColor(self.colors[COLOR_BACKGROUND]), 0))
nkey = key + self.st_pos -1 nkey = key + self.st_pos -1
rect = self.rg[nkey] rect = self.rg[nkey]
self.DC.DrawRectangle(rect.x, rect.y, rect.width+1, rect.height+1)
def DrawGrid(self): # calculate and draw the grid lines DC.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
self.DC.SetPen(wxPen(wxNamedColour(self.grid_color), 0))
def DrawGrid(self, DC): # calculate and draw the grid lines
DC.SetPen(wxPen(MakeColor(self.colors[COLOR_GRID_LINES]), 0))
self.gridx = [] self.gridx = []
self.gridy = [] self.gridy = []
self.x_st = self.cx_st + self.x_mrg self.x_st = self.cx_st + self.x_mrg
self.y_st = self.cy_st + self.y_mrg + self.title_offset # start postion of draw # start postion of draw
self.y_st = self.cy_st + self.y_mrg + self.title_offset
x1 = self.x_st x1 = self.x_st
y1 = self.y_st y1 = self.y_st
y2 = y1 + self.calH + self.restH
y2 = y1 + self.cheight
for i in range(8): for i in range(8):
if i == 7:
x1 = x1 + self.restW
if self.hide_grid is False: if self.hide_grid is False:
self.DC.DrawLine(x1, y1, x1, y2) DC.DrawLine(x1, y1, x1, y2)
self.gridx.append(x1) self.gridx.append(x1)
x1 = x1 + self.dl_w
x1 = x1 + self.cellW
x1 = self.x_st x1 = self.x_st
y1 = self.y_st y1 = self.y_st
x2 = x1 + self.calW + self.restW
x2 = x1 + self.cwidth
for i in range(8): for i in range(8):
if i == 7:
y1 = y1 + self.restH
if self.hide_grid is False: if self.hide_grid is False:
self.DC.DrawLine(x1, y1, x2, y1) DC.DrawLine(x1, y1, x2, y1)
self.gridy.append(y1)
if i == 0:
y1 = y1 + self.dl_th
else:
y1 = y1 + self.dl_h
self.gridy.append(y1)
if i == 0:
y1 = y1 + self.weekHdrCellH
else:
y1 = y1 + self.cellH
def GetColor(self, name):
return MakeColor(self.colors[name])
def SetColor(self, name, value):
self.colors[name] = MakeColor(value)
class PrtCalDraw(CalDraw): class PrtCalDraw(CalDraw):
def InitValues(self): def InitValues(self):
@@ -424,22 +582,24 @@ class wxCalendar(wxWindow):
def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize): def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize):
wxWindow.__init__(self, parent, id, pos, size) wxWindow.__init__(self, parent, id, pos, size)
# set the calendar control attributes # set the calendar control attributes
self.cal = None
self.grid_color = 'BLACK'
self.back_color = 'WHITE'
self.hide_grid = False self.hide_grid = False
self.sel_color = 'RED'
self.hide_title = False self.hide_title = False
self.show_weekend = False self.show_weekend = False
self.cal_type = "NORMAL" self.cal_type = "NORMAL"
self.outer_border = True
self.week_color = 'LIGHT GREY' self.num_align_horz = wxALIGN_CENTRE
self.week_font_color = 'BLACK' # font colors self.num_align_vert = wxALIGN_CENTRE
self.colors = DefaultColors()
self.set_x_mrg = 1
self.set_y_mrg = 1
self.set_y_end = 1
self.select_list = [] self.select_list = []
self.SetBackgroundColour(wxNamedColor(self.back_color)) self.SetBackgroundColour(MakeColor(self.colors[COLOR_BACKGROUND]))
self.Connect(-1, -1, wxEVT_LEFT_DOWN, self.OnLeftEvent) self.Connect(-1, -1, wxEVT_LEFT_DOWN, self.OnLeftEvent)
self.Connect(-1, -1, wxEVT_LEFT_DCLICK, self.OnLeftDEvent) self.Connect(-1, -1, wxEVT_LEFT_DCLICK, self.OnLeftDEvent)
self.Connect(-1, -1, wxEVT_RIGHT_DOWN, self.OnRightEvent) self.Connect(-1, -1, wxEVT_RIGHT_DOWN, self.OnRightEvent)
@@ -456,7 +616,13 @@ class wxCalendar(wxWindow):
EVT_PAINT(self, self.OnPaint) EVT_PAINT(self, self.OnPaint)
EVT_SIZE(self, self.OnSize) EVT_SIZE(self, self.OnSize)
# control some of the main calendar attributes def GetColor(self, name):
return MakeColor(self.colors[name])
def SetColor(self, name, value):
self.colors[name] = MakeColor(value)
# control some of the main calendar attributes
def HideTitle(self): def HideTitle(self):
self.hide_title = True self.hide_title = True
@@ -464,14 +630,14 @@ class wxCalendar(wxWindow):
def HideGrid(self): def HideGrid(self):
self.hide_grid = True self.hide_grid = True
# determine the calendar rectangle click area and draw a selection # determine the calendar rectangle click area and draw a selection
def ProcessClick(self, event): def ProcessClick(self, event):
self.x, self.y = event.GetX(), event.GetY() self.x, self.y = event.GetX(), event.GetY()
key = self.GetDayHit(self.x, self.y) key = self.GetDayHit(self.x, self.y)
self.SelectDay(key) self.SelectDay(key)
# tab mouse click events and process # tab mouse click events and process
def OnLeftEvent(self, event): def OnLeftEvent(self, event):
self.click = 'LEFT' self.click = 'LEFT'
@@ -493,25 +659,23 @@ class wxCalendar(wxWindow):
def SetSize(self, set_size): def SetSize(self, set_size):
self.size = set_size self.size = set_size
def SetSelDay(self, sel): def SetSelDay(self, sel):
self.sel_lst = sel # list of highlighted days self.sel_lst = sel # list of highlighted days
# get the current date # get the current date
def SetNow(self): def SetNow(self):
dt = now() dt = now()
self.month = dt.month self.month = dt.month
self.year = dt.year self.year = dt.year
self.day = dt.day self.day = dt.day
# set the current day # set the current day
def SetCurrentDay(self): def SetCurrentDay(self):
self.SetNow() self.SetNow()
self.set_day = self.day self.set_day = self.day
# get the date, day, month, year set in calendar # get the date, day, month, year set in calendar
def GetDate(self): def GetDate(self):
return self.day, self.month, self.year return self.day, self.month, self.year
@@ -525,7 +689,7 @@ class wxCalendar(wxWindow):
def GetYear(self): def GetYear(self):
return self.year return self.year
# set the day, month, and year # set the day, month, and year
def SetDayValue(self, day): def SetDayValue(self, day):
self.set_day = day self.set_day = day
@@ -540,7 +704,7 @@ class wxCalendar(wxWindow):
def SetYear(self, year): def SetYear(self, year):
self.year = year self.year = year
# increment year and month # increment year and month
def IncYear(self): def IncYear(self):
self.year = self.year + 1 self.year = self.year + 1
@@ -564,11 +728,11 @@ class wxCalendar(wxWindow):
self.year = self.year - 1 self.year = self.year - 1
self.set_day = None self.set_day = None
# test to see if the selection has a date and create event # test to see if the selection has a date and create event
def TestDay(self, key): def TestDay(self, key):
try: try:
self.day = int(self.cal[key]) self.day = int(self.cal_days[key])
except: except:
return None return None
if self.day == "": if self.day == "":
@@ -583,7 +747,7 @@ class wxCalendar(wxWindow):
self.set_day = self.day self.set_day = self.day
return key return key
# find the clicked area rectangle # find the clicked area rectangle
def GetDayHit(self, mx, my): def GetDayHit(self, mx, my):
for key in self.rg.keys(): for key in self.rg.keys():
@@ -592,14 +756,22 @@ class wxCalendar(wxWindow):
if wxIntersectRect(ms_rect, val) is not None: if wxIntersectRect(ms_rect, val) is not None:
result = self.TestDay(key) result = self.TestDay(key)
return result return result
return None return None
# calendar drawing # calendar drawing
def SetWeekColor(self, font_color, week_color): # set font and background color for week title def SetWeekColor(self, font_color, week_color):
self.week_font_color = font_color # set font and background color for week title
self.week_color = week_color self.colors[COLOR_HEADER_FONT] = MakeColor(font_color)
self.colors[COLOR_HEADER_BACKGROUND] = MakeColor(week_color)
self.colors[COLOR_3D_LIGHT] = MakeColor(week_color)
self.colors[COLOR_3D_DARK] = MakeColor(week_color)
def SetTextAlign(self, vert, horz):
self.num_align_horz = horz
self.num_align_vert = vert
def AddSelect(self, list, font_color, back_color): def AddSelect(self, list, font_color, back_color):
list_val = [list, font_color, back_color] list_val = [list, font_color, back_color]
self.select_list.append(list_val) self.select_list.append(list_val)
@@ -619,63 +791,77 @@ class wxCalendar(wxWindow):
self.DoDrawing(DC) self.DoDrawing(DC)
def DoDrawing(self, DC): def DoDrawing(self, DC):
DC = wxPaintDC(self) #DC = wxPaintDC(self)
DC.BeginDrawing() DC.BeginDrawing()
try:
cal = self.caldraw
except:
self.caldraw = CalDraw(self)
cal = self.caldraw
self.cal = cal = CalDraw(self)
cal.grid_color = self.grid_color
cal.back_color = self.back_color
cal.hide_grid = self.hide_grid cal.hide_grid = self.hide_grid
cal.grid_color = self.grid_color
cal.hide_title = self.hide_title cal.hide_title = self.hide_title
cal.show_weekend = self.show_weekend cal.show_weekend = self.show_weekend
cal.cal_type = self.cal_type cal.cal_type = self.cal_type
cal.outer_border = self.outer_border
cal.num_align_horz = self.num_align_horz
cal.num_align_vert = self.num_align_vert
cal.colors = self.colors
if self.size is None: if self.size is None:
size = self.GetClientSize() size = self.GetClientSize()
else: else:
size = self.size size = self.size
# drawing attributes # drawing attributes
cal.week_font_color = self.week_font_color
cal.week_color = self.week_color
cal.SetSize(size) cal.SetSize(size)
cal.SetCal(self.year, self.month) cal.SetCal(self.year, self.month)
# these have to set after SetCal as SetCal would overwrite them again.
cal.set_x_mrg = self.set_x_mrg
cal.set_y_mrg = self.set_y_mrg
cal.set_y_end = self.set_y_end
for val in self.select_list: for val in self.select_list:
cal.AddSelect(val[0], val[1], val[2]) cal.AddSelect(val[0], val[1], val[2])
cal.DrawCal(DC, self.sel_lst) cal.DrawCal(DC, self.sel_lst)
self.rg = cal.GetRect() self.rg = cal.GetRect()
self.cal = cal.GetCal() self.cal_days = cal.GetCal()
self.st_pos = cal.GetOffset() self.st_pos = cal.GetOffset()
self.ymax = DC.MaxY() self.ymax = DC.MaxY()
if self.set_day != None: if self.set_day != None:
self.SetDay(self.set_day) self.SetDay(self.set_day)
DC.EndDrawing() DC.EndDrawing()
# draw the selection rectangle # draw the selection rectangle
def DrawRect(self, key, fgcolor = None, width = 0):
def DrawRect(self, key, color = 'BLACK', width = 0):
if key == None: if key == None:
return return
DC = wxClientDC(self) DC = wxClientDC(self)
DC.BeginDrawing() DC.BeginDrawing()
brush = wxBrush(wxColour(0, 0xFF, 0x80), wxTRANSPARENT) brush = wxBrush(wxColour(0, 0xFF, 0x80), wxTRANSPARENT)
DC.SetBrush(brush) DC.SetBrush(brush)
DC.SetPen(wxPen(wxNamedColour(color), width))
try:
DC.SetPen(wxPen(MakeColor(fgcolor), width))
except:
DC.SetPen(wxPen(MakeColor(self.GetColor(COLOR_GRID_LINES)), width))
rect = self.rg[key] rect = self.rg[key]
DC.DrawRectangle(rect.x, rect.y, rect.width+1, rect.height+1) DC.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
DC.EndDrawing() DC.EndDrawing()
# set the day selection # set the day selection
def SetDay(self, day): def SetDay(self, day):
day = day + self.st_pos - 1 day = day + self.st_pos - 1
@@ -683,23 +869,29 @@ class wxCalendar(wxWindow):
def SelectDay(self, key): def SelectDay(self, key):
sel_size = 1 sel_size = 1
self.DrawRect(self.sel_key, self.back_color, sel_size) # clear large selection self.DrawRect(self.sel_key, self.GetColor(COLOR_BACKGROUND), sel_size) # clear large selection
if self.hide_grid is False:
self.DrawRect(self.sel_key, self.grid_color)
self.DrawRect(key, self.sel_color, sel_size) if self.hide_grid is False:
self.DrawRect(self.sel_key, self.GetColor(COLOR_GRID_LINES),sel_size )
self.DrawRect(key, self.GetColor(COLOR_HIGHLIGHT_BACKGROUND), sel_size)
self.sel_key = key # store last used by self.sel_key = key # store last used by
self.select_day = None self.select_day = None
def ClearDsp(self): def ClearDsp(self):
self.Clear() self.Clear()
def SetMargin(self, xmarg, ymarg):
self.set_x_mrg = xmarg
self.set_y_mrg = ymarg
self.set_y_end = ymarg
class CalenDlg(wxDialog): class CalenDlg(wxDialog):
def __init__(self, parent, month=None, day = None, year=None): def __init__(self, parent, month=None, day = None, year=None):
wxDialog.__init__(self, parent, -1, "Event Calendar", wxPyDefaultPosition, wxSize(280, 360)) wxDialog.__init__(self, parent, -1, "Event Calendar", wxPyDefaultPosition, wxSize(280, 360))
# set the calendar and attributes # set the calendar and attributes
self.calend = wxCalendar(self, -1, wxPoint(20, 60), wxSize(240, 200)) self.calend = wxCalendar(self, -1, wxPoint(20, 60), wxSize(240, 200))
if month == None: if month == None:
self.calend.SetCurrentDay() self.calend.SetCurrentDay()
start_month = self.calend.GetMonth() start_month = self.calend.GetMonth()
@@ -712,15 +904,15 @@ class CalenDlg(wxDialog):
self.calend.HideTitle() self.calend.HideTitle()
self.ResetDisplay() self.ResetDisplay()
# get month list from DateTime # get month list from DateTime
monthlist = GetMonthList() monthlist = GetMonthList()
# select the month # select the month
mID = wxNewId() mID = wxNewId()
self.date = wxComboBox(self, mID, Month[start_month], wxPoint(20, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN) self.date = wxComboBox(self, mID, Month[start_month], wxPoint(20, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN)
EVT_COMBOBOX(self, mID, self.EvtComboBox) EVT_COMBOBOX(self, mID, self.EvtComboBox)
# alternate spin button to control the month # alternate spin button to control the month
mID = wxNewId() mID = wxNewId()
h = self.date.GetSize().height h = self.date.GetSize().height
self.m_spin = wxSpinButton(self, mID, wxPoint(130, 20), wxSize(h*2, h), wxSP_VERTICAL) self.m_spin = wxSpinButton(self, mID, wxPoint(130, 20), wxSize(h*2, h), wxSP_VERTICAL)
@@ -729,7 +921,7 @@ class CalenDlg(wxDialog):
EVT_SPIN(self, mID, self.OnMonthSpin) EVT_SPIN(self, mID, self.OnMonthSpin)
# spin button to control the year # spin button to control the year
mID = wxNewId() mID = wxNewId()
self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(160, 20), wxSize(60, -1)) self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(160, 20), wxSize(60, -1))
h = self.dtext.GetSize().height h = self.dtext.GetSize().height
@@ -794,6 +986,3 @@ class CalenDlg(wxDialog):
def ResetDisplay(self): def ResetDisplay(self):
month = self.calend.GetMonth() month = self.calend.GetMonth()
self.calend.Refresh() self.calend.Refresh()