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

Demo updates for new wx namespace, from Jeff Grimmett

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24723 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2003-12-09 01:23:28 +00:00
parent a61d40115f
commit 8fa876ca9e
147 changed files with 7313 additions and 5154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
wxPython/demo/wxDragImage.py
View File

@@ -1,32 +1,32 @@
# 11/15/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o Updated for wx namespace
#
from wxPython.wx import *
import images
import wx
import images
#----------------------------------------------------------------------
class DragShape:
def __init__(self, bmp):
self.bmp = bmp
self.pos = wxPoint(0,0)
self.pos = (0,0)
self.shown = True
self.text = None
self.fullscreen = False
def HitTest(self, pt):
rect = self.GetRect()
return rect.InsideXY(pt.x, pt.y)
def GetRect(self):
return wxRect(self.pos.x, self.pos.y,
return wx.Rect(self.pos[0], self.pos[1],
self.bmp.GetWidth(), self.bmp.GetHeight())
def Draw(self, dc, op = wxCOPY):
def Draw(self, dc, op = wx.COPY):
if self.bmp.Ok():
memDC = wxMemoryDC()
memDC = wx.MemoryDC()
memDC.SelectObject(self.bmp)
dc.Blit((self.pos.x, self.pos.y),
@@ -41,100 +41,111 @@ class DragShape:
#----------------------------------------------------------------------
class DragCanvas(wxScrolledWindow):
class DragCanvas(wx.ScrolledWindow):
def __init__(self, parent, ID):
wxScrolledWindow.__init__(self, parent, ID)
wx.ScrolledWindow.__init__(self, parent, ID)
self.shapes = []
self.dragImage = None
self.dragShape = None
self.hiliteShape = None
self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
self.bg_bmp = images.getBackgroundBitmap()
# Make a shape from an image and mask. This one will demo
# dragging outside the window
bmp = images.getTestStarBitmap()
shape = DragShape(bmp)
shape.pos = wxPoint(5, 5)
shape.pos = (5, 5)
shape.fullscreen = True
self.shapes.append(shape)
# Make a shape from some text
text = "Some Text"
bg_colour = wxColour(57, 115, 57) # matches the bg image
font = wxFont(15, wxROMAN, wxNORMAL, wxBOLD)
bg_colour = wx.Colour(57, 115, 57) # matches the bg image
font = wx.Font(15, wx.ROMAN, wx.NORMAL, wx.BOLD)
textExtent = self.GetFullTextExtent(text, font)
bmp = wxEmptyBitmap(textExtent[0], textExtent[1])
dc = wxMemoryDC()
# create a bitmap the same size as our text
bmp = wx.EmptyBitmap(textExtent[0], textExtent[1])
# 'draw' the text onto the bitmap
dc = wx.MemoryDC()
dc.SelectObject(bmp)
dc.SetBackground(wxBrush(bg_colour, wxSOLID))
dc.SetBackground(wx.Brush(bg_colour, wx.SOLID))
dc.Clear()
dc.SetTextForeground(wxRED)
dc.SetTextForeground(wx.RED)
dc.SetFont(font)
dc.DrawText(text, (0, 0))
dc.SelectObject(wxNullBitmap)
mask = wxMaskColour(bmp, bg_colour)
bmp.SetMask(mask)
shape = DragShape(bmp)
shape.pos = wxPoint(5, 100)
shape.pos = (5, 100)
shape.text = "Some dragging text"
self.shapes.append(shape)
# Make some shapes from some playing card images.
x = 200
for card in ['_01c_', '_12h_', '_13d_', '_10s_']:
bmpFunc = getattr(images, "get%sBitmap" % card)
bmp = bmpFunc()
shape = DragShape(bmp)
shape.pos = wxPoint(x, 5)
shape.pos = (x, 5)
self.shapes.append(shape)
x = x + 80
EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
EVT_PAINT(self, self.OnPaint)
EVT_LEFT_DOWN(self, self.OnLeftDown)
EVT_LEFT_UP(self, self.OnLeftUp)
EVT_MOTION(self, self.OnMotion)
EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.Bind(wx.EVT_MOTION, self.OnMotion)
self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
# We're not doing anything here, but you might have reason to.
# for example, if you were dragging something, you might elect to
# 'drop it' when the cursor left the window.
def OnLeaveWindow(self, evt):
pass
# tile the background bitmap
def TileBackground(self, dc):
# tile the background bitmap
sz = self.GetClientSize()
w = self.bg_bmp.GetWidth()
h = self.bg_bmp.GetHeight()
x = 0
while x < sz.width:
y = 0
while y < sz.height:
dc.DrawBitmap(self.bg_bmp, (x, y))
y = y + h
x = x + w
# Go through our list of shapes and draw them in whatever place they are.
def DrawShapes(self, dc):
for shape in self.shapes:
if shape.shown:
shape.Draw(dc)
# This is actually a sophisticated 'hit test', but in this
# case we're also determining which shape, if any, was 'hit'.
def FindShape(self, pt):
for shape in self.shapes:
if shape.HitTest(pt):
return shape
return None
# Remove a shape from the display
def EraseShape(self, shape, dc):
r = shape.GetRect()
dc.SetClippingRect(r)
@@ -142,55 +153,80 @@ class DragCanvas(wxScrolledWindow):
self.DrawShapes(dc)
dc.DestroyClippingRegion()
# Clears the background, then redraws it. If the DC is passed, then
# we only do so in the area so designated. Otherwise, it's the whole thing.
def OnEraseBackground(self, evt):
dc = evt.GetDC()
if not dc:
dc = wxClientDC(self)
rect = self.GetUpdateRegion().GetBox()
dc.SetClippingRect(rect)
self.TileBackground(dc)
# Fired whenever a paint event occurs
def OnPaint(self, evt):
dc = wxPaintDC(self)
dc = wx.PaintDC(self)
self.PrepareDC(dc)
self.DrawShapes(dc)
# Left mouse button is down.
def OnLeftDown(self, evt):
# Did the mouse go down on one of our shapes?
shape = self.FindShape(evt.GetPosition())
# If a shape was 'hit', then set that as the shape we're going to
# drag around. Get our start position. Dragging has not yet started.
# That will happen once the mouse moves, OR the mouse is released.
if shape:
# get ready to start dragging, but wait for the user to
# move it a bit first
self.dragShape = shape
self.dragStartPos = evt.GetPosition()
# Left mouse button up.
def OnLeftUp(self, evt):
if not self.dragImage or not self.dragShape:
self.dragImage = None
self.dragShape = None
return
# end the dragging
# Hide the image, end dragging, and nuke out the drag image.
self.dragImage.Hide()
self.dragImage.EndDrag()
self.dragImage = None
dc = wxClientDC(self)
dc = wx.ClientDC(self)
if self.hiliteShape:
self.hiliteShape.Draw(dc)
self.hiliteShape = None
# reposition and draw the shape
self.dragShape.pos = self.dragShape.pos + evt.GetPosition() - self.dragStartPos
# Note by jmg 11/28/03
# Here's the original:
#
# self.dragShape.pos = self.dragShape.pos + evt.GetPosition() - self.dragStartPos
#
# So if there are any problems associated with this, use that as
# a starting place in your investigation. I've tried to simulate the
# wx.Point __add__ method here -- it won't work for tuples as we
# have now from the various methods
#
# There must be a better way to do this :-)
#
self.dragShape.pos = (
self.dragShape.pos[0] + evt.GetPosition()[0] - self.dragStartPos[0],
self.dragShape.pos[1] + evt.GetPosition()[1] - self.dragStartPos[1]
)
self.dragShape.shown = True
self.dragShape.Draw(dc)
self.dragShape = None
# The mouse is moving
def OnMotion(self, evt):
# Ignore mouse movement if we're not dragging.
if not self.dragShape or not evt.Dragging() or not evt.LeftIsDown():
return
@@ -206,17 +242,17 @@ class DragCanvas(wxScrolledWindow):
return
# erase the shape since it will be drawn independently now
dc = wxClientDC(self)
dc = wx.ClientDC(self)
self.dragShape.shown = False
self.EraseShape(self.dragShape, dc)
if self.dragShape.text:
self.dragImage = wxDragString(self.dragShape.text,
wxStockCursor(wxCURSOR_HAND))
self.dragImage = wx.DragString(self.dragShape.text,
wx.StockCursor(wx.CURSOR_HAND))
else:
self.dragImage = wxDragImage(self.dragShape.bmp,
wxStockCursor(wxCURSOR_HAND))
self.dragImage = wx.DragImage(self.dragShape.bmp,
wx.StockCursor(wx.CURSOR_HAND))
hotspot = self.dragStartPos - self.dragShape.pos
self.dragImage.BeginDrag(hotspot, self, self.dragShape.fullscreen)
@@ -244,14 +280,14 @@ class DragCanvas(wxScrolledWindow):
self.dragImage.Hide()
if unhiliteOld:
dc = wxClientDC(self)
dc = wx.ClientDC(self)
self.hiliteShape.Draw(dc)
self.hiliteShape = None
if hiliteNew:
dc = wxClientDC(self)
dc = wx.ClientDC(self)
self.hiliteShape = onShape
self.hiliteShape.Draw(dc, wxINVERT)
self.hiliteShape.Draw(dc, wx.INVERT)
# now move it and show it again if needed
self.dragImage.Move(evt.GetPosition())
@@ -262,10 +298,14 @@ class DragCanvas(wxScrolledWindow):
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = wxPanel(nb, -1)
win = wx.Panel(nb, -1)
canvas = DragCanvas(win, -1)
def onSize(evt, panel=win, canvas=canvas): canvas.SetSize(panel.GetSize())
EVT_SIZE(win, onSize)
def onSize(evt, panel=win, canvas=canvas):
canvas.SetSize(panel.GetSize())
win.Bind(wx.EVT_SIZE, onSize)
return win
#----------------------------------------------------------------------
@@ -273,6 +313,28 @@ def runTest(frame, nb, log):
overview = """\
DragImage is used when you wish to drag an object on the screen, and a simple
cursor is not enough.
On Windows, the WIN32 API is used to do achieve smooth dragging. On other
platforms, <code>GenericDragImage</code> is used. Applications may also prefer to use
<code>GenericDragImage</code> on Windows, too.
<b>wxPython note</b>: wxPython uses <code>GenericDragImage</code> on all
platforms, but uses the <code>DragImage</code> name.
To use this class, when you wish to start dragging an image, create a
<code>DragImage</code> object and store it somewhere you can access it as the
drag progresses. Call BeginDrag to start, and EndDrag to stop the drag. To move
the image, initially call Show and then Move. If you wish to update the screen
contents during the drag (for example, highlight an item as in the example), first
call Hide, update the screen, call Move, and then call Show.
You can drag within one window, or you can use full-screen dragging either across
the whole screen, or just restricted to one area of the screen to save resources.
If you want the user to drag between two windows, then you will need to use
full-screen dragging.
"""