]> git.saurik.com Git - wxWidgets.git/blob - wxPython/wx/lib/printout.py
style sheet for the api docs
[wxWidgets.git] / wxPython / wx / lib / printout.py
1 #----------------------------------------------------------------------------
2 # Name: printout.py
3 # Purpose: preview and printing class -> table/grid printing
4 #
5 # Author: Lorne White (email: lorne.white@telusplanet.net)
6 #
7 # Created:
8 # Version 0.75
9 # Date: May 15, 2002
10 # Licence: wxWindows license
11 #----------------------------------------------------------------------------
12 # Release Notes
13
14 # fixed bug for string wider than print region
15 # add index to data list after parsing total pages for paging
16 #----------------------------------------------------------------------------
17 # 12/10/2003 - Jeff Grimmett (grimmtooth@softhome.net)
18 #
19 # o 2.5 compatability update.
20 #
21
22 import copy
23 import os
24 import sys
25
26 import wx
27
28 class PrintBase:
29 def SetPrintFont(self, font): # set the DC font parameters
30 fattr = font["Attr"]
31 if fattr[0] == 1:
32 weight = wx.BOLD
33 else:
34 weight = wx.NORMAL
35
36 if fattr[1] == 1:
37 set_style = wx.ITALIC
38 else:
39 set_style = wx.NORMAL
40
41 underline = fattr[2]
42 fcolour = self.GetFontColour(font)
43 self.DC.SetTextForeground(fcolour)
44
45 setfont = wx.Font(font["Size"], wx.SWISS, set_style, weight, underline)
46 setfont.SetFaceName(font["Name"])
47 self.DC.SetFont(setfont)
48
49 def GetFontColour(self, font):
50 fcolour = font["Colour"]
51 return wx.Colour(fcolour[0], fcolour[1], fcolour[2])
52
53 def OutTextRegion(self, textout, txtdraw = True):
54 textlines = textout.split('\n')
55 y = copy.copy(self.y) + self.pt_space_before
56 for text in textlines:
57 remain = 'X'
58 while remain != "":
59 vout, remain = self.SetFlow(text, self.region)
60 if self.draw == True and txtdraw == True:
61 test_out = self.TestFull(vout)
62 if self.align == wx.ALIGN_LEFT:
63 self.DC.DrawText(test_out, (self.indent+self.pcell_left_margin, y))
64
65 elif self.align == wx.ALIGN_CENTRE:
66 diff = self.GetCellDiff(test_out, self.region)
67 self.DC.DrawText(test_out, (self.indent+diff/2, y))
68
69 elif self.align == wx.ALIGN_RIGHT:
70 diff = self.GetCellDiff(test_out, self.region)
71 self.DC.DrawText(test_out, (self.indent+diff, y))
72
73 else:
74 self.DC.DrawText(test_out, (self.indent+self.pcell_left_margin, y))
75 text = remain
76 y = y + self.space
77 return y - self.space + self.pt_space_after
78
79 def GetCellDiff(self, text, width): # get the remaining cell size for adjustment
80 w, h = self.DC.GetTextExtent(text)
81 diff = width - w
82 if diff < 0:
83 diff = 0
84 return diff
85
86 def TestFull(self, text_test):
87 w, h = self.DC.GetTextExtent(text_test)
88 if w > self.region: # trouble fitting into cell
89 return self.SetChar(text_test, self.region) # fit the text to the cell size
90 else:
91 return text_test
92
93 def SetFlow(self, ln_text, width):
94 width = width - self.pcell_right_margin
95 text = ""
96 split = ln_text.split()
97 if len(split) == 1:
98 return ln_text, ""
99
100 try:
101 w, h = self.DC.GetTextExtent(" " + split[0])
102 if w >= width:
103 return ln_text, ""
104 except:
105 pass
106
107 cnt = 0
108 for word in split:
109 bword = " " + word # blank + word
110 length = len(bword)
111
112 w, h = self.DC.GetTextExtent(text + bword)
113 if w < width:
114 text = text + bword
115 cnt = cnt + 1
116 else:
117 remain = ' '.join(split[cnt:])
118 text = text.strip()
119 return text, remain
120
121 remain = ' '.join(split[cnt:])
122 vout = text.strip()
123 return vout, remain
124
125 def SetChar(self, ln_text, width): # truncate string to fit into width
126 width = width - self.pcell_right_margin - self.pcell_left_margin
127 text = ""
128 for val in ln_text:
129 w, h = self.DC.GetTextExtent(text + val)
130 if w > width:
131 text = text + ".."
132 return text # fitted text value
133 text = text + val
134 return text
135
136 def OutTextPageWidth(self, textout, y_out, align, indent, txtdraw = True):
137 textlines = textout.split('\n')
138 y = copy.copy(y_out)
139
140 pagew = self.parent.page_width * self.pwidth # full page width
141 w, h = self.DC.GetTextExtent(textout)
142 y_line = h
143
144 for text in textlines:
145 remain = 'X'
146 while remain != "":
147 vout, remain = self.SetFlow(text, pagew)
148 if self.draw == True and txtdraw == True:
149 test_out = vout
150 if align == wx.ALIGN_LEFT:
151 self.DC.DrawText(test_out, (indent, y))
152
153 elif align == wx.ALIGN_CENTRE:
154 diff = self.GetCellDiff(test_out, pagew)
155 self.DC.DrawText(test_out, (indent+diff/2, y))
156
157 elif align == wx.ALIGN_RIGHT:
158 diff = self.GetCellDiff(test_out, pagew)
159 self.DC.DrawText(test_out, (indent+diff, y))
160
161 else:
162 self.DC.DrawText(test_out, (indent, y_out))
163 text = remain
164 y = y + y_line
165 return y - y_line
166
167 def GetDate(self):
168 date, time = self.GetNow()
169 return date
170
171 def GetDateTime(self):
172 date, time = self.GetNow()
173 return date + ' ' + time
174
175 def GetNow(self):
176 full = str(wx.DateTime_Now()) # get the current date and time in print format
177 flds = full.split()
178 date = flds[0]
179 time = flds[1]
180 return date, time
181
182 def SetPreview(self, preview):
183 self.preview = preview
184
185 def SetPSize(self, width, height):
186 self.pwidth = width/self.scale
187 self.pheight = height/self.scale
188
189 def SetScale(self, scale):
190 self.scale = scale
191
192 def SetPTSize(self, width, height):
193 self.ptwidth = width
194 self.ptheight = height
195
196 def getWidth(self):
197 return self.sizew
198
199 def getHeight(self):
200 return self.sizeh
201
202
203 class PrintTableDraw(wx.ScrolledWindow, PrintBase):
204 def __init__(self, parent, DC, size):
205 self.parent = parent
206 self.DC = DC
207 self.scale = parent.scale
208 self.width = size[0]
209 self.height = size[1]
210 self.SetDefaults()
211
212 def SetDefaults(self):
213 self.page = 1
214 self.total_pages = None
215
216 self.page_width = self.parent.page_width
217 self.page_height = self.parent.page_height
218
219 self.left_margin = self.parent.left_margin
220 self.right_margin = self.parent.right_margin
221
222 self.top_margin = self.parent.top_margin
223 self.bottom_margin = self.parent.bottom_margin
224 self.cell_left_margin = self.parent.cell_left_margin
225 self.cell_right_margin = self.parent.cell_right_margin
226
227 self.label_colour = self.parent.label_colour
228
229 self.row_line_colour = self.parent.row_line_colour
230 self.row_line_size = self.parent.row_line_size
231
232 self.row_def_line_colour = self.parent.row_def_line_colour
233 self.row_def_line_size = self.parent.row_def_line_size
234
235 self.column_line_colour = self.parent.column_line_colour
236 self.column_line_size = self.parent.column_line_size
237
238 self.column_def_line_size = self.parent.column_def_line_size
239 self.column_def_line_colour = self.parent.column_def_line_colour
240
241 self.text_font = self.parent.text_font
242
243 self.label_font = self.parent.label_font
244
245 def AdjustValues(self):
246 self.vertical_offset = self.pheight * self.parent.vertical_offset
247 self.horizontal_offset = self.pheight * self.parent.horizontal_offset
248
249 self.pcell_left_margin = self.pwidth * self.cell_left_margin
250 self.pcell_right_margin = self.pwidth * self.cell_right_margin
251 self.ptop_margin = self.pheight * self.top_margin
252 self.pbottom_margin = self.pheight * self.bottom_margin
253
254 self.pheader_margin = self.pheight * self.parent.header_margin
255 self.pfooter_margin = self.pheight * self.parent.footer_margin
256
257 self.cell_colour = self.parent.set_cell_colour
258 self.cell_text = self.parent.set_cell_text
259
260 self.column = []
261 self.column_align = []
262 self.column_bgcolour = []
263 self.column_txtcolour = []
264
265 set_column_align = self.parent.set_column_align
266 set_column_bgcolour = self.parent.set_column_bgcolour
267 set_column_txtcolour = self.parent.set_column_txtcolour
268
269 pos_x = self.left_margin * self.pwidth + self.horizontal_offset # left margin
270 self.column.append(pos_x)
271
272 if self.set_column == []:
273 table_width = self.page_width - self.left_margin - self.right_margin
274 width = table_width/(len(self.label))
275 for val in self.label:
276 column_width = width * self.pwidth
277 pos_x = pos_x + column_width
278 self.column.append(pos_x) # position of each column
279 else:
280 for val in self.set_column:
281 column_width = val * self.pwidth
282 pos_x = pos_x + column_width
283 self.column.append(pos_x) # position of each column
284
285 if pos_x > self.page_width * self.pwidth: # check if it fits in page
286 print "Warning, Too Wide for Page"
287 return
288
289 if self.label != []:
290 if len(self.column) -1 != len(self.label):
291 print "Column Settings Incorrect", "\nColumn Value: " + str(self.column), "\nLabel Value: " + str(self.label)
292 return
293
294 first_value = self.data[0]
295 column_total = len(first_value)
296 if column_total != len(self.column) -1:
297 print "Column Settings Incorrect", first_value, self.column
298 return
299
300 col = 0
301 for col in range(column_total):
302 try:
303 align = set_column_align[col] # check if custom column alignment
304 except:
305 align = wx.ALIGN_LEFT
306 self.column_align.append(align)
307
308 try:
309 colour = set_column_bgcolour[col] # check if custom column background colour
310 except:
311 colour = self.parent.column_colour
312 self.column_bgcolour.append(colour)
313
314 try:
315 colour = set_column_txtcolour[col] # check if custom column text colour
316 except:
317 colour = self.GetFontColour(self.parent.text_font)
318
319 self.column_txtcolour.append(colour)
320
321 col = col + 1
322
323 def SetPointAdjust(self):
324 f = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL) # setup using 10 point
325 self.DC.SetFont(f)
326 f.SetFaceName(self.text_font["Name"])
327 x, y = self.DC.GetTextExtent("W")
328
329 self.label_pt_space_before = self.parent.label_pt_adj_before * y/10 # extra spacing for label per point value
330 self.label_pt_space_after = self.parent.label_pt_adj_after * y/10
331
332 self.text_pt_space_before = self.parent.text_pt_adj_before * y/10 # extra spacing for row text per point value
333 self.text_pt_space_after = self.parent.text_pt_adj_after * y/10
334
335 def SetPage(self, page):
336 self.page = page
337
338 def SetColumns(self, col):
339 self.column = col
340
341 def OutCanvas(self):
342 self.AdjustValues()
343 self.SetPointAdjust()
344
345 self.y_start = self.ptop_margin + self.vertical_offset
346 self.y_end = self.parent.page_height * self.pheight - self.pbottom_margin + self.vertical_offset
347
348 self.SetPrintFont(self.label_font)
349
350 x, y = self.DC.GetTextExtent("W")
351 self.label_space = y
352
353 self.SetPrintFont(self.text_font)
354
355 x, y = self.DC.GetTextExtent("W")
356 self.space = y
357
358 if self.total_pages is None:
359 self.GetTotalPages() # total pages for display/printing
360
361 self.data_cnt = self.page_index[self.page-1]
362
363 self.draw = True
364 self.PrintHeader()
365 self.PrintFooter()
366 self.OutPage()
367
368 def GetTotalPages(self):
369 self.data_cnt = 0
370 self.draw = False
371 self.page_index = [0]
372
373 cnt = 0
374 while 1:
375 test = self.OutPage()
376 self.page_index.append(self.data_cnt)
377 if test == False:
378 break
379 cnt = cnt + 1
380
381 self.total_pages = cnt + 1
382
383 def OutPage(self):
384 self.y = self.y_start
385 self.end_x = self.column[-1]
386
387 if self.data_cnt < len(self.data): # if there data for display on the page
388 if self.label != []: # check if header defined
389 self.PrintLabel()
390 else:
391 return False
392
393 for val in self.data:
394 try:
395 row_val = self.data[self.data_cnt]
396 except:
397 self.FinishDraw()
398 return False
399
400 max_y = self.PrintRow(row_val, False) # test to see if row will fit in remaining space
401 test = max_y + self.space
402
403 if test > self.y_end:
404 break
405
406 self.ColourRowCells(max_y-self.y+self.space) # colour the row/column
407 max_y = self.PrintRow(row_val, True) # row fits - print text
408 self.DrawGridLine() # top line of cell
409 self.y = max_y + self.space
410
411 if self.y > self.y_end:
412 break
413
414 self.data_cnt = self.data_cnt + 1
415
416 self.FinishDraw()
417
418 if self.data_cnt == len(self.data): # last value in list
419 return False
420
421 return True
422
423
424 def PrintLabel(self):
425 self.pt_space_before = self.label_pt_space_before # set the point spacing
426 self.pt_space_after = self.label_pt_space_after
427
428 self.LabelColorRow(self.label_colour)
429 self.SetPrintFont(self.label_font)
430
431 self.col = 0
432 max_y = 0
433 for vtxt in self.label:
434 self.region = self.column[self.col+1] - self.column[self.col]
435 self.indent = self.column[self.col]
436
437 self.align = wx.ALIGN_LEFT
438
439 max_out = self.OutTextRegion(vtxt, True)
440 if max_out > max_y:
441 max_y = max_out
442 self.col = self.col + 1
443
444 self.DrawGridLine() # top line of label
445 self.y = max_y + self.label_space
446
447 def PrintHeader(self): # print the header array
448 if self.draw == False:
449 return
450
451 for val in self.parent.header:
452 self.SetPrintFont(val["Font"])
453
454 header_indent = val["Indent"] * self.pwidth
455 text = val["Text"]
456
457 htype = val["Type"]
458 if htype == "Date":
459 addtext = self.GetDate()
460 elif htype == "Date & Time":
461 addtext = self.GetDateTime()
462 else:
463 addtext = ""
464
465 self.OutTextPageWidth(text+addtext, self.pheader_margin, val["Align"], header_indent, True)
466
467 def PrintFooter(self): # print the header array
468 if self.draw == False:
469 return
470
471 footer_pos = self.parent.page_height * self.pheight - self.pfooter_margin + self.vertical_offset
472 for val in self.parent.footer:
473 self.SetPrintFont(val["Font"])
474
475 footer_indent = val["Indent"] * self.pwidth
476 text = val["Text"]
477
478 ftype = val["Type"]
479 if ftype == "Pageof":
480 addtext = "Page " + str(self.page) + " of " + str(self.total_pages)
481 elif ftype == "Page":
482 addtext = "Page " + str(self.page)
483 elif ftype == "Num":
484 addtext = str(self.page)
485 elif ftype == "Date":
486 addtext = self.GetDate()
487 elif ftype == "Date & Time":
488 addtext = self.GetDateTime()
489 else:
490 addtext = ""
491
492 self.OutTextPageWidth(text+addtext, footer_pos, val["Align"], footer_indent, True)
493
494
495 def LabelColorRow(self, colour):
496 brush = wx.Brush(colour, wx.SOLID)
497 self.DC.SetBrush(brush)
498 height = self.label_space + self.label_pt_space_before + self.label_pt_space_after
499 self.DC.DrawRectangle((self.column[0], self.y),
500 (self.end_x-self.column[0]+1, height))
501
502 def ColourRowCells(self, height):
503 if self.draw == False:
504 return
505
506 col = 0
507 for colour in self.column_bgcolour:
508 cellcolour = self.GetCellColour(self.data_cnt, col)
509 if cellcolour is not None:
510 colour = cellcolour
511
512 brush = wx.Brush(colour, wx.SOLID)
513 self.DC.SetBrush(brush)
514 self.DC.SetPen(wx.Pen(wx.NamedColour('WHITE'), 0))
515
516 start_x = self.column[col]
517 width = self.column[col+1] - start_x + 2
518 self.DC.DrawRectangle((start_x, self.y), (width, height))
519 col = col + 1
520
521 def PrintRow(self, row_val, draw = True, align = wx.ALIGN_LEFT):
522 self.SetPrintFont(self.text_font)
523
524 self.pt_space_before = self.text_pt_space_before # set the point spacing
525 self.pt_space_after = self.text_pt_space_after
526
527 self.col = 0
528 max_y = 0
529 for vtxt in row_val:
530 self.region = self.column[self.col+1] - self.column[self.col]
531 self.indent = self.column[self.col]
532 self.align = self.column_align[self.col]
533
534 fcolour = self.column_txtcolour[self.col] # set font colour
535 celltext = self.GetCellText(self.data_cnt, self.col)
536 if celltext is not None:
537 fcolour = celltext # override the column colour
538
539 self.DC.SetTextForeground(fcolour)
540
541 max_out = self.OutTextRegion(vtxt, draw)
542 if max_out > max_y:
543 max_y = max_out
544 self.col = self.col + 1
545 return max_y
546
547 def GetCellColour(self, row, col): # check if custom colour defined for the cell background
548 try:
549 set = self.cell_colour[row]
550 except:
551 return None
552 try:
553 colour = set[col]
554 return colour
555 except:
556 return None
557
558 def GetCellText(self, row, col): # check if custom colour defined for the cell text
559 try:
560 set = self.cell_text[row]
561 except:
562 return None
563 try:
564 colour = set[col]
565 return colour
566 except:
567 return None
568
569 def FinishDraw(self):
570 self.DrawGridLine() # draw last row line
571 self.DrawColumns() # draw all vertical lines
572
573 def DrawGridLine(self):
574 if self.draw == True:
575 try:
576 size = self.row_line_size[self.data_cnt]
577 except:
578 size = self.row_def_line_size
579
580 try:
581 colour = self.row_line_colour[self.data_cnt]
582 except:
583 colour = self.row_def_line_colour
584
585 self.DC.SetPen(wx.Pen(colour, size))
586
587 y_out = self.y
588 # y_out = self.y + self.pt_space_before + self.pt_space_after # adjust for extra spacing
589 self.DC.DrawLine((self.column[0], y_out), (self.end_x, y_out))
590
591 def DrawColumns(self):
592 if self.draw == True:
593 col = 0
594 for val in self.column:
595 try:
596 size = self.column_line_size[col]
597 except:
598 size = self.column_def_line_size
599
600 try:
601 colour = self.column_line_colour[col]
602 except:
603 colour = self.column_def_line_colour
604
605 indent = val
606
607 self.DC.SetPen(wx.Pen(colour, size))
608 self.DC.DrawLine((indent, self.y_start), (indent, self.y))
609 col = col + 1
610
611 def DrawText(self):
612 self.DoRefresh()
613
614 def DoDrawing(self, DC):
615 size = DC.GetSize()
616 self.DC = DC
617
618 DC.BeginDrawing()
619 self.DrawText()
620 DC.EndDrawing()
621
622 self.sizew = DC.MaxY()
623 self.sizeh = DC.MaxX()
624
625
626 class PrintTable:
627 def __init__(self, parentFrame=None):
628 self.data = []
629 self.set_column = []
630 self.label = []
631 self.header = []
632 self.footer = []
633
634 self.set_column_align = {}
635 self.set_column_bgcolour = {}
636 self.set_column_txtcolour = {}
637 self.set_cell_colour = {}
638 self.set_cell_text = {}
639 self.column_line_size = {}
640 self.column_line_colour = {}
641 self.row_line_size = {}
642 self.row_line_colour = {}
643
644 self.parentFrame = parentFrame
645 self.SetPreviewSize()
646
647 self.printData = wx.PrintData()
648 self.scale = 1.0
649
650 self.SetParms()
651 self.SetColors()
652 self.SetFonts()
653 self.TextSpacing()
654
655 self.SetPrinterOffset()
656 self.SetHeaderValue()
657 self.SetFooterValue()
658 self.SetMargins()
659 self.SetPortrait()
660
661 def SetPreviewSize(self, position = wx.Point(0, 0), size="Full"):
662 if size == "Full":
663 r = wx.GetClientDisplayRect()
664 self.preview_frame_size = r.GetSize()
665 self.preview_frame_pos = r.GetPosition()
666 else:
667 self.preview_frame_size = size
668 self.preview_frame_pos = position
669
670 def SetPaperId(self, paper):
671 self.printData.SetPaperId(paper)
672
673 def SetOrientation(self, orient):
674 self.printData.SetOrientation(orient)
675
676 def SetColors(self):
677 self.row_def_line_colour = wx.NamedColour('BLACK')
678 self.row_def_line_size = 1
679
680 self.column_def_line_colour = wx.NamedColour('BLACK')
681 self.column_def_line_size = 1
682 self.column_colour = wx.NamedColour('WHITE')
683
684 self.label_colour = wx.NamedColour('LIGHT GREY')
685
686 def SetFonts(self):
687 self.label_font = { "Name": self.default_font_name, "Size": 12, "Colour": [0, 0, 0], "Attr": [0, 0, 0] }
688 self.text_font = { "Name": self.default_font_name, "Size": 10, "Colour": [0, 0, 0], "Attr": [0, 0, 0] }
689
690 def TextSpacing(self):
691 self.label_pt_adj_before = 0 # point adjustment before and after the label text
692 self.label_pt_adj_after = 0
693
694 self.text_pt_adj_before = 0 # point adjustment before and after the row text
695 self.text_pt_adj_after = 0
696
697 def SetLabelSpacing(self, before, after): # method to set the label space adjustment
698 self.label_pt_adj_before = before
699 self.label_pt_adj_after = after
700
701 def SetRowSpacing(self, before, after): # method to set the row space adjustment
702 self.text_pt_adj_before = before
703 self.text_pt_adj_after = after
704
705 def SetPrinterOffset(self): # offset to adjust for printer
706 self.vertical_offset = -0.1
707 self.horizontal_offset = -0.1
708
709 def SetHeaderValue(self):
710 self.header_margin = 0.25
711 self.header_font = { "Name": self.default_font_name, "Size": 11, "Colour": [0, 0, 0], "Attr": [0, 0, 0] }
712 self.header_align = wx.ALIGN_CENTRE
713 self.header_indent = 0
714 self.header_type = "Text"
715
716 def SetFooterValue(self):
717 self.footer_margin = 0.7
718 self.footer_font = { "Name": self.default_font_name, "Size": 11, "Colour": [0, 0, 0], "Attr": [0, 0, 0] }
719 self.footer_align = wx.ALIGN_CENTRE
720 self.footer_indent = 0
721 self.footer_type = "Pageof"
722
723 def SetMargins(self):
724 self.left_margin = 1.0
725 self.right_margin = 1.0 # only used if no column sizes
726
727 self.top_margin = 0.8
728 self.bottom_margin = 1.0
729 self.cell_left_margin = 0.1
730 self.cell_right_margin = 0.1
731
732 def SetPortrait(self):
733 self.printData.SetPaperId(wx.PAPER_LETTER)
734 self.printData.SetOrientation(wx.PORTRAIT)
735 self.page_width = 8.5
736 self.page_height = 11.0
737
738 def SetLandscape(self):
739 self.printData.SetOrientation(wx.LANDSCAPE)
740 self.page_width = 11.0
741 self.page_height = 8.5
742
743 def SetParms(self):
744 self.ymax = 1
745 self.xmax = 1
746 self.page = 1
747 self.total_pg = 100
748
749 self.preview = None
750 self.page = 0
751
752 self.default_font_name = "Arial"
753 self.default_font = { "Name": self.default_font_name, "Size": 10, "Colour": [0, 0, 0], "Attr": [0, 0, 0] }
754
755 def SetColAlignment(self, col, align=wx.ALIGN_LEFT):
756 self.set_column_align[col] = align
757
758 def SetColBackgroundColour(self, col, colour):
759 self.set_column_bgcolour[col] = colour
760
761 def SetColTextColour(self, col, colour):
762 self.set_column_txtcolour[col] = colour
763
764 def SetCellColour(self, row, col, colour): # cell background colour
765 try:
766 set = self.set_cell_colour[row] # test if row already exists
767 try:
768 set[col] = colour # test if column already exists
769 except:
770 set = { col: colour } # create the column value
771 except:
772 set = { col: colour } # create the column value
773
774 self.set_cell_colour[row] = set # create dictionary item for colour settings
775
776 def SetCellText(self, row, col, colour): # font colour for custom cells
777 try:
778 set = self.set_cell_text[row] # test if row already exists
779 try:
780 set[col] = colour # test if column already exists
781 except:
782 set = { col: colour } # create the column value
783 except:
784 set = { col: colour } # create the column value
785
786 self.set_cell_text[row] = set # create dictionary item for colour settings
787
788 def SetColumnLineSize(self, col, size): # column line size
789 self.column_line_size[col] = size # create dictionary item for column line settings
790
791 def SetColumnLineColour(self, col, colour):
792 self.column_line_colour[col] = colour
793
794 def SetRowLineSize(self, row, size):
795 self.row_line_size[row] = size
796
797 def SetRowLineColour(self, row, colour):
798 self.row_line_colour[row] = colour
799
800 def GetColour(self, colour): # returns colours based from wxColour value
801 red = colour.Red()
802 blue = colour.Blue()
803 green = colour.Green()
804 return [red, green, blue ]
805
806 def SetHeader(self, text = "", type = "Text", font=None, align = None, indent = None, colour = None, size = None):
807 set = { "Text": text }
808
809 if font is None:
810 set["Font"] = copy.copy(self.default_font)
811 else:
812 set["Font"] = font
813
814 if colour is not None:
815 setfont = set["Font"]
816 setfont["Colour"] = self.GetColour(colour)
817
818 if size is not None:
819 setfont = set["Font"]
820 setfont["Size"] = size
821
822 if align is None:
823 set["Align"] = self.header_align
824 else:
825 set["Align"] = align
826
827 if indent is None:
828 set["Indent"] = self.header_indent
829 else:
830 set["Indent"] = indent
831
832 if type is None:
833 set["Type"] = self.header_type
834 else:
835 set["Type"] = type
836
837 self.header.append(set)
838
839 def SetFooter(self, text = "", type = None, font=None, align = None, indent = None, colour = None, size = None):
840 set = { "Text": text }
841
842 if font is None:
843 set["Font"] = copy.copy(self.default_font)
844 else:
845 set["Font"] = font
846
847 if colour is not None:
848 setfont = set["Font"]
849 setfont["Colour"] = self.GetColour(colour)
850
851 if size is not None:
852 setfont = set["Font"]
853 setfont["Size"] = size
854
855 if align is None:
856 set["Align"] = self.footer_align
857 else:
858 set["Align"] = align
859
860 if indent is None:
861 set["Indent"] = self.footer_indent
862 else:
863 set["Indent"] = indent
864
865 if type is None:
866 set["Type"] = self.footer_type
867 else:
868 set["Type"] = type
869
870 self.footer.append(set)
871
872 def Preview(self):
873 printout = SetPrintout(self)
874 printout2 = SetPrintout(self)
875 self.preview = wx.PrintPreview(printout, printout2, self.printData)
876 if not self.preview.Ok():
877 wxMessageBox("There was a problem printing!", "Printing", wx.OK)
878 return
879
880 self.preview.SetZoom(60) # initial zoom value
881
882 frame = wx.PreviewFrame(self.preview, self.parentFrame, "Print preview")
883
884 frame.Initialize()
885 if self.parentFrame:
886 frame.SetPosition(self.preview_frame_pos)
887 frame.SetSize(self.preview_frame_size)
888 frame.Show(True)
889
890 def Print(self):
891 pdd = wx.PrintDialogData()
892 pdd.SetPrintData(self.printData)
893 printer = wx.Printer(pdd)
894 printout = SetPrintout(self)
895 if not printer.Print(self.parentFrame, printout):
896 wx.MessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wx.OK)
897 else:
898 self.printData = printer.GetPrintDialogData().GetPrintData()
899 printout.Destroy()
900
901 def DoDrawing(self, DC):
902 size = DC.GetSize()
903 DC.BeginDrawing()
904
905 table = PrintTableDraw(self, DC, size)
906 table.data = self.data
907 table.set_column = self.set_column
908 table.label = self.label
909 table.SetPage(self.page)
910
911 if self.preview is None:
912 table.SetPSize(size[0]/self.page_width, size[1]/self.page_height)
913 table.SetPTSize(size[0], size[1])
914 table.SetPreview(False)
915 else:
916 if self.preview == 1:
917 table.scale = self.scale
918 table.SetPSize(size[0]/self.page_width, size[1]/self.page_height)
919 else:
920 table.SetPSize(self.pwidth, self.pheight)
921
922 table.SetPTSize(self.ptwidth, self.ptheight)
923 table.SetPreview(self.preview)
924
925 table.OutCanvas()
926 self.page_total = table.total_pages # total display pages
927
928 DC.EndDrawing()
929
930 self.ymax = DC.MaxY()
931 self.xmax = DC.MaxX()
932
933 self.sizeh = size[0]
934 self.sizew = size[1]
935
936 def GetTotalPages(self):
937 self.page_total = 100
938 return self.page_total
939
940 def HasPage(self, page):
941 if page <= self.page_total:
942 return True
943 else:
944 return False
945
946 def SetPage(self, page):
947 self.page = page
948
949 def SetPageSize(self, width, height):
950 self.pwidth, self.pheight = width, height
951
952 def SetTotalSize(self, width, height):
953 self.ptwidth, self.ptheight = width, height
954
955 def SetPreview(self, preview, scale):
956 self.preview = preview
957 self.scale = scale
958
959 def SetTotalSize(self, width, height):
960 self.ptwidth = width
961 self.ptheight = height
962
963 class PrintGrid:
964 def __init__(self, parent, grid, format = [], total_col = None, total_row = None):
965 if total_row is None:
966 total_row = grid.GetNumberRows()
967 if total_col is None:
968 total_col = grid.GetNumberCols()
969
970 self.total_row = total_row
971 self.total_col = total_col
972 self.grid = grid
973
974 data = []
975 for row in range(total_row):
976 row_val = []
977 value = grid.GetRowLabelValue(row)
978 row_val.append(value)
979
980 for col in range(total_col):
981 value = grid.GetCellValue(row, col)
982 row_val.append(value)
983 data.append(row_val)
984
985 label = [""]
986 for col in range(total_col):
987 value = grid.GetColLabelValue(col)
988 label.append(value)
989
990 self.table = PrintTable(parent)
991 self.table.cell_left_margin = 0.0
992 self.table.cell_right_margin = 0.0
993
994 self.table.label = label
995 self.table.set_column = format
996 self.table.data = data
997
998 def GetTable(self):
999 return self.table
1000
1001 def SetAttributes(self):
1002 for row in range(self.total_row):
1003 for col in range(self.total_col):
1004 colour = self.grid.GetCellTextColour(row, col-1)
1005 self.table.SetCellText(row, col, colour)
1006
1007 colour = self.grid.GetCellBackgroundColour(row, col-1)
1008 self.table.SetCellColour(row, col, colour)
1009
1010 def Preview(self):
1011 self.table.Preview()
1012
1013 def Print(self):
1014 self.table.Print()
1015
1016
1017 class SetPrintout(wx.Printout):
1018 def __init__(self, canvas):
1019 wx.Printout.__init__(self)
1020 self.canvas = canvas
1021 self.end_pg = 1000
1022
1023 def OnBeginDocument(self, start, end):
1024 return self.base_OnBeginDocument(start, end)
1025
1026 def OnEndDocument(self):
1027 self.base_OnEndDocument()
1028
1029 def HasPage(self, page):
1030 try:
1031 end = self.canvas.HasPage(page)
1032 return end
1033 except:
1034 return True
1035
1036 def GetPageInfo(self):
1037 try:
1038 self.end_pg = self.canvas.GetTotalPages()
1039 except:
1040 pass
1041
1042 end_pg = self.end_pg
1043 str_pg = 1
1044 return (str_pg, end_pg, str_pg, end_pg)
1045
1046 def OnPreparePrinting(self):
1047 self.base_OnPreparePrinting()
1048
1049 def OnBeginPrinting(self):
1050 dc = self.GetDC()
1051
1052 self.preview = self.IsPreview()
1053 if (self.preview):
1054 self.pixelsPerInch = self.GetPPIScreen()
1055 else:
1056 self.pixelsPerInch = self.GetPPIPrinter()
1057
1058 (w, h) = dc.GetSize()
1059 scaleX = float(w) / 1000
1060 scaleY = float(h) / 1000
1061 self.printUserScale = min(scaleX, scaleY)
1062
1063 self.base_OnBeginPrinting()
1064
1065 def GetSize(self):
1066 self.psizew, self.psizeh = self.GetPPIPrinter()
1067 return self.psizew, self.psizeh
1068
1069 def GetTotalSize(self):
1070 self.ptsizew, self.ptsizeh = self.GetPageSizePixels()
1071 return self.ptsizew, self.ptsizeh
1072
1073 def OnPrintPage(self, page):
1074 dc = self.GetDC()
1075 (w, h) = dc.GetSize()
1076 scaleX = float(w) / 1000
1077 scaleY = float(h) / 1000
1078 self.printUserScale = min(scaleX, scaleY)
1079 dc.SetUserScale(self.printUserScale, self.printUserScale)
1080
1081 self.preview = self.IsPreview()
1082
1083 self.canvas.SetPreview(self.preview, self.printUserScale)
1084 self.canvas.SetPage(page)
1085
1086 self.ptsizew, self.ptsizeh = self.GetPageSizePixels()
1087 self.canvas.SetTotalSize(self.ptsizew, self.ptsizeh)
1088
1089 self.psizew, self.psizeh = self.GetPPIPrinter()
1090 self.canvas.SetPageSize(self.psizew, self.psizeh)
1091
1092 self.canvas.DoDrawing(dc)
1093 return True
1094
1095
1096
1097
1098
1099