wxPython Merge #2 of 2.4 branch --> HEAD (branch tag: wxPy_2_4_merge_2)
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@21593 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
@@ -6,11 +6,11 @@ can do simple drawings upon.
|
||||
"""
|
||||
|
||||
|
||||
from wxPython.wx import *
|
||||
import wx # This module uses the new wx namespace
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DoodleWindow(wxWindow):
|
||||
class DoodleWindow(wx.Window):
|
||||
menuColours = { 100 : 'Black',
|
||||
101 : 'Yellow',
|
||||
102 : 'Red',
|
||||
@@ -32,7 +32,7 @@ class DoodleWindow(wxWindow):
|
||||
|
||||
|
||||
def __init__(self, parent, ID):
|
||||
wxWindow.__init__(self, parent, ID, style=wxNO_FULL_REPAINT_ON_RESIZE)
|
||||
wx.Window.__init__(self, parent, ID, style=wx.NO_FULL_REPAINT_ON_RESIZE)
|
||||
self.SetBackgroundColour("WHITE")
|
||||
self.listeners = []
|
||||
self.thickness = 1
|
||||
@@ -44,20 +44,20 @@ class DoodleWindow(wxWindow):
|
||||
self.InitBuffer()
|
||||
|
||||
# hook some mouse events
|
||||
EVT_LEFT_DOWN(self, self.OnLeftDown)
|
||||
EVT_LEFT_UP(self, self.OnLeftUp)
|
||||
EVT_RIGHT_UP(self, self.OnRightUp)
|
||||
EVT_MOTION(self, self.OnMotion)
|
||||
wx.EVT_LEFT_DOWN(self, self.OnLeftDown)
|
||||
wx.EVT_LEFT_UP(self, self.OnLeftUp)
|
||||
wx.EVT_RIGHT_UP(self, self.OnRightUp)
|
||||
wx.EVT_MOTION(self, self.OnMotion)
|
||||
|
||||
# the window resize event and idle events for managing the buffer
|
||||
EVT_SIZE(self, self.OnSize)
|
||||
EVT_IDLE(self, self.OnIdle)
|
||||
wx.EVT_SIZE(self, self.OnSize)
|
||||
wx.EVT_IDLE(self, self.OnIdle)
|
||||
|
||||
# and the refresh event
|
||||
EVT_PAINT(self, self.OnPaint)
|
||||
wx.EVT_PAINT(self, self.OnPaint)
|
||||
|
||||
# When the window is destroyed, clean up resources.
|
||||
EVT_WINDOW_DESTROY(self, self.Cleanup)
|
||||
wx.EVT_WINDOW_DESTROY(self, self.Cleanup)
|
||||
|
||||
|
||||
def Cleanup(self, evt):
|
||||
@@ -69,9 +69,9 @@ class DoodleWindow(wxWindow):
|
||||
def InitBuffer(self):
|
||||
"""Initialize the bitmap used for buffering the display."""
|
||||
size = self.GetClientSize()
|
||||
self.buffer = wxEmptyBitmap(size.width, size.height)
|
||||
dc = wxBufferedDC(None, self.buffer)
|
||||
dc.SetBackground(wxBrush(self.GetBackgroundColour()))
|
||||
self.buffer = wx.EmptyBitmap(size.width, size.height)
|
||||
dc = wx.BufferedDC(None, self.buffer)
|
||||
dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
|
||||
dc.Clear()
|
||||
self.DrawLines(dc)
|
||||
self.reInitBuffer = False
|
||||
@@ -80,14 +80,14 @@ class DoodleWindow(wxWindow):
|
||||
def SetColour(self, colour):
|
||||
"""Set a new colour and make a matching pen"""
|
||||
self.colour = colour
|
||||
self.pen = wxPen(wxNamedColour(self.colour), self.thickness, wxSOLID)
|
||||
self.pen = wx.Pen(self.colour, self.thickness, wx.SOLID)
|
||||
self.Notify()
|
||||
|
||||
|
||||
def SetThickness(self, num):
|
||||
"""Set a new line thickness and make a matching pen"""
|
||||
self.thickness = num
|
||||
self.pen = wxPen(wxNamedColour(self.colour), self.thickness, wxSOLID)
|
||||
self.pen = wx.Pen(self.colour, self.thickness, wx.SOLID)
|
||||
self.Notify()
|
||||
|
||||
|
||||
@@ -103,20 +103,20 @@ class DoodleWindow(wxWindow):
|
||||
|
||||
def MakeMenu(self):
|
||||
"""Make a menu that can be popped up later"""
|
||||
menu = wxMenu()
|
||||
menu = wx.Menu()
|
||||
keys = self.menuColours.keys()
|
||||
keys.sort()
|
||||
for k in keys:
|
||||
text = self.menuColours[k]
|
||||
menu.Append(k, text, kind=wxITEM_CHECK)
|
||||
EVT_MENU_RANGE(self, 100, 200, self.OnMenuSetColour)
|
||||
EVT_UPDATE_UI_RANGE(self, 100, 200, self.OnCheckMenuColours)
|
||||
menu.Append(k, text, kind=wx.ITEM_CHECK)
|
||||
wx.EVT_MENU_RANGE(self, 100, 200, self.OnMenuSetColour)
|
||||
wx.EVT_UPDATE_UI_RANGE(self, 100, 200, self.OnCheckMenuColours)
|
||||
menu.Break()
|
||||
|
||||
for x in range(1, self.maxThickness+1):
|
||||
menu.Append(x, str(x), kind=wxITEM_CHECK)
|
||||
EVT_MENU_RANGE(self, 1, self.maxThickness, self.OnMenuSetThickness)
|
||||
EVT_UPDATE_UI_RANGE(self, 1, self.maxThickness, self.OnCheckMenuThickness)
|
||||
menu.Append(x, str(x), kind=wx.ITEM_CHECK)
|
||||
wx.EVT_MENU_RANGE(self, 1, self.maxThickness, self.OnMenuSetThickness)
|
||||
wx.EVT_UPDATE_UI_RANGE(self, 1, self.maxThickness, self.OnCheckMenuThickness)
|
||||
self.menu = menu
|
||||
|
||||
|
||||
@@ -126,8 +126,11 @@ class DoodleWindow(wxWindow):
|
||||
text = self.menuColours[event.GetId()]
|
||||
if text == self.colour:
|
||||
event.Check(True)
|
||||
event.SetText(text.upper())
|
||||
else:
|
||||
event.Check(False)
|
||||
event.SetText(text)
|
||||
|
||||
def OnCheckMenuThickness(self, event):
|
||||
if event.GetId() == self.thickness:
|
||||
event.Check(True)
|
||||
@@ -164,7 +167,7 @@ class DoodleWindow(wxWindow):
|
||||
current one. Save the coordinants for redraws.
|
||||
"""
|
||||
if event.Dragging() and event.LeftIsDown():
|
||||
dc = wxBufferedDC(wxClientDC(self), self.buffer)
|
||||
dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
|
||||
dc.BeginDrawing()
|
||||
dc.SetPen(self.pen)
|
||||
pos = event.GetPositionTuple()
|
||||
@@ -200,10 +203,10 @@ class DoodleWindow(wxWindow):
|
||||
Called when the window is exposed.
|
||||
"""
|
||||
# Create a buffered paint DC. It will create the real
|
||||
# wxPaintDC and then blit the bitmap to it when dc is
|
||||
# wx.PaintDC and then blit the bitmap to it when dc is
|
||||
# deleted. Since we don't need to draw anything else
|
||||
# here that's all there is to it.
|
||||
dc = wxBufferedPaintDC(self, self.buffer)
|
||||
dc = wx.BufferedPaintDC(self, self.buffer)
|
||||
|
||||
|
||||
def DrawLines(self, dc):
|
||||
@@ -212,7 +215,7 @@ class DoodleWindow(wxWindow):
|
||||
"""
|
||||
dc.BeginDrawing()
|
||||
for colour, thickness, line in self.lines:
|
||||
pen = wxPen(wxNamedColour(colour), thickness, wxSOLID)
|
||||
pen = wx.Pen(colour, thickness, wx.SOLID)
|
||||
dc.SetPen(pen)
|
||||
for coords in line:
|
||||
apply(dc.DrawLine, coords)
|
||||
@@ -240,16 +243,16 @@ class DoodleWindow(wxWindow):
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DoodleFrame(wxFrame):
|
||||
class DoodleFrame(wx.Frame):
|
||||
def __init__(self, parent):
|
||||
wxFrame.__init__(self, parent, -1, "Doodle Frame", size=(800,600),
|
||||
style=wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE)
|
||||
wx.Frame.__init__(self, parent, -1, "Doodle Frame", size=(800,600),
|
||||
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
|
||||
doodle = DoodleWindow(self, -1)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
if __name__ == '__main__':
|
||||
app = wxPySimpleApp()
|
||||
app = wx.PySimpleApp()
|
||||
frame = DoodleFrame(None)
|
||||
frame.Show(True)
|
||||
app.MainLoop()
|
||||
|
@@ -4008,4 +4008,261 @@ I472
|
||||
I599
|
||||
I473
|
||||
tatp56
|
||||
a(S'Red'
|
||||
p57
|
||||
I4
|
||||
(lp58
|
||||
(I503
|
||||
I412
|
||||
I503
|
||||
I411
|
||||
ta(I503
|
||||
I411
|
||||
I504
|
||||
I411
|
||||
ta(I504
|
||||
I411
|
||||
I504
|
||||
I410
|
||||
ta(I504
|
||||
I410
|
||||
I505
|
||||
I410
|
||||
ta(I505
|
||||
I410
|
||||
I505
|
||||
I409
|
||||
ta(I505
|
||||
I409
|
||||
I506
|
||||
I409
|
||||
ta(I506
|
||||
I409
|
||||
I507
|
||||
I409
|
||||
ta(I507
|
||||
I409
|
||||
I507
|
||||
I408
|
||||
ta(I507
|
||||
I408
|
||||
I508
|
||||
I408
|
||||
ta(I508
|
||||
I408
|
||||
I509
|
||||
I408
|
||||
ta(I509
|
||||
I408
|
||||
I510
|
||||
I408
|
||||
ta(I510
|
||||
I408
|
||||
I511
|
||||
I408
|
||||
ta(I511
|
||||
I408
|
||||
I511
|
||||
I409
|
||||
ta(I511
|
||||
I409
|
||||
I511
|
||||
I410
|
||||
ta(I511
|
||||
I410
|
||||
I512
|
||||
I410
|
||||
ta(I512
|
||||
I410
|
||||
I512
|
||||
I411
|
||||
ta(I512
|
||||
I411
|
||||
I512
|
||||
I412
|
||||
ta(I512
|
||||
I412
|
||||
I512
|
||||
I413
|
||||
ta(I512
|
||||
I413
|
||||
I512
|
||||
I414
|
||||
ta(I512
|
||||
I414
|
||||
I512
|
||||
I415
|
||||
ta(I512
|
||||
I415
|
||||
I511
|
||||
I415
|
||||
ta(I511
|
||||
I415
|
||||
I511
|
||||
I416
|
||||
ta(I511
|
||||
I416
|
||||
I510
|
||||
I416
|
||||
ta(I510
|
||||
I416
|
||||
I510
|
||||
I417
|
||||
ta(I510
|
||||
I417
|
||||
I509
|
||||
I417
|
||||
ta(I509
|
||||
I417
|
||||
I508
|
||||
I418
|
||||
ta(I508
|
||||
I418
|
||||
I508
|
||||
I419
|
||||
ta(I508
|
||||
I419
|
||||
I507
|
||||
I420
|
||||
ta(I507
|
||||
I420
|
||||
I506
|
||||
I421
|
||||
ta(I506
|
||||
I421
|
||||
I505
|
||||
I421
|
||||
ta(I505
|
||||
I421
|
||||
I504
|
||||
I422
|
||||
ta(I504
|
||||
I422
|
||||
I503
|
||||
I423
|
||||
ta(I503
|
||||
I423
|
||||
I503
|
||||
I424
|
||||
ta(I503
|
||||
I424
|
||||
I502
|
||||
I425
|
||||
ta(I502
|
||||
I425
|
||||
I502
|
||||
I426
|
||||
tatp59
|
||||
a(g57
|
||||
I4
|
||||
(lp60
|
||||
(I503
|
||||
I414
|
||||
I502
|
||||
I414
|
||||
ta(I502
|
||||
I414
|
||||
I502
|
||||
I413
|
||||
ta(I502
|
||||
I413
|
||||
I501
|
||||
I413
|
||||
ta(I501
|
||||
I413
|
||||
I499
|
||||
I412
|
||||
ta(I499
|
||||
I412
|
||||
I498
|
||||
I412
|
||||
ta(I498
|
||||
I412
|
||||
I497
|
||||
I412
|
||||
ta(I497
|
||||
I412
|
||||
I496
|
||||
I412
|
||||
ta(I496
|
||||
I412
|
||||
I495
|
||||
I412
|
||||
ta(I495
|
||||
I412
|
||||
I494
|
||||
I412
|
||||
ta(I494
|
||||
I412
|
||||
I493
|
||||
I413
|
||||
ta(I493
|
||||
I413
|
||||
I493
|
||||
I414
|
||||
ta(I493
|
||||
I414
|
||||
I493
|
||||
I415
|
||||
ta(I493
|
||||
I415
|
||||
I493
|
||||
I416
|
||||
ta(I493
|
||||
I416
|
||||
I493
|
||||
I417
|
||||
ta(I493
|
||||
I417
|
||||
I493
|
||||
I418
|
||||
ta(I493
|
||||
I418
|
||||
I493
|
||||
I419
|
||||
ta(I493
|
||||
I419
|
||||
I493
|
||||
I420
|
||||
ta(I493
|
||||
I420
|
||||
I494
|
||||
I421
|
||||
ta(I494
|
||||
I421
|
||||
I495
|
||||
I422
|
||||
ta(I495
|
||||
I422
|
||||
I496
|
||||
I422
|
||||
ta(I496
|
||||
I422
|
||||
I497
|
||||
I423
|
||||
ta(I497
|
||||
I423
|
||||
I498
|
||||
I423
|
||||
ta(I498
|
||||
I423
|
||||
I498
|
||||
I424
|
||||
ta(I498
|
||||
I424
|
||||
I499
|
||||
I424
|
||||
ta(I499
|
||||
I424
|
||||
I500
|
||||
I424
|
||||
ta(I500
|
||||
I424
|
||||
I500
|
||||
I425
|
||||
ta(I500
|
||||
I425
|
||||
I501
|
||||
I425
|
||||
tatp61
|
||||
a.
|
@@ -7,10 +7,12 @@ intelligent Frame. This one has a menu and a statusbar, is able to
|
||||
save and reload doodles, clear the workspace, and has a simple control
|
||||
panel for setting color and line thickness in addition to the popup
|
||||
menu that DoodleWindow provides. There is also a nice About dialog
|
||||
implmented using an wxHtmlWindow.
|
||||
implmented using an wx.html.HtmlWindow.
|
||||
"""
|
||||
|
||||
from wxPython.wx import *
|
||||
import wx # This module uses the new wx namespace
|
||||
import wx.html
|
||||
from wx.lib import buttons # for generic button classes
|
||||
from doodle import DoodleWindow
|
||||
|
||||
import os, cPickle
|
||||
@@ -18,25 +20,28 @@ import os, cPickle
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
idNEW = 11001
|
||||
idOPEN = 11002
|
||||
idSAVE = 11003
|
||||
idSAVEAS = 11004
|
||||
idCLEAR = 11005
|
||||
idEXIT = 11006
|
||||
idABOUT = 11007
|
||||
wx.RegisterId(5000) # Give a high starting value for the IDs, just for kicks
|
||||
|
||||
idNEW = wx.NewId()
|
||||
idOPEN = wx.NewId()
|
||||
idSAVE = wx.NewId()
|
||||
idSAVEAS = wx.NewId()
|
||||
idCLEAR = wx.NewId()
|
||||
idEXIT = wx.NewId()
|
||||
idABOUT = wx.NewId()
|
||||
|
||||
|
||||
class DoodleFrame(wxFrame):
|
||||
|
||||
class DoodleFrame(wx.Frame):
|
||||
"""
|
||||
A DoodleFrame contains a DoodleWindow and a ControlPanel and manages
|
||||
their layout with a wxBoxSizer. A menu and associated event handlers
|
||||
their layout with a wx.BoxSizer. A menu and associated event handlers
|
||||
provides for saving a doodle to a file, etc.
|
||||
"""
|
||||
title = "Do a doodle"
|
||||
def __init__(self, parent):
|
||||
wxFrame.__init__(self, parent, -1, self.title, size=(800,600),
|
||||
style=wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE)
|
||||
wx.Frame.__init__(self, parent, -1, self.title, size=(800,600),
|
||||
style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
|
||||
self.CreateStatusBar()
|
||||
self.MakeMenu()
|
||||
self.filename = None
|
||||
@@ -47,9 +52,9 @@ class DoodleFrame(wxFrame):
|
||||
# Create a sizer to layout the two windows side-by-side.
|
||||
# Both will grow vertically, the doodle window will grow
|
||||
# horizontally as well.
|
||||
box = wxBoxSizer(wxHORIZONTAL)
|
||||
box.Add(cPanel, 0, wxEXPAND)
|
||||
box.Add(self.doodle, 1, wxEXPAND)
|
||||
box = wx.BoxSizer(wx.HORIZONTAL)
|
||||
box.Add(cPanel, 0, wx.EXPAND)
|
||||
box.Add(self.doodle, 1, wx.EXPAND)
|
||||
|
||||
# Tell the frame that it should layout itself in response to
|
||||
# size events.
|
||||
@@ -73,15 +78,19 @@ class DoodleFrame(wxFrame):
|
||||
f.close()
|
||||
self.doodle.SetLinesData(data)
|
||||
except cPickle.UnpicklingError:
|
||||
wxMessageBox("%s is not a doodle file." % self.filename,
|
||||
"oops!", style=wxOK|wxICON_EXCLAMATION)
|
||||
wx.MessageBox("%s is not a doodle file." % self.filename,
|
||||
"oops!", style=wx.OK|wx.ICON_EXCLAMATION)
|
||||
|
||||
|
||||
def MakeMenu(self):
|
||||
# create the file menu
|
||||
menu1 = wxMenu()
|
||||
menu1.Append(idOPEN, "&Open", "Open a doodle file")
|
||||
menu1.Append(idSAVE, "&Save", "Save the doodle")
|
||||
menu1 = wx.Menu()
|
||||
|
||||
# Using the "\tKeyName" syntax automatically creates a
|
||||
# wx.AcceleratorTable for this frame and binds the keys to
|
||||
# the menu items.
|
||||
menu1.Append(idOPEN, "&Open\tCtrl-O", "Open a doodle file")
|
||||
menu1.Append(idSAVE, "&Save\tCtrl-S", "Save the doodle")
|
||||
menu1.Append(idSAVEAS, "Save &As", "Save the doodle in a new file")
|
||||
menu1.AppendSeparator()
|
||||
menu1.Append(idCLEAR, "&Clear", "Clear the current doodle")
|
||||
@@ -89,30 +98,30 @@ class DoodleFrame(wxFrame):
|
||||
menu1.Append(idEXIT, "E&xit", "Terminate the application")
|
||||
|
||||
# and the help menu
|
||||
menu2 = wxMenu()
|
||||
menu2.Append(idABOUT, "&About", "Display the gratuitous 'about this app' thingamajig")
|
||||
menu2 = wx.Menu()
|
||||
menu2.Append(idABOUT, "&About\tCtrl-H", "Display the gratuitous 'about this app' thingamajig")
|
||||
|
||||
# and add them to a menubar
|
||||
menuBar = wxMenuBar()
|
||||
menuBar = wx.MenuBar()
|
||||
menuBar.Append(menu1, "&File")
|
||||
menuBar.Append(menu2, "&Help")
|
||||
self.SetMenuBar(menuBar)
|
||||
|
||||
EVT_MENU(self, idOPEN, self.OnMenuOpen)
|
||||
EVT_MENU(self, idSAVE, self.OnMenuSave)
|
||||
EVT_MENU(self, idSAVEAS, self.OnMenuSaveAs)
|
||||
EVT_MENU(self, idCLEAR, self.OnMenuClear)
|
||||
EVT_MENU(self, idEXIT, self.OnMenuExit)
|
||||
EVT_MENU(self, idABOUT, self.OnMenuAbout)
|
||||
wx.EVT_MENU(self, idOPEN, self.OnMenuOpen)
|
||||
wx.EVT_MENU(self, idSAVE, self.OnMenuSave)
|
||||
wx.EVT_MENU(self, idSAVEAS, self.OnMenuSaveAs)
|
||||
wx.EVT_MENU(self, idCLEAR, self.OnMenuClear)
|
||||
wx.EVT_MENU(self, idEXIT, self.OnMenuExit)
|
||||
wx.EVT_MENU(self, idABOUT, self.OnMenuAbout)
|
||||
|
||||
|
||||
|
||||
wildcard = "Doodle files (*.ddl)|*.ddl|All files (*.*)|*.*"
|
||||
|
||||
def OnMenuOpen(self, event):
|
||||
dlg = wxFileDialog(self, "Open doodle file...", os.getcwd(),
|
||||
style=wxOPEN, wildcard = self.wildcard)
|
||||
if dlg.ShowModal() == wxID_OK:
|
||||
dlg = wx.FileDialog(self, "Open doodle file...", os.getcwd(),
|
||||
style=wx.OPEN, wildcard = self.wildcard)
|
||||
if dlg.ShowModal() == wx.ID_OK:
|
||||
self.filename = dlg.GetPath()
|
||||
self.ReadFile()
|
||||
self.SetTitle(self.title + ' -- ' + self.filename)
|
||||
@@ -127,10 +136,10 @@ class DoodleFrame(wxFrame):
|
||||
|
||||
|
||||
def OnMenuSaveAs(self, event):
|
||||
dlg = wxFileDialog(self, "Save doodle as...", os.getcwd(),
|
||||
style=wxSAVE | wxOVERWRITE_PROMPT,
|
||||
dlg = wx.FileDialog(self, "Save doodle as...", os.getcwd(),
|
||||
style=wx.SAVE | wx.OVERWRITE_PROMPT,
|
||||
wildcard = self.wildcard)
|
||||
if dlg.ShowModal() == wxID_OK:
|
||||
if dlg.ShowModal() == wx.ID_OK:
|
||||
filename = dlg.GetPath()
|
||||
if not os.path.splitext(filename)[1]:
|
||||
filename = filename + '.ddl'
|
||||
@@ -159,7 +168,7 @@ class DoodleFrame(wxFrame):
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
class ControlPanel(wxPanel):
|
||||
class ControlPanel(wx.Panel):
|
||||
"""
|
||||
This class implements a very simple control panel for the DoodleWindow.
|
||||
It creates buttons for each of the colours and thickneses supported by
|
||||
@@ -167,36 +176,51 @@ class ControlPanel(wxPanel):
|
||||
also a little window that shows an example doodleLine in the selected
|
||||
values. Nested sizers are used for layout.
|
||||
"""
|
||||
|
||||
BMP_SIZE = 16
|
||||
BMP_BORDER = 3
|
||||
|
||||
def __init__(self, parent, ID, doodle):
|
||||
wxPanel.__init__(self, parent, ID, style=wxRAISED_BORDER)
|
||||
wx.Panel.__init__(self, parent, ID, style=wx.RAISED_BORDER)
|
||||
|
||||
numCols = 4
|
||||
spacing = 4
|
||||
|
||||
btnSize = wx.Size(self.BMP_SIZE + 2*self.BMP_BORDER,
|
||||
self.BMP_SIZE + 2*self.BMP_BORDER)
|
||||
|
||||
# Make a grid of buttons for each colour. Attach each button
|
||||
# event to self.OnSetColour. The button ID is the same as the
|
||||
# key in the colour dictionary.
|
||||
self.clrBtns = {}
|
||||
colours = doodle.menuColours
|
||||
keys = colours.keys()
|
||||
keys.sort()
|
||||
cGrid = wxGridSizer(cols=numCols, hgap=2, vgap=2)
|
||||
cGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
|
||||
for k in keys:
|
||||
bmp = self.MakeBitmap(wxNamedColour(colours[k]))
|
||||
b = wxBitmapButton(self, k, bmp)
|
||||
EVT_BUTTON(self, k, self.OnSetColour)
|
||||
bmp = self.MakeBitmap(colours[k])
|
||||
b = buttons.GenBitmapToggleButton(self, k, bmp, size=btnSize )
|
||||
b.SetBezelWidth(1)
|
||||
b.SetUseFocusIndicator(False)
|
||||
wx.EVT_BUTTON(self, k, self.OnSetColour)
|
||||
cGrid.Add(b, 0)
|
||||
self.clrBtns[colours[k]] = b
|
||||
self.clrBtns[colours[keys[0]]].SetToggle(True)
|
||||
|
||||
# Save the button size so we can use it for the number buttons
|
||||
btnSize = b.GetSize()
|
||||
|
||||
# Make a grid of buttons for the thicknesses. Attach each button
|
||||
# event to self.OnSetThickness. The button ID is the same as the
|
||||
# thickness value.
|
||||
tGrid = wxGridSizer(cols=numCols, hgap=2, vgap=2)
|
||||
self.thknsBtns = {}
|
||||
tGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
|
||||
for x in range(1, doodle.maxThickness+1):
|
||||
b = wxButton(self, x, str(x), size=btnSize)
|
||||
EVT_BUTTON(self, x, self.OnSetThickness)
|
||||
b = buttons.GenToggleButton(self, x, str(x), size=btnSize)
|
||||
b.SetBezelWidth(1)
|
||||
b.SetUseFocusIndicator(False)
|
||||
wx.EVT_BUTTON(self, x, self.OnSetThickness)
|
||||
tGrid.Add(b, 0)
|
||||
self.thknsBtns[x] = b
|
||||
self.thknsBtns[1].SetToggle(True)
|
||||
|
||||
# Make a colour indicator window, it is registerd as a listener
|
||||
# with the doodle window so it will be notified when the settings
|
||||
@@ -208,10 +232,10 @@ class ControlPanel(wxPanel):
|
||||
|
||||
# Make a box sizer and put the two grids and the indicator
|
||||
# window in it.
|
||||
box = wxBoxSizer(wxVERTICAL)
|
||||
box.Add(cGrid, 0, wxALL, spacing)
|
||||
box.Add(tGrid, 0, wxALL, spacing)
|
||||
box.Add(ci, 0, wxEXPAND|wxALL, spacing)
|
||||
box = wx.BoxSizer(wx.VERTICAL)
|
||||
box.Add(cGrid, 0, wx.ALL, spacing)
|
||||
box.Add(tGrid, 0, wx.ALL, spacing)
|
||||
box.Add(ci, 0, wx.EXPAND|wx.ALL, spacing)
|
||||
self.SetSizer(box)
|
||||
self.SetAutoLayout(True)
|
||||
|
||||
@@ -224,15 +248,15 @@ class ControlPanel(wxPanel):
|
||||
def MakeBitmap(self, colour):
|
||||
"""
|
||||
We can create a bitmap of whatever we want by simply selecting
|
||||
it into a wxMemoryDC and drawing on it. In this case we just set
|
||||
it into a wx.MemoryDC and drawing on it. In this case we just set
|
||||
a background brush and clear the dc.
|
||||
"""
|
||||
bmp = wxEmptyBitmap(16,16)
|
||||
dc = wxMemoryDC()
|
||||
bmp = wx.EmptyBitmap(self.BMP_SIZE, self.BMP_SIZE)
|
||||
dc = wx.MemoryDC()
|
||||
dc.SelectObject(bmp)
|
||||
dc.SetBackground(wxBrush(colour))
|
||||
dc.SetBackground(wx.Brush(colour))
|
||||
dc.Clear()
|
||||
dc.SelectObject(wxNullBitmap)
|
||||
dc.SelectObject(wx.NullBitmap)
|
||||
return bmp
|
||||
|
||||
|
||||
@@ -241,6 +265,10 @@ class ControlPanel(wxPanel):
|
||||
Use the event ID to get the colour, set that colour in the doodle.
|
||||
"""
|
||||
colour = self.doodle.menuColours[event.GetId()]
|
||||
if colour != self.doodle.colour:
|
||||
# untoggle the old colour button
|
||||
self.clrBtns[self.doodle.colour].SetToggle(False)
|
||||
# set the new colour
|
||||
self.doodle.SetColour(colour)
|
||||
|
||||
|
||||
@@ -248,22 +276,28 @@ class ControlPanel(wxPanel):
|
||||
"""
|
||||
Use the event ID to set the thickness in the doodle.
|
||||
"""
|
||||
self.doodle.SetThickness(event.GetId())
|
||||
thickness = event.GetId()
|
||||
if thickness != self.doodle.thickness:
|
||||
# untoggle the old thickness button
|
||||
self.thknsBtns[self.doodle.thickness].SetToggle(False)
|
||||
# set the new colour
|
||||
self.doodle.SetThickness(thickness)
|
||||
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class ColourIndicator(wxWindow):
|
||||
class ColourIndicator(wx.Window):
|
||||
"""
|
||||
An instance of this class is used on the ControlPanel to show
|
||||
a sample of what the current doodle line will look like.
|
||||
"""
|
||||
def __init__(self, parent):
|
||||
wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
|
||||
self.SetBackgroundColour(wxWHITE)
|
||||
self.SetSize(wxSize(-1, 45))
|
||||
wx.Window.__init__(self, parent, -1, style=wx.SUNKEN_BORDER)
|
||||
self.SetBackgroundColour(wx.WHITE)
|
||||
self.SetSize( (-1, 45) )
|
||||
self.colour = self.thickness = None
|
||||
EVT_PAINT(self, self.OnPaint)
|
||||
wx.EVT_PAINT(self, self.OnPaint)
|
||||
|
||||
|
||||
def Update(self, colour, thickness):
|
||||
@@ -281,10 +315,10 @@ class ColourIndicator(wxWindow):
|
||||
This method is called when all or part of the window needs to be
|
||||
redrawn.
|
||||
"""
|
||||
dc = wxPaintDC(self)
|
||||
dc = wx.PaintDC(self)
|
||||
if self.colour:
|
||||
sz = self.GetClientSize()
|
||||
pen = wxPen(wxNamedColour(self.colour), self.thickness)
|
||||
pen = wx.Pen(self.colour, self.thickness)
|
||||
dc.BeginDrawing()
|
||||
dc.SetPen(pen)
|
||||
dc.DrawLine(10, sz.height/2, sz.width-10, sz.height/2)
|
||||
@@ -293,7 +327,7 @@ class ColourIndicator(wxWindow):
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DoodleAbout(wxDialog):
|
||||
class DoodleAbout(wx.Dialog):
|
||||
""" An about box that uses an HTML window """
|
||||
|
||||
text = '''
|
||||
@@ -318,44 +352,43 @@ instructions: </p>
|
||||
|
||||
<p><b>SuperDoodle</b> and <b>wxPython</b> are brought to you by
|
||||
<b>Robin Dunn</b> and <b>Total Control Software</b>, Copyright
|
||||
© 1997-2001.</p>
|
||||
© 1997-2003.</p>
|
||||
</body>
|
||||
</html>
|
||||
'''
|
||||
|
||||
def __init__(self, parent):
|
||||
wxDialog.__init__(self, parent, -1, 'About SuperDoodle',
|
||||
size=wxSize(420, 380))
|
||||
from wxPython.html import wxHtmlWindow
|
||||
wx.Dialog.__init__(self, parent, -1, 'About SuperDoodle',
|
||||
size=(420, 380) )
|
||||
|
||||
html = wxHtmlWindow(self, -1)
|
||||
html = wx.html.HtmlWindow(self, -1)
|
||||
html.SetPage(self.text)
|
||||
button = wxButton(self, wxID_OK, "Okay")
|
||||
button = wx.Button(self, wx.ID_OK, "Okay")
|
||||
|
||||
# constraints for the html window
|
||||
lc = wxLayoutConstraints()
|
||||
lc.top.SameAs(self, wxTop, 5)
|
||||
lc.left.SameAs(self, wxLeft, 5)
|
||||
lc.bottom.SameAs(button, wxTop, 5)
|
||||
lc.right.SameAs(self, wxRight, 5)
|
||||
lc = wx.LayoutConstraints()
|
||||
lc.top.SameAs(self, wx.Top, 5)
|
||||
lc.left.SameAs(self, wx.Left, 5)
|
||||
lc.bottom.SameAs(button, wx.Top, 5)
|
||||
lc.right.SameAs(self, wx.Right, 5)
|
||||
html.SetConstraints(lc)
|
||||
|
||||
# constraints for the button
|
||||
lc = wxLayoutConstraints()
|
||||
lc.bottom.SameAs(self, wxBottom, 5)
|
||||
lc.centreX.SameAs(self, wxCentreX)
|
||||
lc = wx.LayoutConstraints()
|
||||
lc.bottom.SameAs(self, wx.Bottom, 5)
|
||||
lc.centreX.SameAs(self, wx.CentreX)
|
||||
lc.width.AsIs()
|
||||
lc.height.AsIs()
|
||||
button.SetConstraints(lc)
|
||||
|
||||
self.SetAutoLayout(True)
|
||||
self.Layout()
|
||||
self.CentreOnParent(wxBOTH)
|
||||
self.CentreOnParent(wx.BOTH)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class DoodleApp(wxApp):
|
||||
class DoodleApp(wx.App):
|
||||
def OnInit(self):
|
||||
frame = DoodleFrame(None)
|
||||
frame.Show(True)
|
||||
|
468
wxPython/samples/hangman/hangman.py
Normal file
468
wxPython/samples/hangman/hangman.py
Normal file
@@ -0,0 +1,468 @@
|
||||
"""Hangman.py, a simple wxPython game, inspired by the
|
||||
old bsd game by Ken Arnold.
|
||||
From the original man page:
|
||||
|
||||
In hangman, the computer picks a word from the on-line
|
||||
word list and you must try to guess it. The computer
|
||||
keeps track of which letters have been guessed and how
|
||||
many wrong guesses you have made on the screen in a
|
||||
graphic fashion.
|
||||
|
||||
That says it all, doesn't it?
|
||||
|
||||
Have fun with it,
|
||||
|
||||
Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)"""
|
||||
|
||||
import random,re
|
||||
from wxPython.wx import *
|
||||
|
||||
|
||||
|
||||
class WordFetcher:
|
||||
builtin_words = ' albatros banana electrometer eggshell'
|
||||
|
||||
def __init__(self, filename, min_length = 5):
|
||||
self.min_length = min_length
|
||||
print "Trying to open file %s" % (filename,)
|
||||
try:
|
||||
f = open(filename, "r")
|
||||
except:
|
||||
print "Couldn't open dictionary file %s, using builtins" % (filename,)
|
||||
self.words = self.builtin_words
|
||||
self.filename = None
|
||||
return
|
||||
self.words = f.read()
|
||||
self.filename = filename
|
||||
print "Got %d bytes." % (len(self.words),)
|
||||
|
||||
def SetMinLength(min_length):
|
||||
self.min_length = min_length
|
||||
|
||||
def Get(self):
|
||||
reg = re.compile('\s+([a-zA-Z]+)\s+')
|
||||
n = 50 # safety valve; maximum number of tries to find a suitable word
|
||||
while n:
|
||||
index = int(random.random()*len(self.words))
|
||||
m = reg.search(self.words[index:])
|
||||
if m and len(m.groups()[0]) >= self.min_length: break
|
||||
n = n - 1
|
||||
if n: return m.groups()[0].lower()
|
||||
return "error"
|
||||
|
||||
|
||||
|
||||
def stdprint(x):
|
||||
print x
|
||||
|
||||
|
||||
|
||||
class URLWordFetcher(WordFetcher):
|
||||
def __init__(self, url):
|
||||
self.OpenURL(url)
|
||||
WordFetcher.__init__(self, "hangman_dict.txt")
|
||||
|
||||
def logprint(self,x):
|
||||
print x
|
||||
|
||||
def RetrieveAsFile(self, host, path=''):
|
||||
from httplib import HTTP
|
||||
try:
|
||||
h = HTTP(host)
|
||||
except:
|
||||
self.logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
|
||||
return None
|
||||
h.putrequest('GET',path)
|
||||
h.putheader('Accept','text/html')
|
||||
h.putheader('Accept','text/plain')
|
||||
h.endheaders()
|
||||
errcode, errmsg, headers = h.getreply()
|
||||
if errcode != 200:
|
||||
self.logprint("HTTP error code %d: %s" % (errcode, errmsg))
|
||||
return None
|
||||
f = h.getfile()
|
||||
return f
|
||||
|
||||
def OpenURL(self,url):
|
||||
from htmllib import HTMLParser
|
||||
import formatter
|
||||
self.url = url
|
||||
m = re.match('http://([^/]+)(/\S*)\s*', url)
|
||||
if m:
|
||||
host = m.groups()[0]
|
||||
path = m.groups()[1]
|
||||
else:
|
||||
m = re.match('http://(\S+)\s*', url)
|
||||
if not m:
|
||||
# Invalid URL
|
||||
self.logprint("Invalid or unsupported URL: %s" % (url))
|
||||
return
|
||||
host = m.groups()[0]
|
||||
path = ''
|
||||
f = self.RetrieveAsFile(host,path)
|
||||
if not f:
|
||||
self.logprint("Could not open %s" % (url))
|
||||
return
|
||||
self.logprint("Receiving data...")
|
||||
data = f.read()
|
||||
tmp = open('hangman_dict.txt','w')
|
||||
fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
|
||||
p = HTMLParser(fmt)
|
||||
self.logprint("Parsing data...")
|
||||
p.feed(data)
|
||||
p.close()
|
||||
tmp.close()
|
||||
|
||||
|
||||
|
||||
class HangmanWnd(wxWindow):
|
||||
def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize):
|
||||
wxWindow.__init__(self, parent, id, pos, size)
|
||||
self.SetBackgroundColour(wxNamedColour('white'))
|
||||
if wxPlatform == '__WXGTK__':
|
||||
self.font = wxFont(12, wxMODERN, wxNORMAL, wxNORMAL)
|
||||
else:
|
||||
self.font = wxFont(10, wxMODERN, wxNORMAL, wxNORMAL)
|
||||
self.SetFocus()
|
||||
EVT_PAINT(self, self.OnPaint)
|
||||
|
||||
|
||||
def StartGame(self, word):
|
||||
self.word = word
|
||||
self.guess = []
|
||||
self.tries = 0
|
||||
self.misses = 0
|
||||
self.Draw()
|
||||
|
||||
def EndGame(self):
|
||||
self.misses = 7;
|
||||
self.guess = map(chr, range(ord('a'),ord('z')+1))
|
||||
self.Draw()
|
||||
|
||||
def HandleKey(self, key):
|
||||
self.message = ""
|
||||
if self.guess.count(key):
|
||||
self.message = 'Already guessed %s' % (key,)
|
||||
return 0
|
||||
self.guess.append(key)
|
||||
self.guess.sort()
|
||||
self.tries = self.tries+1
|
||||
if not key in self.word:
|
||||
self.misses = self.misses+1
|
||||
if self.misses == 7:
|
||||
self.EndGame()
|
||||
return 1
|
||||
has_won = 1
|
||||
for letter in self.word:
|
||||
if not self.guess.count(letter):
|
||||
has_won = 0
|
||||
break
|
||||
if has_won:
|
||||
self.Draw()
|
||||
return 2
|
||||
self.Draw()
|
||||
return 0
|
||||
|
||||
def Draw(self, dc = None):
|
||||
if not dc:
|
||||
dc = wxClientDC(self)
|
||||
dc.SetFont(self.font)
|
||||
dc.Clear()
|
||||
(x,y) = self.GetSizeTuple()
|
||||
x1 = x-200; y1 = 20
|
||||
for letter in self.word:
|
||||
if self.guess.count(letter):
|
||||
dc.DrawText(letter, x1, y1)
|
||||
else:
|
||||
dc.DrawText('.', x1, y1)
|
||||
x1 = x1 + 10
|
||||
x1 = x-200
|
||||
dc.DrawText("tries %d misses %d" % (self.tries,self.misses),x1,50)
|
||||
guesses = ""
|
||||
for letter in self.guess:
|
||||
guesses = guesses + letter
|
||||
dc.DrawText("guessed:", x1, 70)
|
||||
dc.DrawText(guesses[:13], x1+80, 70)
|
||||
dc.DrawText(guesses[13:], x1+80, 90)
|
||||
dc.SetUserScale(x/1000.0, y/1000.0)
|
||||
self.DrawVictim(dc)
|
||||
|
||||
def DrawVictim(self, dc):
|
||||
dc.SetPen(wxPen(wxNamedColour('black'), 20))
|
||||
dc.DrawLines([(10, 980), (10,900), (700,900), (700,940), (720,940),
|
||||
(720,980), (900,980)])
|
||||
dc.DrawLines([(100,900), (100, 100), (300,100)])
|
||||
dc.DrawLine(100,200,200,100)
|
||||
if ( self.misses == 0 ): return
|
||||
dc.SetPen(wxPen(wxNamedColour('blue'), 10))
|
||||
dc.DrawLine(300,100,300,200)
|
||||
if ( self.misses == 1 ): return
|
||||
dc.DrawEllipse(250,200,100,100)
|
||||
if ( self.misses == 2 ): return
|
||||
dc.DrawLine(300,300,300,600)
|
||||
if ( self.misses == 3) : return
|
||||
dc.DrawLine(300,300,250,550)
|
||||
if ( self.misses == 4) : return
|
||||
dc.DrawLine(300,300,350,550)
|
||||
if ( self.misses == 5) : return
|
||||
dc.DrawLine(300,600,350,850)
|
||||
if ( self.misses == 6) : return
|
||||
dc.DrawLine(300,600,250,850)
|
||||
|
||||
def OnPaint(self, event):
|
||||
dc = wxPaintDC(self)
|
||||
self.Draw(dc)
|
||||
|
||||
|
||||
|
||||
class HangmanDemo(HangmanWnd):
|
||||
def __init__(self, wf, parent, id, pos, size):
|
||||
HangmanWnd.__init__(self, parent, id, pos, size)
|
||||
self.StartGame("dummy")
|
||||
self.start_new = 1
|
||||
self.wf = wf
|
||||
self.delay = 500
|
||||
self.timer = self.PlayTimer(self.MakeMove)
|
||||
|
||||
def MakeMove(self):
|
||||
self.timer.Stop()
|
||||
if self.start_new:
|
||||
self.StartGame(self.wf.Get())
|
||||
self.start_new = 0
|
||||
self.left = list('aaaabcdeeeeefghiiiiijklmnnnoooopqrssssttttuuuuvwxyz')
|
||||
else:
|
||||
key = self.left[int(random.random()*len(self.left))]
|
||||
while self.left.count(key): self.left.remove(key)
|
||||
self.start_new = self.HandleKey(key)
|
||||
self.timer.Start(self.delay)
|
||||
|
||||
def Stop(self):
|
||||
self.timer.Stop()
|
||||
|
||||
class PlayTimer(wxTimer):
|
||||
def __init__(self,func):
|
||||
wxTimer.__init__(self)
|
||||
self.func = func
|
||||
self.Start(1000)
|
||||
|
||||
def Notify(self):
|
||||
apply(self.func, ())
|
||||
|
||||
|
||||
|
||||
class HangmanDemoFrame(wxFrame):
|
||||
def __init__(self, wf, parent, id, pos, size):
|
||||
wxFrame.__init__(self, parent, id, "Hangman demo", pos, size)
|
||||
self.demo = HangmanDemo(wf, self, -1, wxDefaultPosition, wxDefaultSize)
|
||||
EVT_CLOSE(self, self.OnCloseWindow)
|
||||
|
||||
def OnCloseWindow(self, event):
|
||||
self.demo.timer.Stop()
|
||||
self.Destroy()
|
||||
|
||||
|
||||
|
||||
class AboutBox(wxDialog):
|
||||
def __init__(self, parent,wf):
|
||||
wxDialog.__init__(self, parent, -1, "About Hangman", wxDefaultPosition, wxSize(350,450))
|
||||
self.wnd = HangmanDemo(wf, self, -1, wxPoint(1,1), wxSize(350,150))
|
||||
self.static = wxStaticText(self, -1, __doc__, wxPoint(1,160), wxSize(350, 250))
|
||||
self.button = wxButton(self, 2001, "OK", wxPoint(150,420), wxSize(50,-1))
|
||||
EVT_BUTTON(self, 2001, self.OnOK)
|
||||
|
||||
def OnOK(self, event):
|
||||
self.wnd.Stop()
|
||||
self.EndModal(wxID_OK)
|
||||
|
||||
|
||||
|
||||
class MyFrame(wxFrame):
|
||||
def __init__(self, parent, wf):
|
||||
self.wf = wf
|
||||
wxFrame.__init__(self, parent, -1, "hangman", wxDefaultPosition, wxSize(400,300))
|
||||
self.wnd = HangmanWnd(self, -1)
|
||||
menu = wxMenu()
|
||||
menu.Append(1001, "New")
|
||||
menu.Append(1002, "End")
|
||||
menu.AppendSeparator()
|
||||
menu.Append(1003, "Reset")
|
||||
menu.Append(1004, "Demo...")
|
||||
menu.AppendSeparator()
|
||||
menu.Append(1005, "Exit")
|
||||
menubar = wxMenuBar()
|
||||
menubar.Append(menu, "Game")
|
||||
menu = wxMenu()
|
||||
#menu.Append(1010, "Internal", "Use internal dictionary", True)
|
||||
menu.Append(1011, "ASCII File...")
|
||||
urls = [ 'wxPython home', 'http://wxPython.org/',
|
||||
'slashdot.org', 'http://slashdot.org/',
|
||||
'cnn.com', 'http://cnn.com',
|
||||
'The New York Times', 'http://www.nytimes.com',
|
||||
'De Volkskrant', 'http://www.volkskrant.nl/frameless/25000006.html',
|
||||
'Gnu GPL', 'http://www.fsf.org/copyleft/gpl.html',
|
||||
'Bijbel: Genesis', 'http://www.coas.com/bijbel/gn1.htm']
|
||||
urlmenu = wxMenu()
|
||||
for item in range(0,len(urls),2):
|
||||
urlmenu.Append(1020+item/2, urls[item], urls[item+1])
|
||||
urlmenu.Append(1080, 'Other...', 'Enter an URL')
|
||||
menu.AppendMenu(1012, 'URL', urlmenu, 'Use a webpage')
|
||||
menu.Append(1013, 'Dump', 'Write contents to stdout')
|
||||
menubar.Append(menu, "Dictionary")
|
||||
self.urls = urls
|
||||
self.urloffset = 1020
|
||||
menu = wxMenu()
|
||||
menu.Append(1090, "About...")
|
||||
menubar.Append(menu, "Help")
|
||||
self.SetMenuBar(menubar)
|
||||
self.CreateStatusBar(2)
|
||||
EVT_MENU(self, 1001, self.OnGameNew)
|
||||
EVT_MENU(self, 1002, self.OnGameEnd)
|
||||
EVT_MENU(self, 1003, self.OnGameReset)
|
||||
EVT_MENU(self, 1004, self.OnGameDemo)
|
||||
EVT_MENU(self, 1005, self.OnWindowClose)
|
||||
EVT_MENU(self, 1011, self.OnDictFile)
|
||||
EVT_MENU_RANGE(self, 1020, 1020+len(urls)/2, self.OnDictURL)
|
||||
EVT_MENU(self, 1080, self.OnDictURLSel)
|
||||
EVT_MENU(self, 1013, self.OnDictDump)
|
||||
EVT_MENU(self, 1090, self.OnHelpAbout)
|
||||
EVT_CHAR(self.wnd, self.OnChar)
|
||||
self.OnGameReset()
|
||||
|
||||
def OnGameNew(self, event):
|
||||
word = self.wf.Get()
|
||||
self.in_progress = 1
|
||||
self.SetStatusText("",0)
|
||||
self.wnd.StartGame(word)
|
||||
|
||||
def OnGameEnd(self, event):
|
||||
self.UpdateAverages(0)
|
||||
self.in_progress = 0
|
||||
self.SetStatusText("",0)
|
||||
self.wnd.EndGame()
|
||||
|
||||
def OnGameReset(self, event=None):
|
||||
self.played = 0
|
||||
self.won = 0
|
||||
self.history = []
|
||||
self.average = 0.0
|
||||
self.OnGameNew(None)
|
||||
|
||||
def OnGameDemo(self, event):
|
||||
frame = HangmanDemoFrame(self.wf, self, -1, wxDefaultPosition, self.GetSize())
|
||||
frame.Show(True)
|
||||
|
||||
def OnDictFile(self, event):
|
||||
fd = wxFileDialog(self)
|
||||
if (self.wf.filename):
|
||||
fd.SetFilename(self.wf.filename)
|
||||
if fd.ShowModal() == wxID_OK:
|
||||
file = fd.GetPath()
|
||||
self.wf = WordFetcher(file)
|
||||
|
||||
def OnDictURL(self, event):
|
||||
item = (event.GetId() - self.urloffset)*2
|
||||
print "Trying to open %s at %s" % (self.urls[item], self.urls[item+1])
|
||||
self.wf = URLWordFetcher(self.urls[item+1])
|
||||
|
||||
def OnDictURLSel(self, event):
|
||||
msg = wxTextEntryDialog(self, "Enter the URL of the dictionary document", "Enter URL")
|
||||
if msg.ShowModal() == wxID_OK:
|
||||
url = msg.GetValue()
|
||||
self.wf = URLWordFetcher(url)
|
||||
def OnDictDump(self, event):
|
||||
print self.wf.words
|
||||
|
||||
def OnHelpAbout(self, event):
|
||||
about = AboutBox(self, self.wf)
|
||||
about.ShowModal()
|
||||
about.wnd.Stop() # that damn timer won't stop!
|
||||
|
||||
def UpdateAverages(self, has_won):
|
||||
if has_won:
|
||||
self.won = self.won + 1
|
||||
self.played = self.played+1
|
||||
self.history.append(self.wnd.misses) # ugly
|
||||
total = 0.0
|
||||
for m in self.history:
|
||||
total = total + m
|
||||
self.average = float(total/len(self.history))
|
||||
|
||||
def OnChar(self, event):
|
||||
if not self.in_progress:
|
||||
#print "new"
|
||||
self.OnGameNew(None)
|
||||
return
|
||||
key = event.KeyCode();
|
||||
#print key
|
||||
if key >= ord('A') and key <= ord('Z'):
|
||||
key = key + ord('a') - ord('A')
|
||||
key = chr(key)
|
||||
if key < 'a' or key > 'z':
|
||||
event.Skip()
|
||||
return
|
||||
res = self.wnd.HandleKey(key)
|
||||
if res == 0:
|
||||
self.SetStatusText(self.wnd.message)
|
||||
elif res == 1:
|
||||
self.UpdateAverages(0)
|
||||
self.SetStatusText("Too bad, you're dead!",0)
|
||||
self.in_progress = 0
|
||||
elif res == 2:
|
||||
self.in_progress = 0
|
||||
self.UpdateAverages(1)
|
||||
self.SetStatusText("Congratulations!",0)
|
||||
if self.played:
|
||||
percent = (100.*self.won)/self.played
|
||||
else:
|
||||
percent = 0.0
|
||||
self.SetStatusText("p %d, w %d (%g %%), av %g" % (self.played,self.won, percent, self.average),1)
|
||||
|
||||
def OnWindowClose(self, event):
|
||||
self.Destroy()
|
||||
|
||||
|
||||
|
||||
class MyApp(wxApp):
|
||||
def OnInit(self):
|
||||
if wxPlatform == '__WXGTK__':
|
||||
defaultfile = "/usr/share/games/hangman-words"
|
||||
elif wxPlatform == '__WXMSW__':
|
||||
defaultfile = "c:\\windows\\hardware.txt"
|
||||
else:
|
||||
defaultfile = ""
|
||||
wf = WordFetcher(defaultfile)
|
||||
frame = MyFrame(None, wf)
|
||||
self.SetTopWindow(frame)
|
||||
frame.Show(True)
|
||||
return True
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app = MyApp(0)
|
||||
app.MainLoop()
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
overview = __doc__
|
||||
|
||||
|
||||
def runTest(frame, nb, log):
|
||||
if wxPlatform == '__WXGTK__' or wxPlatform == '__WXMOTIF__':
|
||||
defaultfile = "/usr/share/games/hangman-words"
|
||||
elif wxPlatform == '__WXMSW__':
|
||||
defaultfile = "c:\\windows\\hardware.txt"
|
||||
else:
|
||||
defaultfile = ""
|
||||
wf = WordFetcher(defaultfile)
|
||||
win = MyFrame(frame, wf)
|
||||
frame.otherWin = win
|
||||
win.Show(True)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
1
wxPython/samples/wx_examples/basic/__init__.py
Normal file
1
wxPython/samples/wx_examples/basic/__init__.py
Normal file
@@ -0,0 +1 @@
|
||||
# Python package.
|
27
wxPython/samples/wx_examples/basic/app.py
Executable file
27
wxPython/samples/wx_examples/basic/app.py
Executable file
@@ -0,0 +1,27 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
"""Basic application class."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import wx
|
||||
|
||||
from frame import Frame
|
||||
|
||||
class App(wx.App):
|
||||
"""Application class."""
|
||||
|
||||
def OnInit(self):
|
||||
self.frame = Frame()
|
||||
self.frame.Show()
|
||||
self.SetTopWindow(self.frame)
|
||||
return True
|
||||
|
||||
def main():
|
||||
app = App()
|
||||
app.MainLoop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
33
wxPython/samples/wx_examples/basic/frame.py
Executable file
33
wxPython/samples/wx_examples/basic/frame.py
Executable file
@@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
"""Basic frame class, with App for testing."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import wx
|
||||
|
||||
class Frame(wx.Frame):
|
||||
"""Frame class."""
|
||||
|
||||
def __init__(self, parent=None, id=-1, title='Title',
|
||||
pos=wx.DefaultPosition, size=(400, 200)):
|
||||
"""Create a Frame instance."""
|
||||
wx.Frame.__init__(self, parent, id, title, pos, size)
|
||||
|
||||
class App(wx.App):
|
||||
"""Application class."""
|
||||
|
||||
def OnInit(self):
|
||||
self.frame = Frame()
|
||||
self.frame.Show()
|
||||
self.SetTopWindow(self.frame)
|
||||
return True
|
||||
|
||||
def main():
|
||||
app = App()
|
||||
app.MainLoop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
1
wxPython/samples/wx_examples/hello/__init__.py
Normal file
1
wxPython/samples/wx_examples/hello/__init__.py
Normal file
@@ -0,0 +1 @@
|
||||
# Python package.
|
38
wxPython/samples/wx_examples/hello/hello.py
Executable file
38
wxPython/samples/wx_examples/hello/hello.py
Executable file
@@ -0,0 +1,38 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
"""Hello, wxPython! program."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import wx
|
||||
|
||||
class Frame(wx.Frame):
|
||||
"""Frame class that displays an image."""
|
||||
|
||||
def __init__(self, image, parent=None, id=-1,
|
||||
pos=wx.DefaultPosition, title='Hello, wxPython!'):
|
||||
"""Create a Frame instance and display image."""
|
||||
temp = image.ConvertToBitmap()
|
||||
size = temp.GetWidth(), temp.GetHeight()
|
||||
wx.Frame.__init__(self, parent, id, title, pos, size)
|
||||
self.bmp = wx.StaticBitmap(parent=self, id=-1, bitmap=temp)
|
||||
|
||||
class App(wx.App):
|
||||
"""Application class."""
|
||||
|
||||
def OnInit(self):
|
||||
wx.InitAllImageHandlers()
|
||||
image = wx.Image('wxPython.jpg', wx.BITMAP_TYPE_JPEG)
|
||||
self.frame = Frame(image)
|
||||
self.frame.Show()
|
||||
self.SetTopWindow(self.frame)
|
||||
return True
|
||||
|
||||
def main():
|
||||
app = App()
|
||||
app.MainLoop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
BIN
wxPython/samples/wx_examples/hello/wxPython.jpg
Normal file
BIN
wxPython/samples/wx_examples/hello/wxPython.jpg
Normal file
Binary file not shown.
After Width: | Height: | Size: 14 KiB |
Reference in New Issue
Block a user