Lots of demo tweaks for API updates, bug fixes and new images for the
wxListbook demo git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24620 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
parent
5c0ccabf02
commit
fbd5dd1dfa
@ -99,17 +99,16 @@ def runTest(frame, nb, log):
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
overview = """\
|
||||
|
||||
"""
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys,os
|
||||
import run
|
||||
run.main(['', os.path.basename(sys.argv[0])])
|
||||
|
||||
|
||||
@ -25,17 +25,6 @@ You can get it at:
|
||||
overview = ""
|
||||
|
||||
else:
|
||||
def runTest(frame, nb, log):
|
||||
"""
|
||||
This method is used by the wxPython Demo Framework for integrating
|
||||
this demo with the rest.
|
||||
"""
|
||||
win = DrawFrame(NULL, -1, "FloatCanvas Drawing Window",wxDefaultPosition,wxSize(500,500))
|
||||
frame.otherWin = win
|
||||
win.Show(True)
|
||||
|
||||
|
||||
|
||||
from wxPython.lib import floatcanvas
|
||||
import wxPython.lib.colourdb
|
||||
|
||||
@ -48,10 +37,10 @@ else:
|
||||
ID_DRAWMAP2_MENU = wxNewId()
|
||||
ID_CLEAR_MENU = wxNewId()
|
||||
|
||||
wxPython.lib.colourdb.updateColourDB()
|
||||
colors = wxPython.lib.colourdb.getColourList()
|
||||
|
||||
colors = []
|
||||
LineStyles = floatcanvas.draw_object.LineStyleList.keys()
|
||||
|
||||
|
||||
|
||||
class DrawFrame(wxFrame):
|
||||
|
||||
@ -372,7 +361,11 @@ else:
|
||||
"""
|
||||
|
||||
def OnInit(self):
|
||||
frame = DrawFrame(NULL, -1, "FloatCanvas Demo App",wxDefaultPosition,wxSize(700,700))
|
||||
global colors
|
||||
wxPython.lib.colourdb.updateColourDB()
|
||||
colors = wxPython.lib.colourdb.getColourList()
|
||||
|
||||
frame = DrawFrame(None, -1, "FloatCanvas Demo App",wxDefaultPosition,wxSize(700,700))
|
||||
|
||||
self.SetTopWindow(frame)
|
||||
|
||||
@ -427,9 +420,30 @@ else:
|
||||
return Lines
|
||||
else:
|
||||
return Shorelines
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
def runTest(frame, nb, log):
|
||||
"""
|
||||
This method is used by the wxPython Demo Framework for integrating
|
||||
this demo with the rest.
|
||||
"""
|
||||
global colors
|
||||
wxPython.lib.colourdb.updateColourDB()
|
||||
colors = wxPython.lib.colourdb.getColourList()
|
||||
|
||||
win = DrawFrame(None, -1, "FloatCanvas Drawing Window",wxDefaultPosition,wxSize(500,500))
|
||||
frame.otherWin = win
|
||||
win.Show(True)
|
||||
|
||||
|
||||
|
||||
|
||||
## for the wxPython demo:
|
||||
overview = floatcanvas.FloatCanvas.__doc__
|
||||
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if not haveNumeric:
|
||||
|
||||
@ -20,7 +20,7 @@ class TestPanel(wxPanel):
|
||||
b = wxButton(self, -1, "non-default")
|
||||
EVT_BUTTON(self, b.GetId(), self.OnButton)
|
||||
sizer.Add(b)
|
||||
sizer.Add(10,10)
|
||||
sizer.Add((10,10))
|
||||
|
||||
b = wxGenButton(self, -1, 'Hello')
|
||||
EVT_BUTTON(self, b.GetId(), self.OnButton)
|
||||
|
||||
@ -21,7 +21,7 @@ class HugeTable(wxPyGridTableBase):
|
||||
self.even=wxGridCellAttr()
|
||||
self.even.SetBackgroundColour("sea green")
|
||||
|
||||
def GetAttr(self, row, col, kind):
|
||||
def GetAttr(self, row, col, kind):
|
||||
attr = [self.even, self.odd][row % 2]
|
||||
attr.IncRef()
|
||||
return attr
|
||||
|
||||
@ -13,18 +13,18 @@ class MyCustomRenderer(wxPyGridCellRenderer):
|
||||
dc.SetBackgroundMode(wxSOLID)
|
||||
dc.SetBrush(wxBrush(wxBLACK, wxSOLID))
|
||||
dc.SetPen(wxTRANSPARENT_PEN)
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
|
||||
dc.DrawRectangleRect(rect)
|
||||
|
||||
dc.SetBackgroundMode(wxTRANSPARENT)
|
||||
dc.SetFont(attr.GetFont())
|
||||
|
||||
text = grid.GetCellValue(row, col)
|
||||
colors = [wxRED, wxWHITE, wxCYAN]
|
||||
colors = ["RED", "WHITE", "SKY BLUE"]
|
||||
x = rect.x + 1
|
||||
y = rect.y + 1
|
||||
for ch in text:
|
||||
dc.SetTextForeground(random.choice(colors))
|
||||
dc.DrawText(ch, x, y)
|
||||
dc.DrawText(ch, (x, y))
|
||||
w, h = dc.GetTextExtent(ch)
|
||||
x = x + w
|
||||
if x > rect.right - 5:
|
||||
@ -107,7 +107,7 @@ Renderers used together.
|
||||
|
||||
row = 2
|
||||
for label, value, renderClass, args in rendererDemoData:
|
||||
renderer = apply(renderClass, args)
|
||||
renderer = renderClass(*args)
|
||||
self.SetCellValue(row, renCol, label)
|
||||
self.SetCellValue(row, renCol+1, value)
|
||||
self.SetCellRenderer(row, renCol+1, renderer)
|
||||
@ -116,7 +116,7 @@ Renderers used together.
|
||||
|
||||
row = 2
|
||||
for label, value, editorClass, args in editorDemoData:
|
||||
editor = apply(editorClass, args)
|
||||
editor = editorClass(*args)
|
||||
self.SetCellValue(row, edCol, label)
|
||||
self.SetCellValue(row, edCol+1, value)
|
||||
self.SetCellEditor(row, edCol+1, editor)
|
||||
@ -127,8 +127,8 @@ Renderers used together.
|
||||
for label, value, renClass, edClass in comboDemoData:
|
||||
self.SetCellValue(row, renCol, label)
|
||||
self.SetCellValue(row, renCol+1, value)
|
||||
editor = apply(edClass, ()) #args)
|
||||
renderer = apply(renClass, ()) #args)
|
||||
editor = edClass()
|
||||
renderer = renClass()
|
||||
self.SetCellEditor(row, renCol+1, editor)
|
||||
self.SetCellRenderer(row, renCol+1, renderer)
|
||||
row = row + 2
|
||||
|
||||
@ -23,13 +23,6 @@ import images
|
||||
##print os.getpid(); raw_input("Press a key...")
|
||||
|
||||
|
||||
# Use Python's bool constants if available, make aliases if not
|
||||
try:
|
||||
True
|
||||
except NameError:
|
||||
__builtins__.True = 1==1
|
||||
__builtins__.False = 1==0
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
@ -32,7 +32,7 @@ class TestPanel(wxPanel):
|
||||
box.Add(t, 0, wxCENTER|wxALL, 5)
|
||||
|
||||
box.Add(wxStaticLine(self, -1), 0, wxEXPAND)
|
||||
box.Add(10,20)
|
||||
box.Add((10,20))
|
||||
|
||||
t = wxStaticText(self, -1, text)
|
||||
t.SetFont(nf)
|
||||
|
||||
BIN
wxPython/demo/bmp_source/toblom01.png
Normal file
BIN
wxPython/demo/bmp_source/toblom01.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.0 KiB |
BIN
wxPython/demo/bmp_source/toblom02.png
Normal file
BIN
wxPython/demo/bmp_source/toblom02.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom03.png
Normal file
BIN
wxPython/demo/bmp_source/toblom03.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom04.png
Normal file
BIN
wxPython/demo/bmp_source/toblom04.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom05.png
Normal file
BIN
wxPython/demo/bmp_source/toblom05.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.2 KiB |
BIN
wxPython/demo/bmp_source/toblom06.png
Normal file
BIN
wxPython/demo/bmp_source/toblom06.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom07.png
Normal file
BIN
wxPython/demo/bmp_source/toblom07.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.2 KiB |
BIN
wxPython/demo/bmp_source/toblom08.png
Normal file
BIN
wxPython/demo/bmp_source/toblom08.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom09.png
Normal file
BIN
wxPython/demo/bmp_source/toblom09.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom10.png
Normal file
BIN
wxPython/demo/bmp_source/toblom10.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.0 KiB |
BIN
wxPython/demo/bmp_source/toblom11.png
Normal file
BIN
wxPython/demo/bmp_source/toblom11.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom12.png
Normal file
BIN
wxPython/demo/bmp_source/toblom12.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.0 KiB |
BIN
wxPython/demo/bmp_source/toblom13.png
Normal file
BIN
wxPython/demo/bmp_source/toblom13.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
BIN
wxPython/demo/bmp_source/toblom14.png
Normal file
BIN
wxPython/demo/bmp_source/toblom14.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.2 KiB |
BIN
wxPython/demo/bmp_source/toblom15.png
Normal file
BIN
wxPython/demo/bmp_source/toblom15.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
@ -64,6 +64,23 @@ command_lines = [
|
||||
"-a -u -n Tux bmp_source/Tux.png images.py",
|
||||
|
||||
|
||||
"-a -u -n Blom01 bmp_source/toblom01.png images.py",
|
||||
"-a -u -n Blom02 bmp_source/toblom02.png images.py",
|
||||
"-a -u -n Blom03 bmp_source/toblom03.png images.py",
|
||||
"-a -u -n Blom04 bmp_source/toblom04.png images.py",
|
||||
"-a -u -n Blom05 bmp_source/toblom05.png images.py",
|
||||
"-a -u -n Blom06 bmp_source/toblom06.png images.py",
|
||||
"-a -u -n Blom07 bmp_source/toblom07.png images.py",
|
||||
"-a -u -n Blom08 bmp_source/toblom08.png images.py",
|
||||
"-a -u -n Blom09 bmp_source/toblom09.png images.py",
|
||||
"-a -u -n Blom10 bmp_source/toblom10.png images.py",
|
||||
"-a -u -n Blom11 bmp_source/toblom11.png images.py",
|
||||
"-a -u -n Blom12 bmp_source/toblom12.png images.py",
|
||||
"-a -u -n Blom13 bmp_source/toblom13.png images.py",
|
||||
"-a -u -n Blom14 bmp_source/toblom14.png images.py",
|
||||
"-a -u -n Blom15 bmp_source/toblom15.png images.py",
|
||||
|
||||
|
||||
" -u -c bmp_source/001.png throbImages.py",
|
||||
"-a -u -c bmp_source/002.png throbImages.py",
|
||||
"-a -u -c bmp_source/003.png throbImages.py",
|
||||
|
||||
@ -5391,3 +5391,499 @@ def getTuxImage():
|
||||
stream = cStringIO.StringIO(getTuxData())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom01Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x014ID\
|
||||
ATx\x9c\xbd\x97\xdb\x12\xc3 \x08D\xa5\xd3\xff\xffe\xfa\x90\x12\xf1\x02\xb2h\
|
||||
\xc2S;\xa3\xeeY\x82\x8a\xc4\xcc\\\xc0 \xa2\xe6\x7fb\x89;>\xe9\x99*\x88h\x80\
|
||||
\x8a\xc67#&\x86\x89J\xd1\xe6\x05\x02\xc9\x08\x0cP\xc5Z\xf1K\xb8\x05\x89\xc0@\
|
||||
\x00\xda\xbd\x17HVR\x19\x98\xb9_\xc1X a\x80\xa8{\x01\xd4\xe2\x1e\x08E\xb6\
|
||||
\xa1Wx\x96\xb8\x8e\xd9\xf8k\x1d>\xb3\r-A\rm\xc5\x12\x00q_\xe7\\\xe3"\xe3\x8f\
|
||||
g\xa0\x87]A\xb8\x00R0D\xd9\xca\xdf\xc8@\xf6h\x15a\r\x92\x02\xe8\x17@\xef\x9b\
|
||||
\xe8\xf8P\r\x9c\x16\x97-\x18\x06x2n\x80\x9d+\x15\t\xed\xbe\x01(E\xb6\xcd\xf3\
|
||||
\x10:^\xfd\x04\xbd{\x13@N\xbf7\x921\x05\xd0\xe2\xf2{\x17f\xe6\xbe\x01`\xe6\
|
||||
\xe5\xf1\x99\x05\xb1\xc4K\x01\x1b\x92\xfev\xdbh\x86s\x00\xbd\xfb\x08\x88\xe7\
|
||||
\x1e\x06\xb0\xc4,\x90\x95\xb8\x0b \x8bZ\xae\xbd9\xc8\xa7\x99\x02\xd4B\xfc\
|
||||
\xf7mw\x1f\xe7\x8b_\x85L\ndM\xd2\x00\xc8\x02c\xbf\xdf\x82x\x81>\xd3\x8e\xd5@\
|
||||
\xf6}8t\xc5C\xdb\x9c\xd8\xf8\x08\x8c\xdb\x96#o\x81:\x07\x830\x01N\xdc\x8a\
|
||||
\x11\x88\x1f\x16\x83\xc4;y\xb9\x8f\xf2\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom01Bitmap():
|
||||
return wxBitmapFromImage(getBlom01Image())
|
||||
|
||||
def getBlom01Image():
|
||||
stream = cStringIO.StringIO(getBlom01Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom02Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xe5IDATx\x9c\xadWY\x8e\xc30\x08\x85jn\x94\x9e)\x87\xeaW#Mo\x939\x13\xf3\xd1\
|
||||
`\x03~xQ\x8b\x84\x94`\x96\xc7b\xc7a\x11\x11\x9a$f\xa6\xa8\x8ed=y\xa4\xdblp""\
|
||||
\x11!f^\x0e2\x04\xc0\xcc\x85#er\xbb\x8ed#`jw#"\xa7\x8c2\xb4\x99\xeb33\x93\
|
||||
\xec[\n"K\xa4\xd8^1K\x0b4P\xcf\xa1\x95kp\xa4c\xfdX\xb0jc\x13\xfeANd\xdfJ\xb0\
|
||||
\x14\xcc\xe3/\x05W\xaae@\xaa~lM\x03@K\xdc\xcb\xd0\xea\xc6\xb5h\x97\x05.\xeb\
|
||||
\xd96\x8c\x99\xc7lR\x87\xd1n0\x8c\xcd6\xb4\xc3\xe6\xe4\xa1\xe4J\xc7\xf1\x9a\
|
||||
\x1aB\xeb\xdfr\xde\x820\xfd\x16\xc4\xca\xde\x1fU\xa4\xdb\x02;\xcd\xe8yd7Cp\
|
||||
\x17Xg\x11\xb5\xad\x10\xd2\x1d\xc9\xa2\xbf\xf4(F\x01\x8e\xe3\xe5\xde\xfd\xc1\
|
||||
B\x85\xed\xe9\x19\xc1\xc7\xb6\xd2\xd5\x82\x86\x95\xe0\xda~\x8a\xec\xe7\xa5w\
|
||||
\xaa_\xc7\xd6\x07"]\x87Z\x1eH\x1b\xa0\xb7\xa62\x04\x1c\x81j$\xd51\xce\xacf7\
|
||||
\xe6Z\xb1-\xadHg\x08\xef\xf9RJgc\'\xb1\xe7\x81XD$\x9fV\xec\x94Y\xd7\x12\xa7~\
|
||||
\xc6.\x19>\xe0\xca\xe7X\xb9\x06Vj+\xf1\x9et\x1f\xc8\xd2\xf3\xf9\x0bl\xea\x0e\
|
||||
hv\x01\x1a@;Pyo\xcf|\xd8:}\xb7\x94\x9e\x03o\x90w\xf7\xae,\xfbY\x130\xcf\xce\
|
||||
\xfe\xfa`\x8d\xbe\x13e\x08Q\x8f\x90\xb1\x06D\x815\xa0\xf5\x81d\x0e\xa8\x0ea\
|
||||
\xaa\xd0\x01AD\xc4\x8f{\x03<\xf3\x03u\xb2\xde\x9098(\xf45\xf2,!\xdd\xee\xb7\
|
||||
\x00!\xb6w\xbb\x99\xcc\xa3\xcfX\xd1\xe1\x7f\x81\xbb\xfd&\x97\x92\x15\x8a\x80\
|
||||
\xd3\xfb@\t\x0eP[@+\x15@\xd4\xbd\x0fD\xe7\xf1\xc2\xa9\xb7\xe7O@L\xfd\x9a\xa5\
|
||||
;\xe4\x0b-Y\xfa7\x8c\xb4\xf2g\xf4\x15\x00(\xe3OAtg \x0b\xd6\x03\xb1:\x0f\xff\
|
||||
\x8bY\xee\x8f\\Ix\x17\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom02Bitmap():
|
||||
return wxBitmapFromImage(getBlom02Image())
|
||||
|
||||
def getBlom02Image():
|
||||
stream = cStringIO.StringIO(getBlom02Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom03Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xbcIDATx\x9c\xadW[n\xc40\x08\xc4Qn\x94\x9e\xc9=Ss\xa6\xee\x99\xe8\xcf\xe2\
|
||||
\x02\x19\x1e\x89v\xa4\xd5\xe6\x81a<`\xec\x0c"bf&\x8d1\x06\xf9g\x1d\xe8q\xfeZ\
|
||||
\xc0\xcc\xeb\xdd\x18\x8361@F(\x00z\x8e\xecP`=)!\xb1\xa1\x81\x11\t\xe4\x04\
|
||||
\xcd\xbe\x03\xf1\xbf/I\xe6qq\xa4\xe5\xba\x0b?\x01\xb9\xf6\xbe\x8c\x02DD<\x8f\
|
||||
\x8b\xd4H\xd2(\xdf:\x88\xfe\xd7\xea\x99\t23/vo\x15V\x90\xf3ua\xad\x0b("\x80\
|
||||
\x10\xd9l:\x80\x04\xd4j\xc8`T\x0fYA\xea1\x19\xc1\xa1\xd7`\xa5\x04\x02R\xc3L\
|
||||
\xaaR\x87\x15\x88\xc8\xfcx\x1e\xecL\xa0m4>{\'\x18\xa4\x1a\x11\x924c\x1f\xa5@\
|
||||
+\xa8\xd5C\xbev_\xbd\x9dF\x93\x91\x84\x93P\xb5\xe4\xc7\x99\x1a\xd0@\xeb\xd6\
|
||||
\xe73\xcaoTK\xc6\xe6\xad\xcc\x85\x00b\x19:\t\x96\xe4\x1d\xecY\xd0j\x99uH\xb6\
|
||||
\x08d2\x86\x85\xf6\xfbS\x92l\x13@\x8e\xb2\xfc\x11\x11\x8d\xafoh\x97\xf5\x0c\
|
||||
\xa2d/0\xbd\xba\x08\x9e\xd9\xa0\xe7~/\x80\x04>\t!\x11\x05\r\t\xac\xbc\x9f\
|
||||
\xafR\xca\xa7\xf0\xa9\xded\xd30\xe7\x80y\x84\xdd\xac\x0c\xa0l\xa3M\xcc\x10\
|
||||
\xc8\xf2\xb3\xb6\xe3FM [\xf1\x9b.g}\x1e0L\xabU\xa0{|\xf3\x1ca\xfcK\xaf!p*F\
|
||||
\x03"\x82(=\xd1\xd6\x8c\xfc\xefQ\x95\x9a\xfd\xdc\xab1\xe7\xbf\x1d\x9d\x8b\
|
||||
\x88\xf7\x95\x9d\t\xe4\xbe\xb5\x0c\xcd,Up\xf8\x1e \xab\x83\xf0X\xee\xef\xefv\
|
||||
\xb8.\x89\xcd\x1b\xddq\x9a\xa1{\xb8)Sp\xa7=W\xc1\x10R\x02\xddO1\xb1}\x82\x94\
|
||||
@\xa7\x97k\xdb\x8f\x13\x80\n\x9c\'\xbc~\xaa@x&\xf4D*<U\xe0\x0f\x10\xc9\xceq\
|
||||
\x05\x93\xf4\xf9\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom03Bitmap():
|
||||
return wxBitmapFromImage(getBlom03Image())
|
||||
|
||||
def getBlom03Image():
|
||||
stream = cStringIO.StringIO(getBlom03Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom04Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xb0IDATx\x9c\xc5WQ\xb2\x830\x08\x84No\xa4g\xd23\xc53%g\xa2\x1f\x9a\x08\x11\
|
||||
\x12\xa2}}\xcc8\xd5\x12a\xc3\x12@$"\x02\xa7 "\xe4\xe5\x88x\xd1sSY\xdf3\x8f#\
|
||||
\x00\xa4aM\xc7\xc1\x9c\xcf-\x17\xefQ\xc7\x96s\xfe\xff\xe9\xf8|\xd7\x02\xf1\
|
||||
\xf2:\'\x82r)\xd1\xbf\x00\xe9\xad)\xb6[\x14\xf0p#\xda;w9B\x9d\n\x95\x02\x8d\
|
||||
\xe7\'\xce[\xa2R0\x98\x97\xdf\x07\x909\xff7\x00\xbf\x94\x0b\x80_\xee\x1e\x80\
|
||||
%a\xab\xc0<\x95\xd6\x91,\x11\xc8g\xfc/\x84\x17$\x15\xc0\xae @\xf4\x17\x90\
|
||||
\xbb T\x00D$\xaa\x9d\xbb\x8a\r\x02\xdem\xcb\x17\xde\xa7\x92\xba\x95\x8f\xd7x\
|
||||
D\x80\x18\x96C\xb3\xf9QT"*!o\xb5\xb2\x9b\xc9_D\x00\x8aA\x00\xbb\x9d?d\x08\
|
||||
\x00\x98\x17\xc5P\xd6P\x0c\x14\xc3B\x07\xfer\x95\xb5\x04BW\xbbl\xb6cI\x0b\
|
||||
\x01\xa4#\xd4\xd3"\xd6M\xd3d\xbc\xdf\xcf\x11\xb3\x12\xf2~\xe0\xe9\r1,\xc5Y\
|
||||
\xa6\x84Sc%\xac\xbb\x14\xf3\xec\xd5\xce\xf3\xbcn@1\\\x9c\xd7K\xeb\xcdt\x01p\
|
||||
\x1aT\xdd\xbc*`\xeb\x91Lw\x0e\xe0\x18\xc9\x10Qd\xbc\t4\x86\x02\xa6\xde\xb95\
|
||||
\x8c\xb8\x00\\\x00\xcd\xabi\x8cb\x80\x94\x12 n\x8c\x86v\xfet\x01\xb4(P\xc1\
|
||||
\x1d\xd1\xf28w\x01\xd0(\xc8Sn\xad\xf3PU\xcb\xad\x81d\xcfv\xe9\x1c\xe7u\x0f\
|
||||
\x7f\xc9\x03_i\xec~\x98x\x93\x90\x9f\x86\x91\x99\xd2w\x0c\x0f\xe3|\x87\xb5\
|
||||
\x9c\x8diL\\\x9ff\xbd(\xa4\x94\xf6Bt\xa3#=\x1aJ\xadh\x0c\x89\xd5\r\xbd\xdd\
|
||||
\x91b\x90\xcf\x832\xfcu\x0c\xa0\xf5\x82\xc8\xee\xe7!*>U\x97\xad\xea\x9c/\xc2\
|
||||
\xb9\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom04Bitmap():
|
||||
return wxBitmapFromImage(getBlom04Image())
|
||||
|
||||
def getBlom04Image():
|
||||
stream = cStringIO.StringIO(getBlom04Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom05Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02\
|
||||
\xd3IDATx\x9c\xddW1n\xe30\x10\x9c5\x92\xfa\xa2\x07\xa4\xa1\x9e \xf7j\xe4\'(\
|
||||
\xcd\x1d\x90T\xd2\x13\xf4\x06=A\xaa\x12\xe0\xae\x89\xbf\xa0F\xbd\xf9\x04\xf1\
|
||||
\x0bN\xea\x04\xd8+l\xd2$E\xda\x8e}@\x80\x1b@\xb0dR\xdc\xd9\xdd\xd9%E\xcc\xcc\
|
||||
\xf8F,\xbe\xd3\xf8\xffC\x80\x88\x90\xa6)\x88\xc8\xb9\xce\xc1\xcd\xbf0\x9eu\
|
||||
\x15\xb6\xed\x80\xac\xaa\x80\xcc\x1d\xd3\x88I\x8d\xae\x11\xa16nc\xdb\x0eH\
|
||||
\x9ab6W\xd6}\x90\xc8\xd5\x04l\xf8dB\xf0\x89\\\x9d\x02\xfex\x03n~\xe0\xe5\xe5\
|
||||
\x0f\x9e\x9e~\x9d$\xa2\xc7\x88\x08\xcc|\xb9\x08\x89\xc8\x18\x07\x80\xc7\xc7\
|
||||
\x9f`f<?\xff6^n\xdb\xe1\xf4:\x97\xa6@{\x10B\x9a\xa6PJ!\xeb*$k\x85m)\x82\xf3d\
|
||||
\xdd_\x16\x01"\x82\x10\x02}\xbf\xf3T)\xe5\x8cO\xd3d\xee\xfd1\x1f\x17\xa7@)\
|
||||
\x85\xb6m\x01\xec<~xx\x98\xcd\x91u\x1f\xac\x88d} u1\x01!\x04\x848\x84v\xbd^\
|
||||
\x1f\x9d\xaf\x8dn\xdb\xc1I\xc9L\x03~i1\xf3\xd1\xae\xc6\xccX\xadV\x18\x86\xc1\
|
||||
\xd1\x84~\xa7(\nc\xd0\xee\x11\xb2\xee\xc1\xccn\x19\xfa\xca\xb6\x17\xdat\x15\
|
||||
\xb2,\x83\x0f=n\xe7\xdd\xc6\xb6\x14\xb3\xe6\xa4\x8d\x03V\x1f\x08\x19\xd7\x1e\
|
||||
\xda\x86x\xd3\xb9\xe3\xfbgJS3\xd7\x17\x9eR\n\xd8\x97&\xea\x1eYW\x99*r\x1b\
|
||||
\x91g|\x1cG\x00@\x9e\xe7g\x11!"L\xd3\x84\xd5j\xe5x+\x84@\xd2\x14\xc16M\xcc\
|
||||
\xcc\xc7jZ\x13\xb9\xbf\xbfwD\x17\xd2\xc5\xa6\xab\xb0\xd4\x9e\xe2\xd0\xf5l\
|
||||
\xc3v_\x90u\x7f^+\xce\xf3\xdceM4\x8b@\x0c\xc9Z\x01Ma\x0c\xfbM\xe9\xcbex\xcax\
|
||||
Y\x96\xc1\xffc\xddpq*\xfc>\x8a\xa2\x00-\xeb\xe8xS$G\r\xdbM\x08\x00\x08@p;PJ\
|
||||
\x99\x9c\x9f\xa3\x81\xb2,\xf1\xba\xcf\xb3M\xd0\xde\x19\xfd\xfc;U`\x1b\x04v\
|
||||
\x9d\xce\xae\x02\x87u \rR\xca`d\xa4%J!\x04\x12\xb8\x111\x11\x18\xc7qf(\x84s\
|
||||
\x04\x18\x8b\x80MFG\xfd,\x11\xfa\x8d\xc56@\xcb\x1a\xb4\xac!\xa5\x0c\xbe\xebG\
|
||||
\xeb*\xd3\x88\x0e\x04>\xdf\x91\xe7yp\xeb\x1c\xc7\xd1\xa4F\x0b\x96\x99\r\t\
|
||||
\x1d\r\xbb\xfe\x83$$\x82;\xe3\x82\x99A\xb7w\xe6h\xed#\x96\x16\x9b\x84\xad\
|
||||
\x9d(2\xf7\x84\xa4\xa3\xb0\xd0\x8b\x19\xcfbg\xfa\xcf\xf7\xe8\xda\xd3kc\xeec%\
|
||||
\xaa\xcf\x06\xfe1m\xa6\x81 \x91\xcfw\xd0\xed\xddl?p\xde\x8b\x08\xb3i\x0e\xe4\
|
||||
d MQ\x11:D<\xe3\x93GB{\x1d\xf2\xbe,\xcb\xdd.\xbbG\xd2\x14\x80\xadW\xfe"\x00\
|
||||
\xf0d]\xf0~\xf5=\x00\xdel6\xcc\x1fo\xcc\x1fo\x9cu\x95\xf9?\xeb*\xf3|\xf5wA\
|
||||
\x0c\xb6\xd7t{\x07\x00\x87O7\t\xc8~\xd7\t\xff\x02\\\xbd\xe0\xa1\xd4\x84R\xed\
|
||||
\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom05Bitmap():
|
||||
return wxBitmapFromImage(getBlom05Image())
|
||||
|
||||
def getBlom05Image():
|
||||
stream = cStringIO.StringIO(getBlom05Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom06Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xd9IDATx\x9c\xbd\x97\xc1q\xc3 \x10E\xffz\x92{j@%\x90\x12hA-\x84\x12\xe4\x12\
|
||||
\xa4\x12H\x0bn\xc1%\xc4%\xc85\xe4\x9e\x039$\xab $`\x11\x9e\xfc\x93\xf0\x80\
|
||||
\xf6\xf1\x97]d\xf2\xde{\x08DD\xab\xb1pYQO\xd2\xe0q@\x06j\x059\x1d\t\x1e\x06\
|
||||
\x8e\x9dy8@I\xce\xb9&\x88,@j\xf7\x8f\x94\xd8\x81\xdc.[\\hJ\x81R\xaaey\x1e\
|
||||
\xa0Tv]\xd7a\x18\x86e\xcc.\xd4:\xb1[\x86D\x04\xff\xf6\xb1\x02\t\x01n\xb7\x1b\
|
||||
\xb4\xd6\x9bu\xce\xb9\xbf\xf5\xc2\xb3\x93\xed\x03\xf4\xfe\x8aa\x18\xa0\x94\
|
||||
\x02\x11A)\x05\xad5\x94R0\xc6\x88\x02\x94Dq\'$"8\xe7`\xad]vtD\xd6Z\x91\x0b\
|
||||
\xab3\xc0\xc1\xffS\x0b@\x18\xbcu\xf7\x87\x00J:\x9f\xcf\xa2y\xd34\x01\x90\xf7\
|
||||
\x86\x13 \xdb\xfd8\x8e\xc9\x97Xk\x97g\xad\xf5\x02!\xd1\xca\x81\xeb\xf5\xba\
|
||||
\x99\x10\xbe,\xe5\x02\x1f\xda\xbd\xdfK.\x14S\x106\x9b\x9c\x0b,.U\xa9\x0b\xcd\
|
||||
\xb7!\x8b]\xa8m\xcf+\x00c\x0c\xfa\xbe\xdf\xb5\xb3F!D)\r\'\xe0\xa7\xcd\xb6\
|
||||
\x06\xe5`\xecB\x98\x86\x1c\xc4&\x05R\x17\xac\xb5\xd99q*R\x10\xcb]\xe0\xbd_\
|
||||
\xca\x91\xfb\xfc^Ir\xd0\xbe\xef\xb3\x80\xa1\x0b\xe1AN\x02\x84\x10\x000\x03\
|
||||
\x18\x01t\xd1.9p\xee2J\xf5\x12v!\xbc#6)\xf0\xde\xc3{\x8f\xeew<W\x06\x0fe\x8c\
|
||||
)\x96d\xf2:\x0e\xdd\xe0gi\xe0\xbdtr*b\x17\xb2}\x80\xdd8"ie\x89\x1b\x91R\n\
|
||||
\xf7\xfb\xfd\x10D\x9c\x8a\xb0"\xc4\x00\xf3<\xe3r\xb9\x14\xe7\xc5\xe5\x96\x82\
|
||||
`\x89\xfe\x9a\xb1j\x1d\x08!\x18\x8aK\x92A\xab\xef\x02k\xed!\x10>O\xd34\xad\
|
||||
\xd6W9\x00\x00\xfe\xeb\x13\xf4\xfc\xd2\xf4\xc5\x14v\xc9j\x80V\xc5\xe5\xfd\r\
|
||||
\xb7\xe5\x03\xd9\xd7\xfa\xe5$\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom06Bitmap():
|
||||
return wxBitmapFromImage(getBlom06Image())
|
||||
|
||||
def getBlom06Image():
|
||||
stream = cStringIO.StringIO(getBlom06Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom07Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02\
|
||||
\xd4IDATx\x9c\x9dW\xbd\x99\xa30\x10}s\xdfU\xe0\x12\xc6%@\t\xa6\x046\xba`#T\
|
||||
\x82]\xc2\xba\x04\x886\xb8\xe8(\xc1\x94 \x95\x80K\xd8\x8d.\xd8h.`\x07K \x81|\
|
||||
\xef\xfb\xf4a$\xa1\xf7\xe6G#\x99DD\x90\x01"\x8a\xf6g~\x9e\xc4\xcf\\\xe2\xf7\
|
||||
\xf7\xdf\x00\x80\xaf\xaf\xbf\x00\x80\xfb\xfd\xbe\x12\xf6?b6\x05\x10\xd1L\x1c\
|
||||
\xc3\xf5z\xc58\x8e+\xb1\xcf\x88\xd9\xf5\x80B-W0s\xf0\xf4I\x89([LR\x80o\xfd\
|
||||
\x92\x1c\x00\x8c1\x10\x11\xdc\xefw\x1c\x8fG\x88\x08\xaa\xaa\xc2\xedv\x03\x00\
|
||||
\xb4m\x0b`\n\x15\x11%E\xfcHJ\xfbF\x8c|)d\x1cGTU5\x93.Q\xd7u2\x89\xb3C\xb0$\
|
||||
\x15\x91\xd92"\xc28\x8e`f\x10Q`\xfd\x1e6\x05\xbc\xbe\xfe\x020\xc5\xb9(\n\x9c\
|
||||
N\xa7`\\-\x1f\xc7\x11\xc6\x98\xd9\xfd\xcf\x80Ru\x80\x88\xd04v~\x1f\x86\x97\
|
||||
\x95E\xcc\xbc\xda\x05K\xeb\xf5\xd9\xf7}4\x0f\xa2\x1e\x88\xc5\xebt\xfa\x13\
|
||||
\xb5\xe0x<\x06\xc2\x8c1`f\xd4u\x9d\x15\x82\xa8\x07\x96\x02\x989) \x85\x98\
|
||||
\xc7b\x1e\x08\x04\xf8U\xcf\xcf\xfea\x18\xe0\x9c\x8b\x86\xe0\x19a]W\xaeD\x90\
|
||||
\x88H\xaa\xdc\xee\xe1Ya]W\x02\x08=A\x00\xc4\'6\xc6$\tS\xfb<WX]\xd7\xabd\x0c<\
|
||||
\xa0\x10\xbb&r\xce\xa14\xdd.\xf9\xf9|\x0e\xdec\x89\xd8\xf7\xfd\xc4#\xb2NB"\
|
||||
\x8a\n\x88AE\xf9+\xc4\n^]\xd7I\x11\x90\x05\x00\xccMl\x1b\xfd\x9d\x9ac\xdbFl\
|
||||
\xdb\x88\x08\x82\x16\xfdN\xfb\x97\xe4\xd6Z\x11\x11\xb1\xd6\xce\x04J\xa2c\n\
|
||||
\x9d\x13[\\[L\x90/l\xb5\r\x83\x04\xf1\xc2A\xa5\x89\xef\xe3\xc4!c\xdb\x06\x00\
|
||||
P4\xf1\xbc!\x9a\x94\xee\x1eF\xce\xb9\xbd)\xd1\x9c\x99\x04\'\xd6\xec\x1a\x00\
|
||||
\x93\xb0\xd5q\xac\x84\xfa\xbc\x0e\x9f\xb8\x0e\x9f\xd9brP4S\xe2\x12Q\xdc\x03\
|
||||
\xce9\x94e\t\xdb6(\x8ab\xea<\x9f@e\tk\xed\xdc\x97\x12\xf4r\x1d \xb6\x05Q\xda\
|
||||
\x0b\x8a\xe86\x04\x10\x92\xfb\xe3eX\xa8\x92\xee\xb7\xedf\x18&\xae\xc8i\xa8\
|
||||
\x17\x8c\x14\xb6j\x84\x12\xe7\xd6\x11 q%\x13\x91\xa0\xea9\xe7p\xa8.\xbb9\xa0\
|
||||
V;\xe7v\x93Pw\xc1\xee\x9d\x10\x00\x8a\xa2\xc0\xc7\xed\r\xd5\xa5\xcf\x99>W\
|
||||
\xc7)\xdb\xd7\xc4\xd3\xf8\xa4.)\x80\x99g\x8b\x0f\xd5\x05\x87\xea\xb2K\xacV\
|
||||
\xfb5\xc0u\xcd,D\xb3_w\x00\xb0q%\x03\x1e\x85\xc897[\xffq{\xdb\x15\xa0\xd6*i\
|
||||
\xec]C\x90% \x17\xbaC\xfc\x15\x97\xc4\x8f\xb53+\xe1\x16\xfc#\x9a\x99\x83\x7f\
|
||||
F*$U\x8a\x15\x9bI\xe8\xe7\x81OJ\xa5\x01\x95f*8\xdf\'\x8b\x7f;\xd6>"\x04M\xbd\
|
||||
\xa1\xd6\xeb\xe4M0sp\xd21\xf3\xde\'I`>-\x1f\xf8\x07\xa7)\xd6+b\xb9[\xb9\x00\
|
||||
\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom07Bitmap():
|
||||
return wxBitmapFromImage(getBlom07Image())
|
||||
|
||||
def getBlom07Image():
|
||||
stream = cStringIO.StringIO(getBlom07Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom08Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xb6IDATx\x9c\xadW\xed\xb1\x84 \x0cL\xde\\Gg\x0b\xd7\xcaY\x13\xb6b\x0bXS\xde\
|
||||
\x0f%\x86\x10!\xf1\xdc\x19\xe7\x14\x98\xec\x92/8$"\x02\'\x10q\xb8&`\x0e\x00\
|
||||
\x00^\x11b\x8fmD\x0c\x89\xe8\n\x88\x10\x17\x10\xc5D\\\n\xd8\x8d\xf8\x89-\x11\
|
||||
\xf5\x98m\xcc\x14\xf0\x0b\xb9\x16R\xdbl\x8d\xa2L\xc2;.\x8f\x00\xb1\xf5\xc4\
|
||||
\xebi\xe2\x9d\xc4\xbf\xfe\xf5\x94\xbbK\xc8\xa3\xb6\xfe\x9e$\xbe\xb3\x91\x9f\
|
||||
\x05\xf8zCG\x00\x11U\x0b\x1c\xcd.\x04\x9d\x13\xba<\xb9\nd.xDD\xdc-\xc3\xa4+\
|
||||
\x81\xfb\xc0\xee\t\xe4X"\x02PN\x8d\xb1m\xdb\x0e\xa3K%\xa4\x97\xfd=\xb1U#\x92\
|
||||
"\xae\xf0~\xbf\xf7\xb59\xc1\xb6m\x97B\xdc\xe5H\x06\x00\x80\x9f\x9c\xbe\xe6;\
|
||||
\x00\x10\xe5\xc4\x0f\x8fQ\xff\xd1\x94M+\xd6-\x13\x119\x148\xcd\xcd\x1co\xe4\
|
||||
\xc2##\x0cOC+\x0f\x98\xf4\x08Y\x11w\x8e\xfb\x1b\x93\xeb>0\x82\x14\x89\xd3ld\
|
||||
\xfd1gT\xd7\xcf\x8dH#\xa7oC\x8e\xa8\x85\x9cJ\xba\x1e\x90.\xbe\x03\xcb\x032<\
|
||||
\xa6\x80\xb3\x14\x89s\xa0\xd4\xfe4/\xd5Z+GJ\x99J\x11Z\x90\x84\xe9\x01I.\x8dR\
|
||||
NM\xe6G1\xf4\xc0\xd0\x80\x834\xa7/ .\xae.\xf9H\x15hL\xf3R\xc5_\xef\xda<\x0b\
|
||||
\x9e\x86\x95p\xd6\x9d\xd0]\x868\xcd\x80\xd3\xcc\t\xd9[\x179U\xabKi39\xe8\x84\
|
||||
\x16yA}\x07\x08^\xcb\xa3`\xe2\xf5\x18\xf8\xf8/6\xaeFdyA\xeeV\x12G1\x0c\xc1%V\
|
||||
\xf1\xae\x89\xd5\\\xefo\xdae\x122\xf9a\x8c\x8d\xac\x06\xb9\xfc\x96\xef\xc7wo\
|
||||
#\xfd*X\xcf_Dl]]\xc8?j}\x00\xffO\xcbZ\'\x16\xb1\xfd\xc3\x00\x00\x00\x00IEND\
|
||||
\xaeB`\x82'
|
||||
|
||||
def getBlom08Bitmap():
|
||||
return wxBitmapFromImage(getBlom08Image())
|
||||
|
||||
def getBlom08Image():
|
||||
stream = cStringIO.StringIO(getBlom08Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom09Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02EID\
|
||||
ATx\x9c\xa5\x97\xcd\x99\x1b!\x0c\x86?\x9e\xc79\'\xdb\x82S\x02\x1cR\xc0\xd6\
|
||||
\xe0\x12\xa0\x83M\r.a(!5L\tC\x0bna}\xf7\x81\x1c\xc6\xc2B\xc3\xef\xeew\xf2x\
|
||||
\x18\xf4"\t\tT\x8c1bBJ\xa9\xc3\x7f\x93Sd:\xcd\x1a\xdf\x16[\x85\xfa\n\xc8\x10\
|
||||
\x00\x19\xd8\x16\x0bmw\x80\xe0}zOPJ\xa9i\x08\xd5\x0bAi\xd5\x04\xc1A\x8c\xf3(\
|
||||
\xa9\x07\xd4\x05 \x08\x12\x87\xa9\x81\xf0){\xe19\x00\xc8$\x8b1\xee\xae}\xdc\
|
||||
\x81\xd3\xcf,\x1c\x12D)\x93}\'\xe7-A\x9c\xe4 k\xb7\xc3\x87\x00\xa0~\xfcB|\
|
||||
\xdc\x11c\x841.\xb9|[l\x96\x0fdD\xae\xbc\xeb\x81\x92qR\x08\x1e!x\xc4\xc7\x1d\
|
||||
\xe6\xcf\x07\xb4~\xad\xde{\x93@\x80r\x08ZQ\x1e\x02 \x08\x00\x99q.\x02\x99\
|
||||
\xdd\x05\xc3u\xa0fXjv+N\x15\xa2\x9a\xbc7YR\xce@$\x00\xca\xf6V\x18\xc8\x18\
|
||||
\xb0{Dk\x8bu\xbd$\xe3\x94\x8c\xdbb\x87!\xaa\xdb\xb0\x04B\xc9H\xa21\xd2\x03\
|
||||
\x04\xe2B?\'\x0e!\x90\xdb\xa8\xf4\xbe\xf4\x8e\x8cj\xfb*\xd7\xa8T\xc7&\x80\
|
||||
\x04\xa9\xe9|>g\xcf\xb2Ghk\x87BQ\x05\xe0\xab\x94^Y`\x81\x1bp]/x\x7f\xffW\x04\
|
||||
\x19Us\x17,\x8b0\xfc|\xbe^\x7f\x03@2n\xed\x06\xe3\xcc!\x19G`\x9a\xcdH)\x95\
|
||||
\x8c\x92\x9cS\xc9\xfd\xb7\xdb-\x01\xc8D\xe4 \xadd\x1cj\xc7\\\x94\x84\x04\xe6\
|
||||
\xdc\xfe\xdb\xb9\xa7\x97\xf4>\x8e\xaf^\x96g\xaen!*u5nXz\xa8\x94\x8c-5\x01J\
|
||||
\xab\x07\x9eI\xf8\x84\xa8\x89\x1bn\xed\x86\xae\x07\xf8\nK\xfb\x9f\xe2O\xe3\
|
||||
\x8cSY\x8b\xfe\x96\x07d\xd1\xe1\xb1v\xf0\xe9\x99\xe7\x03\xa9tv,i\xe8H\x96\
|
||||
\x06s\x18\xd8\x04\xc1\x8d\xd7vD-\x11\xa7\xba!/H\x0e\x1e\xd6n\x99a\xa9\x91\
|
||||
\xaa8\xe5\x81\xf4\xd1`\xd7\x94\x85\xa9T\x0f\xbet\x1e\x18m\xdd\xa4Vs\xfa\x96\
|
||||
\x07\xbc7M\x08\xef\xcd\xa10\xc9\\\x98\xbe\x9a\xf1\xc9\x01`]/\xe9?\xad5\xde\
|
||||
\xde\xfef\xdf\x94\xee\x0e\xd9\x9c\xa3\x1e\xe0.\xaf\xad\xfc\xf3\xf3\x8a\x10\
|
||||
\x02\x80W\x9f\x00\xf2;\xc4\xe1\xd4<z3\xea\x19\x97\xf2\xde\x14\x0f7\xd3\xbb\
|
||||
\xa0v2\x1aUo}\xff\x01\x93\xa6\xb8)r27w\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom09Bitmap():
|
||||
return wxBitmapFromImage(getBlom09Image())
|
||||
|
||||
def getBlom09Image():
|
||||
stream = cStringIO.StringIO(getBlom09Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom10Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01_ID\
|
||||
ATx\x9c\xbd\x97A\x92\xc5 \x08D\xe1\xd7\x1c\x893\x8dgJ\xce\xe4\x9d\x98\x15)\
|
||||
\xa3"\x1d\xcc\x9f^Z\x9a~(`dUU\x02\xc4\xcc\xc8\xb4A\xd1\xe7\x7f\xde0\xae\xb5\
|
||||
\x92\x88P\xad\xf56."\xd7z\x0f\x84\xbd\x1d\xc8F\xdc\xea8\x0e""*\xa5\xb8\x10S\
|
||||
\x80\xd6\xbc\x1e\xbf\x90\x99\x943\x84\x80\x002\xe6\x11D\xab\x1e\xe2\xf3\x969\
|
||||
\xba\xa6?\xda\xcflR\xc6\x1cYkI\xdaB\\\x00o$]$\x11\x19\xc6\xae\x1c0\x00$\xfa\
|
||||
\xf6\xac\xbd\xf9Q>X.\x84}`\xa6\xd6T\xca\x99:2f&U\x9d\xe7\xc0S\x18$\xfb=m\x03\
|
||||
\x18\x042\xf65\x80\x1d-\x01\xa4\x9c[\xdb\xbb\x05`\xc6;=\xe1\x11\x80\x95\x05R\
|
||||
b\xa8\x90\xf5\xd32DK\xeb\r\xd8\x1b\x80\xaa\xc2\x1dQ\xcay\xbbX\x98y\xe8\x0f-\
|
||||
\x98\x97K\xa9\xeb\xb87\x9f\xad\xeb\xcdg\xfdBU\xfdNh\x06\x16\x19Z\rO\x8fb\x00\
|
||||
\xb0\x16\xd9\x82x\xdb\x8bj\x06e\x1e\xff\xd6\x88<\xe8\xd4e\xb4k\xdc\xee0\x04\
|
||||
\xf0\xa4:\xa2\xef\xf4\x1a\x00\xcclUb6\x16\xcd\xb1\xe8Wo\x83\xe9\x0e\xf4\x11{\
|
||||
\xb7\x1d\xf2\x0f\x19=L\x96\xef\x82\x9dV\x8cDO\x94\xac\x82\xa8\x0cQs\xa2\x87U\
|
||||
\xf0\x8d\x1b\xd2=\x02\xa2\xdc1X\x9b\xee\x934\x05`\x10D\xfe\x9d\xd0\xab\xaf\
|
||||
\x8ct\x12z \xa8\xdaJZY\xfc\x01\x98\xc3\xfd\xb2]Q\xb3\x01\x00\x00\x00\x00IEND\
|
||||
\xaeB`\x82'
|
||||
|
||||
def getBlom10Bitmap():
|
||||
return wxBitmapFromImage(getBlom10Image())
|
||||
|
||||
def getBlom10Image():
|
||||
stream = cStringIO.StringIO(getBlom10Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom11Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xbcIDATx\x9c\xb5W\xdd\x99\x84 \x0c\x9c\xdcw\x9d\\\t\xd8\x82\xadhMP\x93\x96`\
|
||||
-\xb9\x87\x15\x16!\x81\xc0\xde\xcd\x8b+\x9bd\xc6\xfc\x80\x1233&@D\x8f\xfb\
|
||||
\xc90\xf8\xfa\x0brm\xcd\x82\xefY\xf2\xf2\x89\x89\x08D4\x9c\x89\xa1\x0ch\xe4\
|
||||
\xf9\xdah&\xcc\x02Z\xe4\x9f\x88\x18\xca\x80%\xbd\xffR\x82\x99\x06\xb3\xfa\
|
||||
\x983\x90?Y\x08\x01\xeb\xba\xa6\xfbu]\x11B\x10m{\xa0\xde> \xd5\xbe\\\xb3\xd8\
|
||||
h0e@\x0b\x12Go\xc4gH@\xaf\x8e|x\xf0\xe6\x9a6\xdd^\xe0\x06\xb4\xbf\x010\x1f\
|
||||
\x9eys\xe9\xda\xb4m`x+&"\xf0\xe1\x81\x10\x80m{]\x01\xf0\xe6\xa6\xa6ex\'|\x90\
|
||||
\x03\xef\xeb\xa4\x08U\x00\x11\xe18\x8e:`N\x1eQ\xde\xf7b\xf4\x04\xc4C\xc59\
|
||||
\x97\x02\x10\xd1\xab\xe1\x14\xb2\xb8\x1e\xb3@D\xf0\xde\x03@SD\xb7\x04\xce\
|
||||
\xb9\x14X%\x17DH1L\x02\xca#\xb5\xfb\xe4\r\x11\xfb\xbe\xa7ef\x16\xb3\xd0\xdd\
|
||||
\x07\x12y\xb6\xd5\x8e\x88X\x96\xa5iZ\t\xa8\x94\xde\xe4\x14N\xb3\x08Z\xf6*c\
|
||||
\xda\xcb\x8a\xf8F\xf4\x10qw=C\xe8~\t!\xbcG\xb5C\x0e\x8c\x1cF\x877\x91\'\xbfp\
|
||||
\xbe\xfc:g\x82\xe9\x9d\xb0,\x8b(&\x96\xe9\x86\xf7\xfe\xd1\x84\x1f\t\x88""\
|
||||
\xb4\x99\x8es?\x82\xa6\x80X\xbb\xb2\x86\xf9\xef\xf3<+?\xe7\x9c\xea[q\xb4z\
|
||||
\xe0\x91\xf6\x89\x0f\x0f\x8b\xbf\x9a\x01"\xc2\xd5\x08&}\x19\x95k\xd1\xff\xa7\
|
||||
!\xd2\xdc\x03\xd7\x1d\xe8\x12\xc4\xe5\x82\xa3\x8d\x15\xeaa\xd4\x12\xa1A"\x8f\
|
||||
\xf6Z\xcc\xa1O\xb3\x9c\xa0\x14r\t6\x16T\x02$\xa5?\xc2\xef\xb2\xa9,/"\xd2DTS \
|
||||
\x05\x1a\x9d\x80\x96\x982\xd6/0\xc8fA\x05!\x8cN\x00\x00\x00\x00IEND\xaeB`\
|
||||
\x82'
|
||||
|
||||
def getBlom11Bitmap():
|
||||
return wxBitmapFromImage(getBlom11Image())
|
||||
|
||||
def getBlom11Image():
|
||||
stream = cStringIO.StringIO(getBlom11Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom12Data():
|
||||
return \
|
||||
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01CID\
|
||||
ATx\x9c\xc5\x97\xdd\x11\xc2@\x08\x84Y'\x9d\xa4\x85\xf4\x94\x9a\xd2\x93-\xa4\
|
||||
\x96\xf3\xc1!\x83\x08\x1c\xb9\x1f\xdd\xa7\x18O\xf6\x03\x8e\x8bA)\xa5\xd0\x1f\
|
||||
\xb5\x8c\n\x04\xc0\xbc_\xcb\xaf\x1b\xc03\xd6\xdf{ ]\x00\x00\xdc\xc0\x1a\xcc\
|
||||
\x03y\xcc0\xb7\x8c<\xb0&\x80\x9a\xf9\x1d\x88\xe6\n\xf4\x8a!n\x03d\xb3g\xd5\
|
||||
\xd6\xfe\xad\x02\xdd\x00\x00>z\xa9?gc\xfc\xa4\x02Q\x1b\x9a\xa7\xc0\xbanQ\xfa\
|
||||
\x92F\xe5y\xb8\xdf\xdd\x15\xac\x87\x91\x15P\x9b\x9a\xc1\xb6=,\xb7\x15\xf7\
|
||||
\xab\x02\x00Rf\x96\xca\xf3\xb8=\xa6\xc37!C4\x01\xf4d_\x83\xf0\xa0\xa6\x8d!C\
|
||||
\xc8\xf3\xc1J\xee\xda\x03\xa3\xb2\xd7\x10W\xfcm7\xd7\x0c\xfbG\xe4\x89\x8dur'\
|
||||
\x11\xad\x0c0#{V-\xee\x83\xcd\xbd\x12\xcd\xd0)\xae\xaf\x16\x8c\xaa\x80ND\xef\
|
||||
\x83S\xad_J)a\x0b\xb0\xed\xe9SP\x1bf~\xbf\x10\xbd\x9fV\xde\xa8p{\xac 2[\xcb8\
|
||||
\xd2*\x01\x18\x82\x88L\x10o\x9c\xa2\xaaY\xf7\xb8\xfc\xab\xbc\xef\xbd\x19e^4\
|
||||
\xa2\x03&c\x1e\x02d\x04\xe0\x9a\xe7\xa8E\xd2\x9c\xd7\x0f\x05\xe0\xe0Zr\xc7[\
|
||||
\xe6D\x13NB=f\xd2\xdc\xd2\x90\x87\x91\x95\xbdTT\xa5\xee\x16\xf4\xea\x05,8\
|
||||
\xab|C\x98\xe78\x00\x00\x00\x00IEND\xaeB`\x82"
|
||||
|
||||
def getBlom12Bitmap():
|
||||
return wxBitmapFromImage(getBlom12Image())
|
||||
|
||||
def getBlom12Image():
|
||||
stream = cStringIO.StringIO(getBlom12Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom13Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02&ID\
|
||||
ATx\x9c\xbdW\xdb\x91\xa30\x10l\xb9.\x92I\xc1\x0eA)@\x08\x10\x82\x1d\xc2\x12\
|
||||
\x82\x1c\x82IA\x1f\x04\xa0\r\x01R\x99\xfb\xd8\x93,\x81\x9e\xa6n\xbb\xcaUx\
|
||||
\xf4\x98\x9e\x1e\xcd\x08\xc0\x8d\x00\xc0\xcc\xccF\r\xee\x19@\xf0\xdc\x82?\
|
||||
\xa8\x84\x10\x02\x00`\xd4\x80\xef\xe7\x88\xdb\xf8\x84Q\x03\x84\x100jps\xac\
|
||||
\xed\x87K\x05\xaa\xa36\x8a\xa5\x94UQ\x19c\xaa\x95\x10\\A\xb5)\xa2\xc65\x97\
|
||||
\xff\xe1\x1c\x00\x98\xd9\xa5\xed\x14\x8130\xc6\x94I\x94ro\x8c\tlD\x94\xcc/\
|
||||
\x00&\xa2\x83-\xeb\xa3D\xc0\xc7\xba\xae\xae\xe4\xd6uu\xb6\xd4\x18s\xf9@6\x11\
|
||||
`\x0e\x15X\x96\x85\x89\x88\x97eq\xf3\xf7\n\xa4\xf6)\x12\xc8.\xfa\x17)\x11\
|
||||
\xb1\x1aT6-\xccy\x15\x92e(\x84\x801\x06\xd7\xeb\xf5`\x07\x005\xa8\xc3\x9a\
|
||||
\xf19&+&YM\xa9\x08\xa5\x94\xc1!\xb4Q\x1b5\xb86\xbc\xff\xf9\xed9\xa6@l,P\xc0o\
|
||||
\xb7\x16\xb7\xf1y\xb0\x95`\xd7\x00\x80\x94\x12\x00\xf0\xd5\x91\x1b\xf3\x95p\
|
||||
\x04\xfc\x9e\xeeo\xd4\xe28E&\xb6\xaf%q9\xeb\xdc\x8f\xb6\x16\xf6\xc2r\x04,\
|
||||
\xfaIG\x17\xa4\xec\xb5\xce\xf6\xeb\xfd\xff\x17?\xfam\xdb\x00\x1c\xa3\x7f\xdd\
|
||||
e\x15\x19\x7f\xcc\x7f\xb6\xfb\x02\xc0c\xde\xf0\xbaK\xa7\x82S\xa0Vr\x9fLn\xcc\
|
||||
\x7f\xf6U\xd0Z\xbb\xb4u]\xf7&@DE\xe7%\xe4\xa4\xb6*\xd8\xaa\x00\x80y\x9e\xdf\
|
||||
\x04r\x91\x95\x1c\xa5\xf6\x88\xed\xf9\xd5Q@\xa2\xfa:\xf6\x9d\x96\xc8\x96\x0e\
|
||||
\xad\xed\tI\x02\xb1t\xb4(\x14\x9b\xebG\xed\xe3\xc2\xcc\x87Z\xaeuf\x0fnM/\xf0\
|
||||
\xa3\x0e\x08Ty\x8a\xe01o\xaejb\xb5^\x82\xed\x86\x17\xe0\xe7\xfd\xed:\xa8\xa6\
|
||||
\xae\xb6\x8f(\xa5\x9a%\xf6\x98\xb7\xe8x\xf5wA+\x1e\xf3\x86m\xdb\x1c1\xad5n\
|
||||
\x1a.e\xf6.\x88\xbe\x0f\xc4\xee\x863\xd8\xdf\x80>\xb2g\xe0\x93\x8b\x06x\xcb\
|
||||
\xdeO:\xeb\x1cH(\x10LhP\xc3:~\xdd%\xfaI\xe3u\x97\xbfC\xc0:K\xd9?N\xc1\xa7\
|
||||
\xce\xf7J\xe4p\xfa\xcb\xc8w\xd2O: \xd4O\x1aD\x14\xbc\x80\xec\xf1\x17n\xe1\
|
||||
\xfd>\x10\xb5\x1e\x93\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom13Bitmap():
|
||||
return wxBitmapFromImage(getBlom13Image())
|
||||
|
||||
def getBlom13Image():
|
||||
stream = cStringIO.StringIO(getBlom13Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom14Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02\
|
||||
\x92IDATx\x9c\xad\x96\xdd\xb1\xa30\x0c\x85?\xdf\xd9\x06\xb6\x85\xb4\xe0-\xe0\
|
||||
>@\t\xdb\x82]\x02\xb5\xd8-\xdc\x12x!\x05\xb8\x84\xa4\x15\xed\x03\xd8\xf8\x8f\
|
||||
$d\xa3\x19F\x80\x01\x1d\x1d\x1dY o\x18 \x80\x88\xd1"\xc2\xb9\xc3\xe8\xfd}\
|
||||
\x11\xf9\xe2\x84)\xa5\xc0\xfeA\x04D\xf2\xfb\x80\xd5\xebE\xf4\xf5y4\x17\xb2\
|
||||
\xf7\xd5\x06\xe3\\\xfeY\x06\xbb\xef\x9eW\x0c\xe5\xef\xc4\xf5\xd3\x00\xc80\
|
||||
\xa7\x8f\xd0\x82r\x98\x02\x90\x18-\x1a\'\x80h\\Z\x7f\x83\x81\x12\x08 \xcb\
|
||||
\xb2\x88\x88\xc8\xb2,\xebGgR\xb0\xc8B\x04\x18\x83\xc7\xf5\x8f\x00\xa8\xef3W \
|
||||
\xa4\r\xfe_\x0c\x00r\xbb\xdd\xba\x00\x86aH\x00\xf2L\x8b\xcc\xb7\xf5\x04 o\
|
||||
\x8b3\xd9/\xcb"\xc30t\xd7#\x031\xd3:xb =\xec\xcc\xcb@\xe23\xc30\xa4\xfa\xd7\
|
||||
\xeb5\xdd=\x9f\x00hgv\x10\xf3.\x98#0G\xf5\xcf\xd7\x9f\x05\x8f\x0c|\x89\x08\
|
||||
\xc1z\xf4\xdd\x10.\xabg\x06\xedV\xaf\x94j\x8ei\x9a\xda\r\xaa2\x8f\xc6\x10\
|
||||
\x1ez\xd8RHe0%\x13\xda\x19\xd1\xc6\xec\xd7\xa6dh\x9a\xa6.\x13g\x18P""J\xa95\
|
||||
\xe3\x00hv&\x9e\\\x07\xeb\x11\x11\x94R\xc8\xb67\xdf\xefw\xc6q\xe4\xf7}*2\xb6\
|
||||
\xb3\x07@\x8f.\xdd\x0fX\xbe6\x16\x08\xd6\x97\x1f\xbf\xf8\xc7\xc1/>\xd1\x1d\
|
||||
\x83\x03Xk\x0f\x83\x03\x84\xd9\xa6\xfb\xa9\x04E\x19\\[\x86C\xdf\x11a\xdd\x82\
|
||||
E\xdfw\xf6\x87b\x1a\xe6B|\xc5\x03\\\xaf\xd7R\x8c\xf3z\x9e3p$P\x80r\x1c\x87\
|
||||
\x0c\xc4\xcf\x13\x10?k\x97|\x7f\x7f\xa7\xee\x88\xc1\xeb.p\xa3\xd9\x93\xcc4\
|
||||
\x00\xa0$+`\xfc\xc8Q\xcd\xf5\x8f!\xfcm5\xc1\x08\x0e\xb3\nk\xb6E\x90G\xde\xe2\
|
||||
i~H\x0e\x83\xdfMQ\xa6B\xa0Y\xc6/\x07\xdf\x84\xf9+\x0f\x1e[J;S\xa8_S\x81\xca\
|
||||
\x98\x88Zx%h\xaf+\xba\xbfd\xb5\xd0r\xdf0\x91\xd1\x9f\xfa{\xb6\xd8\xd9\x17-\
|
||||
\xd7\xec\x80G\x00D\x04\xc66\xd3"(}\xfac\xf0"\x99\x0e\x88\xdc\x8a\x12\xd4\xa5\
|
||||
\x08x\xb4~@\xbf\xf5h\\%\xac\xd6\x1e1\xf0t\xf6\x02\xddC\x1bs\xb8\xe7\xf76\x9d\
|
||||
f\x14o3\xa5h\xc33\xa6\x94jj\x7f\xd6\xa7Y\xf0\x8e\x89\x08\x16\x7f:(\xba\xd4\
|
||||
\xc2\xdb\x00\xa2\x9d\xcd<\x04_j\xe1\x99\x06^\xd1H^\xfbz\xde?\xbb\xfe\x08\x80\
|
||||
\xa3i\x97\xfdxv\x05K=\r\xdf1\xd9\xf6\r\xc6~Y\x004n\x9f\x15\x1c\xfc\x0f|\xc2\
|
||||
\xeaL\xebs@.\x97K*\xdbGJ\xf0*\x90:x,\xcf?\x91\x91\xf2\x9a\xc0\x8c\xb17\x00\
|
||||
\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom14Bitmap():
|
||||
return wxBitmapFromImage(getBlom14Image())
|
||||
|
||||
def getBlom14Image():
|
||||
stream = cStringIO.StringIO(getBlom14Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
def getBlom15Data():
|
||||
return \
|
||||
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
|
||||
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
|
||||
\xacIDATx\x9c\xbdW\xc1u\x04!\x08\x85\xbcT\x92\x16\xb4\xa6\xb1&\xb6&\xa7\x84\
|
||||
\xd4B\x0e\x1b6\xac\x03\x88\xbe\xddp\x1ba\xe0\x83_Adf\x86EA\xc4\xa7oq!\xeb+.?\
|
||||
w\x82\xf6\xdeM\x9d\xac#b\x1aD\n\x00"\x02\x11\x01\x00@)\x05j\xad\xa6\x9d\xac\
|
||||
\x13Q\xba\x1a8\xdb\x82\xb1\xdc;\x12\x85\xf8xw\xf0\x99\x9f\x10\xc0+\xc5\x03\
|
||||
\xe1\x02xU\xf63y[\x05\xb8\x13p\xa7\xa75+\xa9\xd4)\x10GX[\xda6+\xe9{`\xc7yF\
|
||||
\xcc-\xf8\xaf\xfd\x07HT@g}\x9e\'\xd4vK9\xeet@)ejg^D\xba\x02\x1a\x80\xc5\x81\
|
||||
\x88\x1f\x96n\x0c\xe7\x9e\x82\x0b\x83\x13\x04\x1c\xe5)\xb0\xc3\x9f%\x12\xce\
|
||||
\x82Xr\x9eg\xa8w\x01`mS\xd6\xeb}\x8e\x80p\'W\x1f\xf7\x82Iv\x9ad\x11X\xf1c5%\
|
||||
\x13@\xa6\x97w:R6\x02\xd2\xf3\x99\xbe\x8au\xc0\xb1\xf4\x92\xa1g\x13I8\x0f \
|
||||
\xe2\xb4\xb4\x124\n\x86\xb5\xb9\x15H\r$\x1e\x88\xc7\xdeN@n\x0f$c\xa0U}\xe6\
|
||||
\xee\x98\x02xL\xbc\xd11c\xbe\xe8#\xe6/\x01\x88\x9cH\xcf\x97\xab{\x04\x919MK\
|
||||
\x03\x89W\x05\xe1\xc0\xf7\xc4n\x1b\xc0},\x8f\xb3\xe1N\xf0\xa5\xc8H\xc4\xa9\
|
||||
\xb6\xbe<\x92\xed\x12r\x1b\x80\xceB\xaa\xb0\xc2\xfaY\x15\xc2n\x88\x88p\x1c\
|
||||
\x1dn\xb7\xebK(\xcat\xdc\xae\xe8\xa9\xe6w\xc3\x01ykw\x1e\x101\xb4\xf6\xfb\
|
||||
\xec\x1a\x86\x15\x1dXl\x8e\xa3C)\xc5}\xaa\x99\x00$\xf3R\x8a\xd9\xcf\xff\xb6\
|
||||
\x02\xc3V\xabE\x03\xd1 .\x1c\xb0\x18?~KvD\xfc\xc8\\lDg\xfd\'@tu\x7f\x00\xcfX\
|
||||
\xf1\x16(\xed\x1f\x94\x00\x00\x00\x00IEND\xaeB`\x82'
|
||||
|
||||
def getBlom15Bitmap():
|
||||
return wxBitmapFromImage(getBlom15Image())
|
||||
|
||||
def getBlom15Image():
|
||||
stream = cStringIO.StringIO(getBlom15Data())
|
||||
return wxImageFromStream(stream)
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@ class TestPanel(wxPanel):
|
||||
fgs.Add(btn)
|
||||
fgs.Add(self.sampleText, 0, wxADJUST_MINSIZE|wxGROW)
|
||||
|
||||
fgs.Add(15,15); fgs.Add(15,15) # an empty row
|
||||
fgs.Add((15,15)); fgs.Add((15,15)) # an empty row
|
||||
|
||||
fgs.Add(wxStaticText(self, -1, "PointSize:"))
|
||||
self.ps = wxStaticText(self, -1, "")
|
||||
@ -54,7 +54,7 @@ class TestPanel(wxPanel):
|
||||
self.face.SetFont(font)
|
||||
fgs.Add(self.face, 0, wxADJUST_MINSIZE)
|
||||
|
||||
fgs.Add(15,15); fgs.Add(15,15) # an empty row
|
||||
fgs.Add((15,15)); fgs.Add((15,15)) # an empty row
|
||||
|
||||
fgs.Add(wxStaticText(self, -1, "wxNativeFontInfo:"))
|
||||
self.nfi = wxStaticText(self, -1, "")
|
||||
|
||||
@ -18,9 +18,9 @@ class TestPanel(wxPanel):
|
||||
filter="All files (*.*)|*.*|Python files (*.py)|*.py")
|
||||
|
||||
sz = wxFlexGridSizer(cols=3, hgap=5, vgap=5)
|
||||
sz.Add(35, 35) # some space above
|
||||
sz.Add(35, 35)
|
||||
sz.Add(35, 35)
|
||||
sz.Add((35, 35)) # some space above
|
||||
sz.Add((35, 35))
|
||||
sz.Add((35, 35))
|
||||
|
||||
sz.Add(txt1)
|
||||
sz.Add(txt2)
|
||||
@ -30,7 +30,7 @@ class TestPanel(wxPanel):
|
||||
sz.Add(dir2, 0, wxEXPAND)
|
||||
sz.Add(dir3, 0, wxEXPAND)
|
||||
|
||||
sz.Add(35,35) # some space below
|
||||
sz.Add((35,35)) # some space below
|
||||
|
||||
sz.AddGrowableRow(2)
|
||||
sz.AddGrowableCol(0)
|
||||
|
||||
@ -21,7 +21,7 @@ class ButtonPanel(wxPanel):
|
||||
self.log = log
|
||||
|
||||
box = wxBoxSizer(wxVERTICAL)
|
||||
box.Add(20, 30)
|
||||
box.Add((20, 20))
|
||||
keys = buttonDefs.keys()
|
||||
keys.sort()
|
||||
for k in keys:
|
||||
|
||||
@ -199,7 +199,7 @@ class MegaImageRenderer(wxPyGridCellRenderer):
|
||||
else:
|
||||
dc.SetBrush(wxBrush(wxWHITE, wxSOLID))
|
||||
dc.SetPen(wxPen(wxWHITE, 1, wxSOLID))
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
|
||||
dc.DrawRectangleRect(rect)
|
||||
|
||||
# copy the image but only to the size of the grid cell
|
||||
width, height = bmp.GetWidth(), bmp.GetHeight()
|
||||
@ -209,9 +209,9 @@ class MegaImageRenderer(wxPyGridCellRenderer):
|
||||
if height > rect.height-2:
|
||||
height = rect.height-2
|
||||
|
||||
dc.Blit(rect.x+1, rect.y+1, width, height,
|
||||
dc.Blit((rect.x+1, rect.y+1), (width, height),
|
||||
image,
|
||||
0, 0, wxCOPY, True)
|
||||
(0, 0), wxCOPY, True)
|
||||
|
||||
|
||||
class MegaFontRenderer(wxPyGridCellRenderer):
|
||||
@ -243,7 +243,7 @@ class MegaFontRenderer(wxPyGridCellRenderer):
|
||||
else:
|
||||
dc.SetBrush(wxBrush(wxWHITE, wxSOLID))
|
||||
dc.SetPen(wxPen(wxWHITE, 1, wxSOLID))
|
||||
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
|
||||
dc.DrawRectangleRect(rect)
|
||||
|
||||
text = self.table.GetValue(row, col)
|
||||
dc.SetBackgroundMode(wxSOLID)
|
||||
@ -259,7 +259,7 @@ class MegaFontRenderer(wxPyGridCellRenderer):
|
||||
|
||||
dc.SetTextForeground(self.color)
|
||||
dc.SetFont(self.font)
|
||||
dc.DrawText(text, rect.x+1, rect.y+1)
|
||||
dc.DrawText(text, (rect.x+1, rect.y+1))
|
||||
|
||||
# Okay, now for the advanced class :)
|
||||
# Let's add three dots "..."
|
||||
@ -270,8 +270,8 @@ class MegaFontRenderer(wxPyGridCellRenderer):
|
||||
if width > rect.width-2:
|
||||
width, height = dc.GetTextExtent("...")
|
||||
x = rect.x+1 + rect.width-2 - width
|
||||
dc.DrawRectangle(x, rect.y+1, width+1, height)
|
||||
dc.DrawText("...", x, rect.y+1)
|
||||
dc.DrawRectangle((x, rect.y+1), (width+1, height))
|
||||
dc.DrawText("...", (x, rect.y+1))
|
||||
|
||||
dc.DestroyClippingRegion()
|
||||
|
||||
|
||||
@ -7,7 +7,22 @@ import wxListCtrl
|
||||
import wxScrolledWindow
|
||||
import images
|
||||
|
||||
import sys
|
||||
colourList = [ "Aquamarine", "Black", "Blue", "Blue Violet", "Brown", "Cadet Blue",
|
||||
"Coral", "Cornflower Blue", "Cyan", "Dark Grey", "Dark Green",
|
||||
"Dark Olive Green", "Dark Orchid", "Dark Slate Blue",
|
||||
"Dark Slate Grey", "Dark Turquoise", "Dim Grey", "Firebrick",
|
||||
"Forest Green", "Gold", "Goldenrod", "Grey", "Green", "Green Yellow",
|
||||
"Indian Red", "Khaki", "Light Blue", "Light Grey", "Light Steel Blue",
|
||||
"Lime Green", "Magenta", "Maroon", "Medium Aquamarine", "Medium Blue",
|
||||
"Medium Forest Green", "Medium Goldenrod", "Medium Orchid",
|
||||
"Medium Sea Green", "Medium Slate Blue", "Medium Spring Green",
|
||||
"Medium Turquoise", "Medium Violet Red", "Midnight Blue", "Navy",
|
||||
"Orange", "Orange Red", "Orchid", "Pale Green", "Pink", "Plum",
|
||||
"Purple", "Red", "Salmon", "Sea Green", "Sienna", "Sky Blue",
|
||||
"Slate Blue", "Spring Green", "Steel Blue", "Tan", "Thistle",
|
||||
"Turquoise", "Violet", "Violet Red", "Wheat", "White", "Yellow",
|
||||
"Yellow Green"
|
||||
]
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
@ -22,55 +37,34 @@ class TestLB(wxListbook):
|
||||
)
|
||||
self.log = log
|
||||
|
||||
win = self.makeColorPanel(wxBLUE)
|
||||
self.AddPage(win, "Blue")
|
||||
st = wxStaticText(win.win, -1,
|
||||
"You can put nearly any type of window here,\n"
|
||||
"and if the platform supports it then the\n"
|
||||
"tabs can be on any side of the notebook.",
|
||||
wxPoint(10, 10))
|
||||
st.SetForegroundColour(wxWHITE)
|
||||
st.SetBackgroundColour(wxBLUE)
|
||||
|
||||
# Show how to put an image on one of the notebook tabs,
|
||||
# first make the image list:
|
||||
il = wxImageList(16, 16)
|
||||
idx1 = il.Add(images.getSmilesBitmap())
|
||||
# make an image list using the BlomXX images
|
||||
il = wxImageList(32, 32)
|
||||
for x in range(1, 15):
|
||||
f = getattr(images, 'getBlom%02dBitmap' % x)
|
||||
bmp = f()
|
||||
il.Add(bmp)
|
||||
self.AssignImageList(il)
|
||||
|
||||
|
||||
# now put an image on the first tab we just created:
|
||||
self.SetPageImage(0, idx1)
|
||||
|
||||
|
||||
win = self.makeColorPanel(wxRED)
|
||||
self.AddPage(win, "Red")
|
||||
|
||||
win = wxScrolledWindow.MyCanvas(self)
|
||||
self.AddPage(win, 'ScrolledWindow')
|
||||
|
||||
win = self.makeColorPanel(wxGREEN)
|
||||
self.AddPage(win, "Green")
|
||||
|
||||
win = GridSimple.SimpleGrid(self, log)
|
||||
self.AddPage(win, "Grid")
|
||||
|
||||
win = wxListCtrl.TestListCtrlPanel(self, log)
|
||||
self.AddPage(win, 'List')
|
||||
|
||||
win = self.makeColorPanel(wxCYAN)
|
||||
self.AddPage(win, "Cyan")
|
||||
|
||||
## win = self.makeColorPanel(wxWHITE)
|
||||
## self.AddPage(win, "White")
|
||||
|
||||
## win = self.makeColorPanel(wxBLACK)
|
||||
## self.AddPage(win, "Black")
|
||||
|
||||
win = self.makeColorPanel(wxNamedColour('MIDNIGHT BLUE'))
|
||||
self.AddPage(win, "MIDNIGHT BLUE")
|
||||
|
||||
win = self.makeColorPanel(wxNamedColour('INDIAN RED'))
|
||||
self.AddPage(win, "INDIAN RED")
|
||||
# Now make a bunch of panels for the list book
|
||||
first = True
|
||||
imID = 0
|
||||
for colour in colourList:
|
||||
win = self.makeColorPanel(colour)
|
||||
self.AddPage(win, colour, imageId=imID)
|
||||
imID += 1
|
||||
if imID == il.GetImageCount(): imID = 0
|
||||
if first:
|
||||
st = wxStaticText(win.win, -1,
|
||||
"You can put nearly any type of window here,\n"
|
||||
"and the list can be on any side of the Listbook",
|
||||
wxPoint(10, 10))
|
||||
#st.SetForegroundColour(wxWHITE)
|
||||
#st.SetBackgroundColour(wxBLUE)
|
||||
first = False
|
||||
|
||||
|
||||
|
||||
EVT_LISTBOOK_PAGE_CHANGED(self, self.GetId(), self.OnPageChanged)
|
||||
EVT_LISTBOOK_PAGE_CHANGING(self, self.GetId(), self.OnPageChanging)
|
||||
|
||||
@ -208,17 +208,26 @@ check the source for this sample to see how to implement them.
|
||||
|
||||
|
||||
def TestInsert(self, evt):
|
||||
theID = 508
|
||||
# get the menu
|
||||
mb = self.GetMenuBar()
|
||||
menuItem = mb.FindItemById(507)
|
||||
menuItem = mb.FindItemById(theID)
|
||||
menu = menuItem.GetMenu()
|
||||
|
||||
# figure out the position to insert at
|
||||
pos = 0
|
||||
for i in menu.GetMenuItems():
|
||||
if i.GetId() == theID:
|
||||
break
|
||||
pos += 1
|
||||
|
||||
# now insert the new item
|
||||
ID = wxNewId()
|
||||
##menu.Insert(9, ID, "NewItem " + str(ID))
|
||||
##menu.Insert(pos, ID, "NewItem " + str(ID))
|
||||
item = wxMenuItem(menu)
|
||||
item.SetId(ID)
|
||||
item.SetText("NewItem " + str(ID))
|
||||
menu.InsertItem(9, item)
|
||||
menu.InsertItem(pos, item)
|
||||
|
||||
|
||||
|
||||
|
||||
@ -63,26 +63,26 @@ class TestValidatorPanel(wxPanel):
|
||||
|
||||
fgs = wxFlexGridSizer(0, 2)
|
||||
|
||||
fgs.Add(1,1);
|
||||
fgs.Add((1,1))
|
||||
fgs.Add(wxStaticText(self, -1, "These controls have validators that limit\n"
|
||||
"the type of characters that can be entered."))
|
||||
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
|
||||
label = wxStaticText(self, -1, "Alpha Only: ")
|
||||
fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
|
||||
|
||||
fgs.Add(wxTextCtrl(self, -1, "", validator = MyValidator(ALPHA_ONLY)))
|
||||
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
|
||||
label = wxStaticText(self, -1, "Digits Only: ")
|
||||
fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
|
||||
fgs.Add(wxTextCtrl(self, -1, "", validator = MyValidator(DIGIT_ONLY)))
|
||||
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add(0,0)
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
fgs.Add((0,0))
|
||||
b = wxButton(self, -1, "Test Dialog Validation")
|
||||
EVT_BUTTON(self, b.GetId(), self.OnDoDialog)
|
||||
fgs.Add(b)
|
||||
@ -166,20 +166,20 @@ class TestValidateDialog(wxDialog):
|
||||
|
||||
fgs = wxFlexGridSizer(0, 2)
|
||||
|
||||
fgs.Add(1,1);
|
||||
fgs.Add((1,1));
|
||||
fgs.Add(wxStaticText(self, -1,
|
||||
"These controls must have text entered into them. Each\n"
|
||||
"one has a validator that is checked when the Okay\n"
|
||||
"button is clicked."))
|
||||
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
|
||||
label = wxStaticText(self, -1, "First: ")
|
||||
fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
|
||||
|
||||
fgs.Add(wxTextCtrl(self, -1, "", validator = TextObjectValidator()))
|
||||
|
||||
fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
|
||||
fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
|
||||
|
||||
label = wxStaticText(self, -1, "Second: ")
|
||||
fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user