[wxWidgets.git] / wxPython / demo / wxDragImage.py


from wxPython.wx import *

import images

#----------------------------------------------------------------------

class DragShape:
    def __init__(self, bmp):
        self.bmp = bmp
        self.pos = wxPoint(0,0)
        self.shown = true
        self.text = None
        self.fullscreen = false


    def HitTest(self, pt):
        rect = self.GetRect()
        return rect.Inside(pt.x, pt.y)


    def GetRect(self):
        return wxRect(self.pos.x, self.pos.y,
                      self.bmp.GetWidth(), self.bmp.GetHeight())


    def Draw(self, dc, op = wxCOPY):
        if self.bmp.Ok():
            memDC = wxMemoryDC()
            memDC.SelectObject(self.bmp)

            dc.Blit(self.pos.x, self.pos.y,
                    self.bmp.GetWidth(), self.bmp.GetHeight(),
                    memDC, 0, 0, op, true)

            return true
        else:
            return false


#----------------------------------------------------------------------

class DragCanvas(wxScrolledWindow):
    def __init__(self, parent, ID):
        wxScrolledWindow.__init__(self, parent, ID)
        self.shapes = []
        self.dragImage = None
        self.dragShape = None
        self.hiliteShape = None

        self.SetCursor(wxStockCursor(wxCURSOR_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.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)
        textExtent = self.GetFullTextExtent(text, font)
        bmp = wxEmptyBitmap(textExtent[0], textExtent[1])
        dc = wxMemoryDC()
        dc.SelectObject(bmp)
        dc.SetBackground(wxBrush(bg_colour, wxSOLID))
        dc.Clear()
        dc.SetTextForeground(wxRED)
        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.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)
            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)


    def OnLeaveWindow(self, evt):
        pass


    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


    def DrawShapes(self, dc):
        for shape in self.shapes:
            if shape.shown:
                shape.Draw(dc)


    def FindShape(self, pt):
        for shape in self.shapes:
            if shape.HitTest(pt):
                return shape
        return None


    def EraseShape(self, shape, dc):
        r = shape.GetRect()
        dc.SetClippingRegion(r.x, r.y, r.width, r.height)
        self.TileBackground(dc)
        self.DrawShapes(dc)
        dc.DestroyClippingRegion()


    def OnEraseBackground(self, evt):
        dc = evt.GetDC()
        if not dc:
            dc = wxClientDC(self)
            rect = self.GetUpdateRegion().GetBox()
            dc.SetClippingRegion(rect.x, rect.y, rect.width, rect.height)
        self.TileBackground(dc)


    def OnPaint(self, evt):
        dc = wxPaintDC(self)
        self.PrepareDC(dc)
        self.DrawShapes(dc)


    def OnLeftDown(self, evt):
        shape = self.FindShape(evt.GetPosition())
        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()


    def OnLeftUp(self, evt):
        if not self.dragImage or not self.dragShape:
            self.dragImage = None
            self.dragShape = None
            return

        # end the dragging
        self.dragImage.Hide()
        self.dragImage.EndDrag()
        self.dragImage = None

        dc = wxClientDC(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
        self.dragShape.shown = true
        self.dragShape.Draw(dc)
        self.dragShape = None


    def OnMotion(self, evt):
        if not self.dragShape or not evt.Dragging() or not evt.LeftIsDown():
            return

        # if we have a shape, but havn't started dragging yet
        if self.dragShape and not self.dragImage:

            # only start the drag after having moved a couple pixels
            tolerance = 2
            pt = evt.GetPosition()
            dx = abs(pt.x - self.dragStartPos.x)
            dy = abs(pt.y - self.dragStartPos.y)
            if dx <= tolerance and dy <= tolerance:
                return

            # erase the shape since it will be drawn independently now
            dc = wxClientDC(self)
            self.dragShape.shown = false
            self.EraseShape(self.dragShape, dc)


            if self.dragShape.text:
                self.dragImage = wxDragString(self.dragShape.text,
                                              wxStockCursor(wxCURSOR_HAND))
            else:
                self.dragImage = wxDragImage(self.dragShape.bmp,
                                             wxStockCursor(wxCURSOR_HAND))

            hotspot = self.dragStartPos - self.dragShape.pos
            self.dragImage.BeginDrag(hotspot, self, self.dragShape.fullscreen)

            self.dragImage.Move(pt)
            self.dragImage.Show()


        # if we have shape and image then move it, posibly highlighting another shape.
        elif self.dragShape and self.dragImage:
            onShape = self.FindShape(evt.GetPosition())
            unhiliteOld = false
            hiliteNew = false

            # figure out what to hilite and what to unhilite
            if self.hiliteShape:
                if onShape is None or self.hiliteShape is not onShape:
                    unhiliteOld = true

            if onShape and onShape is not self.hiliteShape and onShape.shown:
                hiliteNew = TRUE

            # if needed, hide the drag image so we can update the window
            if unhiliteOld or hiliteNew:
                self.dragImage.Hide()

            if unhiliteOld:
                dc = wxClientDC(self)
                self.hiliteShape.Draw(dc)
                self.hiliteShape = None

            if hiliteNew:
                dc = wxClientDC(self)
                self.hiliteShape = onShape
                self.hiliteShape.Draw(dc, wxINVERT)

            # now move it and show it again if needed
            self.dragImage.Move(evt.GetPosition())
            if unhiliteOld or hiliteNew:
                self.dragImage.Show()


#----------------------------------------------------------------------

def runTest(frame, nb, log):
    win = wxPanel(nb, -1)
    canvas = DragCanvas(win, -1)
    def onSize(evt, panel=win, canvas=canvas): canvas.SetSize(panel.GetSize())
    EVT_SIZE(win, onSize)
    return win

#----------------------------------------------------------------------


overview = """\
"""
Commit	Line	Data
f6bcfd97 BP	1
	2	from wxPython.wx import *
	3
96bfd053 RD	4	import images
96bfd053 RD	5
f6bcfd97 BP	6	#----------------------------------------------------------------------
	7
	8	class DragShape:
	9	def __init__(self, bmp):
	10	self.bmp = bmp
	11	self.pos = wxPoint(0,0)
	12	self.shown = true
	13	self.text = None
	14	self.fullscreen = false
	15
	16
	17	def HitTest(self, pt):
	18	rect = self.GetRect()
	19	return rect.Inside(pt.x, pt.y)
	20
	21
	22	def GetRect(self):
	23	return wxRect(self.pos.x, self.pos.y,
	24	self.bmp.GetWidth(), self.bmp.GetHeight())
	25
	26
	27	def Draw(self, dc, op = wxCOPY):
	28	if self.bmp.Ok():
	29	memDC = wxMemoryDC()
	30	memDC.SelectObject(self.bmp)
	31
	32	dc.Blit(self.pos.x, self.pos.y,
	33	self.bmp.GetWidth(), self.bmp.GetHeight(),
	34	memDC, 0, 0, op, true)
	35
	36	return true
	37	else:
	38	return false
	39
	40
	41
	42	#----------------------------------------------------------------------
	43
	44	class DragCanvas(wxScrolledWindow):
	45	def __init__(self, parent, ID):
	46	wxScrolledWindow.__init__(self, parent, ID)
	47	self.shapes = []
	48	self.dragImage = None
	49	self.dragShape = None
10e07c70	50	self.hiliteShape = None
f6bcfd97 BP	51
f6bcfd97 BP	52	self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
96bfd053	53	self.bg_bmp = images.getBackgroundBitmap()
f6bcfd97 BP	54
	55
	56	# Make a shape from an image and mask. This one will demo
	57	# dragging outside the window
96bfd053	58	bmp = images.getTestStarBitmap()
f6bcfd97 BP	59	shape = DragShape(bmp)
	60	shape.pos = wxPoint(5, 5)
	61	shape.fullscreen = true
	62	self.shapes.append(shape)
	63
	64
	65	# Make a shape from some text
	66	text = "Some Text"
f2a10cdc	67	bg_colour = wxColour(57, 115, 57) # matches the bg image
f6bcfd97 BP	68	font = wxFont(15, wxROMAN, wxNORMAL, wxBOLD)
	69	textExtent = self.GetFullTextExtent(text, font)
	70	bmp = wxEmptyBitmap(textExtent[0], textExtent[1])
	71	dc = wxMemoryDC()
	72	dc.SelectObject(bmp)
f2a10cdc	73	dc.SetBackground(wxBrush(bg_colour, wxSOLID))
f6bcfd97 BP	74	dc.Clear()
	75	dc.SetTextForeground(wxRED)
	76	dc.SetFont(font)
	77	dc.DrawText(text, 0, 0)
	78	dc.SelectObject(wxNullBitmap)
f2a10cdc	79	mask = wxMaskColour(bmp, bg_colour)
f6bcfd97 BP	80	bmp.SetMask(mask)
	81	shape = DragShape(bmp)
	82	shape.pos = wxPoint(5, 100)
	83	shape.text = "Some dragging text"
	84	self.shapes.append(shape)
	85
	86
	87	# Make some shapes from some playing card images.
	88	x = 200
96bfd053 RD	89	for card in ['_01c_', '_12h_', '_13d_', '_10s_']:
	90	bmpFunc = getattr(images, "get%sBitmap" % card)
	91	bmp = bmpFunc()
f6bcfd97 BP	92	shape = DragShape(bmp)
	93	shape.pos = wxPoint(x, 5)
	94	self.shapes.append(shape)
	95	x = x + 80
	96
	97
	98	EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
	99	EVT_PAINT(self, self.OnPaint)
	100	EVT_LEFT_DOWN(self, self.OnLeftDown)
	101	EVT_LEFT_UP(self, self.OnLeftUp)
	102	EVT_MOTION(self, self.OnMotion)
d42e29c2	103	EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
f6bcfd97 BP	104
f6bcfd97 BP	105
d42e29c2 RD	106	def OnLeaveWindow(self, evt):
	107	pass
	108
f6bcfd97 BP	109
	110	def TileBackground(self, dc):
	111	# tile the background bitmap
	112	sz = self.GetClientSize()
	113	w = self.bg_bmp.GetWidth()
	114	h = self.bg_bmp.GetHeight()
	115
	116	x = 0
	117	while x < sz.width:
	118	y = 0
	119	while y < sz.height:
	120	dc.DrawBitmap(self.bg_bmp, x, y)
	121	y = y + h
	122	x = x + w
	123
	124
	125	def DrawShapes(self, dc):
	126	for shape in self.shapes:
	127	if shape.shown:
	128	shape.Draw(dc)
	129
	130
	131	def FindShape(self, pt):
	132	for shape in self.shapes:
	133	if shape.HitTest(pt):
	134	return shape
	135	return None
	136
	137
	138	def EraseShape(self, shape, dc):
	139	r = shape.GetRect()
	140	dc.SetClippingRegion(r.x, r.y, r.width, r.height)
	141	self.TileBackground(dc)
	142	self.DrawShapes(dc)
	143	dc.DestroyClippingRegion()
	144
	145
f6bcfd97 BP	146	def OnEraseBackground(self, evt):
	147	dc = evt.GetDC()
	148	if not dc:
	149	dc = wxClientDC(self)
b166c703 RD	150	rect = self.GetUpdateRegion().GetBox()
b166c703 RD	151	dc.SetClippingRegion(rect.x, rect.y, rect.width, rect.height)
f6bcfd97 BP	152	self.TileBackground(dc)
	153
	154
	155	def OnPaint(self, evt):
	156	dc = wxPaintDC(self)
	157	self.PrepareDC(dc)
	158	self.DrawShapes(dc)
	159
	160
	161	def OnLeftDown(self, evt):
	162	shape = self.FindShape(evt.GetPosition())
	163	if shape:
	164	# get ready to start dragging, but wait for the user to
	165	# move it a bit first
	166	self.dragShape = shape
	167	self.dragStartPos = evt.GetPosition()
	168
	169
	170	def OnLeftUp(self, evt):
	171	if not self.dragImage or not self.dragShape:
	172	self.dragImage = None
	173	self.dragShape = None
	174	return
	175
	176	# end the dragging
	177	self.dragImage.Hide()
	178	self.dragImage.EndDrag()
	179	self.dragImage = None
	180
f6bcfd97	181	dc = wxClientDC(self)
10e07c70 RD	182	if self.hiliteShape:
	183	self.hiliteShape.Draw(dc)
	184	self.hiliteShape = None
	185
	186	# reposition and draw the shape
	187	self.dragShape.pos = self.dragShape.pos + evt.GetPosition() - self.dragStartPos
f6bcfd97 BP	188	self.dragShape.shown = true
	189	self.dragShape.Draw(dc)
	190	self.dragShape = None
	191
	192
	193	def OnMotion(self, evt):
	194	if not self.dragShape or not evt.Dragging() or not evt.LeftIsDown():
	195	return
	196
	197	# if we have a shape, but havn't started dragging yet
	198	if self.dragShape and not self.dragImage:
	199
	200	# only start the drag after having moved a couple pixels
10e07c70	201	tolerance = 2
f6bcfd97 BP	202	pt = evt.GetPosition()
	203	dx = abs(pt.x - self.dragStartPos.x)
	204	dy = abs(pt.y - self.dragStartPos.y)
	205	if dx <= tolerance and dy <= tolerance:
	206	return
	207
10e07c70 RD	208	# erase the shape since it will be drawn independently now
	209	dc = wxClientDC(self)
	210	self.dragShape.shown = false
	211	self.EraseShape(self.dragShape, dc)
	212
	213
f6bcfd97 BP	214	if self.dragShape.text:
	215	self.dragImage = wxDragString(self.dragShape.text,
	216	wxStockCursor(wxCURSOR_HAND))
	217	else:
	218	self.dragImage = wxDragImage(self.dragShape.bmp,
	219	wxStockCursor(wxCURSOR_HAND))
	220
10e07c70 RD	221	hotspot = self.dragStartPos - self.dragShape.pos
10e07c70 RD	222	self.dragImage.BeginDrag(hotspot, self, self.dragShape.fullscreen)
f6bcfd97	223
10e07c70	224	self.dragImage.Move(pt)
f6bcfd97 BP	225	self.dragImage.Show()
	226
	227
10e07c70	228	# if we have shape and image then move it, posibly highlighting another shape.
f6bcfd97	229	elif self.dragShape and self.dragImage:
10e07c70 RD	230	onShape = self.FindShape(evt.GetPosition())
	231	unhiliteOld = false
	232	hiliteNew = false
	233
	234	# figure out what to hilite and what to unhilite
	235	if self.hiliteShape:
	236	if onShape is None or self.hiliteShape is not onShape:
	237	unhiliteOld = true
	238
	239	if onShape and onShape is not self.hiliteShape and onShape.shown:
	240	hiliteNew = TRUE
	241
	242	# if needed, hide the drag image so we can update the window
	243	if unhiliteOld or hiliteNew:
	244	self.dragImage.Hide()
	245
	246	if unhiliteOld:
	247	dc = wxClientDC(self)
	248	self.hiliteShape.Draw(dc)
	249	self.hiliteShape = None
	250
	251	if hiliteNew:
	252	dc = wxClientDC(self)
	253	self.hiliteShape = onShape
	254	self.hiliteShape.Draw(dc, wxINVERT)
	255
	256	# now move it and show it again if needed
	257	self.dragImage.Move(evt.GetPosition())
	258	if unhiliteOld or hiliteNew:
	259	self.dragImage.Show()
f6bcfd97 BP	260
	261
	262	#----------------------------------------------------------------------
	263
	264	def runTest(frame, nb, log):
70a357c2 RD	265	win = wxPanel(nb, -1)
	266	canvas = DragCanvas(win, -1)
	267	def onSize(evt, panel=win, canvas=canvas): canvas.SetSize(panel.GetSize())
	268	EVT_SIZE(win, onSize)
f6bcfd97 BP	269	return win
	270
	271	#----------------------------------------------------------------------
	272
	273
	274
	275	overview = """\
	276	"""