[wxWidgets.git] / samples / dragimag / dragimag.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dragimag.cpp
// Purpose:     wxDragImage sample
// Author:      Julian Smart
// Modified by:
// Created:     28/2/2000
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/image.h"

// Under Windows, change this to 1
// to use wxGenericDragImage

#define wxUSE_GENERIC_DRAGIMAGE 1

#if wxUSE_GENERIC_DRAGIMAGE
#include "wx/generic/dragimgg.h"
#define wxDragImage wxGenericDragImage
#else
#include "wx/dragimag.h"
#endif

#include "dragimag.h"

#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__)
#include "mondrian.xpm"
#include "dragicon.xpm"
#endif

// main program

IMPLEMENT_APP(MyApp)

// MyCanvas

IMPLEMENT_CLASS(MyCanvas, wxScrolledWindow)

BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
  EVT_PAINT(MyCanvas::OnPaint)
  EVT_ERASE_BACKGROUND(MyCanvas::OnEraseBackground)
  EVT_MOUSE_EVENTS(MyCanvas::OnMouseEvent)
END_EVENT_TABLE()

MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
                    const wxPoint &pos, const wxSize &size )
        : wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
{
    SetBackgroundColour(* wxWHITE);

    SetCursor(wxCursor(wxCURSOR_ARROW));

    m_dragMode = TEST_DRAG_NONE;
    m_draggedShape = (DragShape*) NULL;
    m_dragImage = (wxDragImage*) NULL;
    m_currentlyHighlighted = (DragShape*) NULL;
}

MyCanvas::~MyCanvas()
{
    ClearShapes();

    if (m_dragImage)
        delete m_dragImage;
}

void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
{
    wxPaintDC dc( this );
    PrepareDC( dc );

    DrawShapes(dc);
}

void MyCanvas::OnEraseBackground(wxEraseEvent& event)
{
    if (wxGetApp().GetBackgroundBitmap().Ok())
    {
        wxSize sz = GetClientSize();
        wxRect rect(0, 0, sz.x, sz.y);
        
        if (event.GetDC())
        {
            wxGetApp().TileBitmap(rect, *(event.GetDC()), wxGetApp().GetBackgroundBitmap());
        }
        else
        {
            wxClientDC dc(this);
            wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());
        }
    }
    else
        event.Skip(); // The official way of doing it
}

void MyCanvas::OnMouseEvent(wxMouseEvent& event)
{
    if (event.LeftDown())
    {
        DragShape* shape = FindShape(event.GetPosition());
        if (shape)
        {
            // We tentatively start dragging, but wait for
            // mouse movement before dragging properly.

            m_dragMode = TEST_DRAG_START;
            m_dragStartPos = event.GetPosition();
            m_draggedShape = shape;
        }
    }
    else if (event.LeftUp() && m_dragMode != TEST_DRAG_NONE)
    {
        // Finish dragging

        m_dragMode = TEST_DRAG_NONE;

        if (!m_draggedShape || !m_dragImage)
            return;

        m_draggedShape->SetPosition(m_draggedShape->GetPosition()
                                    + event.GetPosition() - m_dragStartPos);

        m_dragImage->Hide();
        m_dragImage->EndDrag();
        delete m_dragImage;
        m_dragImage = NULL;

        wxClientDC dc(this);
        if (m_currentlyHighlighted)
        {
            m_currentlyHighlighted->Draw(dc);
        }
        m_draggedShape->SetShow(TRUE);
        m_draggedShape->Draw(dc);

        m_currentlyHighlighted = (DragShape*) NULL;

        m_draggedShape = (DragShape*) NULL;
    }
    else if (event.Dragging() && m_dragMode != TEST_DRAG_NONE)
    {
        if (m_dragMode == TEST_DRAG_START)
        {
            // We will start dragging if we've moved beyond a couple of pixels

            int tolerance = 2;
            int dx = abs(event.GetPosition().x - m_dragStartPos.x);
            int dy = abs(event.GetPosition().y - m_dragStartPos.y);
            if (dx <= tolerance && dy <= tolerance)
                return;

            // Start the drag.
            m_dragMode = TEST_DRAG_DRAGGING;

            if (m_dragImage)
                delete m_dragImage;

            // Erase the dragged shape from the canvas
            m_draggedShape->SetShow(FALSE);
            wxClientDC dc(this);
            EraseShape(m_draggedShape, dc);
            DrawShapes(dc);

            switch (m_draggedShape->GetDragMethod())
            {
                case SHAPE_DRAG_BITMAP:
                {
                    m_dragImage = new wxDragImage(m_draggedShape->GetBitmap(), wxCursor(wxCURSOR_HAND));
                    break;
                }
                case SHAPE_DRAG_TEXT:
                {
                    m_dragImage = new wxDragImage(wxString("Dragging some test text"), wxCursor(wxCURSOR_HAND));
                    break;
                }
                case SHAPE_DRAG_ICON:
                {
                    // Can anyone explain why this test is necessary,
                    // to prevent a gcc error?
#ifdef __WXMOTIF__
                    wxIcon icon(dragicon_xpm);
#else
                    wxIcon icon(wxICON(dragicon));
#endif
                    
                    m_dragImage = new wxDragImage(icon, wxCursor(wxCURSOR_HAND));
                    break;
                }
            }

            bool fullScreen = wxGetApp().GetUseScreen();

            // The offset between the top-left of the shape image and the current shape position
            wxPoint beginDragHotSpot = m_dragStartPos - m_draggedShape->GetPosition();
            
            // Now we do this inside the implementation: always assume
            // coordinates relative to the capture window (client coordinates)

            //if (fullScreen)
            //    beginDragHotSpot -= ClientToScreen(wxPoint(0, 0));
            
            if (!m_dragImage->BeginDrag(beginDragHotSpot, this, fullScreen))
            {
                delete m_dragImage;
                m_dragImage = (wxDragImage*) NULL;
                m_dragMode = TEST_DRAG_NONE;
                
            } else
            {
                m_dragImage->Move(event.GetPosition());
                m_dragImage->Show();
            }
        }
        else if (m_dragMode == TEST_DRAG_DRAGGING)
        {
            // We're currently dragging. See if we're over another shape.
            DragShape* onShape = FindShape(event.GetPosition());

            bool mustUnhighlightOld = FALSE;
            bool mustHighlightNew = FALSE;

            if (m_currentlyHighlighted)
            {
                if ((onShape == (DragShape*) NULL) || (m_currentlyHighlighted != onShape))
                    mustUnhighlightOld = TRUE;
            }

            if (onShape && (onShape != m_currentlyHighlighted) && onShape->IsShown())
                mustHighlightNew = TRUE;

            if (mustUnhighlightOld || mustHighlightNew)
                m_dragImage->Hide();

            // Now with the drag image switched off, we can change the window contents.

            if (mustUnhighlightOld)
            {
                wxClientDC clientDC(this);
                m_currentlyHighlighted->Draw(clientDC);
                m_currentlyHighlighted = (DragShape*) NULL;
            }
            if (mustHighlightNew)
            {
                wxClientDC clientDC(this);
                m_currentlyHighlighted = onShape;
                m_currentlyHighlighted->Draw(clientDC, wxINVERT);
            }

            // Move and show the image again
            m_dragImage->Move(event.GetPosition());

            if (mustUnhighlightOld || mustHighlightNew)
                 m_dragImage->Show();
        }
    }
}

void MyCanvas::DrawShapes(wxDC& dc)
{
    wxNode* node = m_displayList.First();
    while (node)
    {
        DragShape* shape = (DragShape*) node->Data();
        if (shape->IsShown())
          shape->Draw(dc);
        node = node->Next();
    }
}

void MyCanvas::EraseShape(DragShape* shape, wxDC& dc)
{
    wxSize sz = GetClientSize();
    wxRect rect(0, 0, sz.x, sz.y);

    wxRect rect2(shape->GetRect());
    dc.SetClippingRegion(rect2.x, rect2.y, rect2.width, rect2.height);
        
    wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());

    dc.DestroyClippingRegion();
}

void MyCanvas::ClearShapes()
{
    wxNode* node = m_displayList.First();
    while (node)
    {
        DragShape* shape = (DragShape*) node->Data();
        delete shape;
        node = node->Next();
    }
    m_displayList.Clear();
}

DragShape* MyCanvas::FindShape(const wxPoint& pt) const
{
    wxNode* node = m_displayList.First();
    while (node)
    {
        DragShape* shape = (DragShape*) node->Data();
        if (shape->HitTest(pt))
            return shape;
        node = node->Next();
    }
    return (DragShape*) NULL;
}

// MyFrame
IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )

BEGIN_EVENT_TABLE(MyFrame,wxFrame)
  EVT_MENU    (wxID_ABOUT, MyFrame::OnAbout)
  EVT_MENU    (wxID_EXIT,  MyFrame::OnQuit)
END_EVENT_TABLE()

MyFrame::MyFrame()
       : wxFrame( (wxFrame *)NULL, -1, "wxDragImage sample",
                  wxPoint(20,20), wxSize(470,360) )
{
  wxMenu *file_menu = new wxMenu();
  file_menu->Append( wxID_ABOUT, "&About...");
  file_menu->Append( TEST_USE_SCREEN, "&Use whole screen for dragging", "Use whole screen", TRUE);
  file_menu->Append( wxID_EXIT, "E&xit");

  wxMenuBar *menu_bar = new wxMenuBar();
  menu_bar->Append(file_menu, "&File");

  SetMenuBar( menu_bar );

  CreateStatusBar(2);
  int widths[] = { -1, 100 };
  SetStatusWidths( 2, widths );

  m_canvas = new MyCanvas( this, -1, wxPoint(0,0), wxSize(10,10) );
}

void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) )
{
  Close( TRUE );
}

void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
{
  (void)wxMessageBox( "wxDragImage demo\n"
                      "Julian Smart (c) 2000",
                      "About wxDragImage Demo", wxICON_INFORMATION | wxOK );
}

//-----------------------------------------------------------------------------
// MyApp
//-----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyApp, wxApp)
    EVT_MENU(TEST_USE_SCREEN, MyApp::OnUseScreen)
END_EVENT_TABLE()

MyApp::MyApp()
{
    // Drag across whole screen
    m_useScreen = FALSE;
}

bool MyApp::OnInit()
{
#if wxUSE_LIBPNG
    wxImage::AddHandler( new wxPNGHandler );
#endif

    wxImage image;
    if (image.LoadFile("backgrnd.png", wxBITMAP_TYPE_PNG))
    {
        m_background = image.ConvertToBitmap();
    }

    MyFrame *frame = new MyFrame();

    wxString rootName("shape0");

    int i;
    for (i = 1; i < 4; i++)
    {
        wxString filename;
        filename.Printf(wxT("%s%d.png"), (const wxChar*)rootName, i);
        if (image.LoadFile(filename, wxBITMAP_TYPE_PNG))
        {
            DragShape* newShape = new DragShape(image.ConvertToBitmap());
            newShape->SetPosition(wxPoint(i*50, i*50));

            if (i == 2)
                newShape->SetDragMethod(SHAPE_DRAG_TEXT);
            else if (i == 3)
                newShape->SetDragMethod(SHAPE_DRAG_ICON);
            else
                newShape->SetDragMethod(SHAPE_DRAG_BITMAP);
            frame->GetCanvas()->GetDisplayList().Append(newShape);
        }
    }

#if 0
    // Under Motif or GTK, this demonstrates that
    // wxScreenDC only gets the root window content.
    // We need to be able to copy the overall content
    // for full-screen dragging to work.
    int w, h;
    wxDisplaySize(& w, & h);
    wxBitmap bitmap(w, h);

    wxScreenDC dc;
    wxMemoryDC memDC;
    memDC.SelectObject(bitmap);
    memDC.Blit(0, 0, w, h, & dc, 0, 0);
    memDC.SelectObject(wxNullBitmap);
    m_background = bitmap;
#endif

    frame->Show( TRUE );

    return TRUE;
}

int MyApp::OnExit()
{
    return 0;
}

bool MyApp::TileBitmap(const wxRect& rect, wxDC& dc, wxBitmap& bitmap)
{
    int w = bitmap.GetWidth();
    int h = bitmap.GetHeight();
    
    int i, j;
    for (i = rect.x; i < rect.x + rect.width; i += w)
    {
        for (j = rect.y; j < rect.y + rect.height; j+= h)
            dc.DrawBitmap(bitmap, i, j);
    }
    return TRUE;
}

void MyApp::OnUseScreen(wxCommandEvent& event)
{
    m_useScreen = !m_useScreen;
}

// DragShape

DragShape::DragShape(const wxBitmap& bitmap)
{
    m_bitmap = bitmap;
    m_pos.x = 0;
    m_pos.y = 0;
    m_dragMethod = SHAPE_DRAG_BITMAP;
    m_show = TRUE;
}

DragShape::~DragShape()
{
}

bool DragShape::HitTest(const wxPoint& pt) const
{
    wxRect rect(GetRect());
    return rect.Inside(pt.x, pt.y);
}

bool DragShape::Draw(wxDC& dc, int op)
{
    if (m_bitmap.Ok())
    {
        wxMemoryDC memDC;
        memDC.SelectObject(m_bitmap);
    
        dc.Blit(m_pos.x, m_pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight(),
            & memDC, 0, 0, op, TRUE);

        return TRUE;
    }
    else
        return FALSE;
}
Commit	Line	Data
68be9f09	1	/////////////////////////////////////////////////////////////////////////////
11e2dfd3	2	// Name: dragimag.cpp
68be9f09 JS	3	// Purpose: wxDragImage sample
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 28/2/2000
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx/wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
11e2dfd3	20	#include "wx/wx.h"
68be9f09 JS	21	#endif
68be9f09 JS	22
11e2dfd3	23	#include "wx/image.h"
68be9f09 JS	24
	25	// Under Windows, change this to 1
	26	// to use wxGenericDragImage
	27
aa2d25a5	28	#define wxUSE_GENERIC_DRAGIMAGE 1
68be9f09 JS	29
68be9f09 JS	30	#if wxUSE_GENERIC_DRAGIMAGE
11e2dfd3	31	#include "wx/generic/dragimgg.h"
68be9f09 JS	32	#define wxDragImage wxGenericDragImage
68be9f09 JS	33	#else
11e2dfd3	34	#include "wx/dragimag.h"
68be9f09 JS	35	#endif
68be9f09 JS	36
11e2dfd3	37	#include "dragimag.h"
68be9f09	38
83661a13	39	#if defined(__WXGTK__) \|\| defined(__WXMOTIF__) \|\| defined(__WXMAC__)
68be9f09 JS	40	#include "mondrian.xpm"
	41	#include "dragicon.xpm"
	42	#endif
	43
	44	// main program
	45
	46	IMPLEMENT_APP(MyApp)
	47
	48	// MyCanvas
	49
	50	IMPLEMENT_CLASS(MyCanvas, wxScrolledWindow)
	51
	52	BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
	53	EVT_PAINT(MyCanvas::OnPaint)
	54	EVT_ERASE_BACKGROUND(MyCanvas::OnEraseBackground)
	55	EVT_MOUSE_EVENTS(MyCanvas::OnMouseEvent)
	56	END_EVENT_TABLE()
	57
	58	MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
	59	const wxPoint &pos, const wxSize &size )
	60	: wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
	61	{
	62	SetBackgroundColour(* wxWHITE);
	63
	64	SetCursor(wxCursor(wxCURSOR_ARROW));
	65
	66	m_dragMode = TEST_DRAG_NONE;
	67	m_draggedShape = (DragShape*) NULL;
	68	m_dragImage = (wxDragImage*) NULL;
	69	m_currentlyHighlighted = (DragShape*) NULL;
	70	}
	71
	72	MyCanvas::~MyCanvas()
	73	{
	74	ClearShapes();
	75
	76	if (m_dragImage)
	77	delete m_dragImage;
	78	}
	79
	80	void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
	81	{
	82	wxPaintDC dc( this );
	83	PrepareDC( dc );
	84
	85	DrawShapes(dc);
68be9f09 JS	86	}
	87
	88	void MyCanvas::OnEraseBackground(wxEraseEvent& event)
	89	{
	90	if (wxGetApp().GetBackgroundBitmap().Ok())
	91	{
	92	wxSize sz = GetClientSize();
	93	wxRect rect(0, 0, sz.x, sz.y);
	94
	95	if (event.GetDC())
	96	{
	97	wxGetApp().TileBitmap(rect, *(event.GetDC()), wxGetApp().GetBackgroundBitmap());
	98	}
	99	else
	100	{
	101	wxClientDC dc(this);
	102	wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());
	103	}
	104	}
	105	else
	106	event.Skip(); // The official way of doing it
	107	}
	108
	109	void MyCanvas::OnMouseEvent(wxMouseEvent& event)
	110	{
	111	if (event.LeftDown())
	112	{
	113	DragShape* shape = FindShape(event.GetPosition());
	114	if (shape)
	115	{
	116	// We tentatively start dragging, but wait for
	117	// mouse movement before dragging properly.
	118
	119	m_dragMode = TEST_DRAG_START;
	120	m_dragStartPos = event.GetPosition();
	121	m_draggedShape = shape;
	122	}
	123	}
	124	else if (event.LeftUp() && m_dragMode != TEST_DRAG_NONE)
	125	{
	126	// Finish dragging
	127
	128	m_dragMode = TEST_DRAG_NONE;
	129
	130	if (!m_draggedShape \|\| !m_dragImage)
	131	return;
	132
aa2d25a5 JS	133	m_draggedShape->SetPosition(m_draggedShape->GetPosition()
aa2d25a5 JS	134	+ event.GetPosition() - m_dragStartPos);
68be9f09 JS	135
	136	m_dragImage->Hide();
	137	m_dragImage->EndDrag();
	138	delete m_dragImage;
	139	m_dragImage = NULL;
	140
	141	wxClientDC dc(this);
	142	if (m_currentlyHighlighted)
	143	{
	144	m_currentlyHighlighted->Draw(dc);
	145	}
	146	m_draggedShape->SetShow(TRUE);
	147	m_draggedShape->Draw(dc);
	148
	149	m_currentlyHighlighted = (DragShape*) NULL;
	150
	151	m_draggedShape = (DragShape*) NULL;
	152	}
	153	else if (event.Dragging() && m_dragMode != TEST_DRAG_NONE)
	154	{
	155	if (m_dragMode == TEST_DRAG_START)
	156	{
	157	// We will start dragging if we've moved beyond a couple of pixels
	158
	159	int tolerance = 2;
	160	int dx = abs(event.GetPosition().x - m_dragStartPos.x);
	161	int dy = abs(event.GetPosition().y - m_dragStartPos.y);
	162	if (dx <= tolerance && dy <= tolerance)
	163	return;
	164
68be9f09 JS	165	// Start the drag.
	166	m_dragMode = TEST_DRAG_DRAGGING;
	167
	168	if (m_dragImage)
	169	delete m_dragImage;
	170
	171	// Erase the dragged shape from the canvas
	172	m_draggedShape->SetShow(FALSE);
	173	wxClientDC dc(this);
	174	EraseShape(m_draggedShape, dc);
	175	DrawShapes(dc);
	176
	177	switch (m_draggedShape->GetDragMethod())
	178	{
	179	case SHAPE_DRAG_BITMAP:
	180	{
aa2d25a5	181	m_dragImage = new wxDragImage(m_draggedShape->GetBitmap(), wxCursor(wxCURSOR_HAND));
68be9f09 JS	182	break;
	183	}
	184	case SHAPE_DRAG_TEXT:
	185	{
a0bb22c2	186	m_dragImage = new wxDragImage(wxString("Dragging some test text"), wxCursor(wxCURSOR_HAND));
68be9f09 JS	187	break;
	188	}
	189	case SHAPE_DRAG_ICON:
	190	{
68be9f09 JS	191	// Can anyone explain why this test is necessary,
	192	// to prevent a gcc error?
	193	#ifdef __WXMOTIF__
6ea5c52d	194	wxIcon icon(dragicon_xpm);
68be9f09	195	#else
6ea5c52d	196	wxIcon icon(wxICON(dragicon));
68be9f09	197	#endif
6ea5c52d	198
aa2d25a5	199	m_dragImage = new wxDragImage(icon, wxCursor(wxCURSOR_HAND));
68be9f09 JS	200	break;
	201	}
	202	}
	203
aa2d25a5	204	bool fullScreen = wxGetApp().GetUseScreen();
68be9f09	205
aa2d25a5 JS	206	// The offset between the top-left of the shape image and the current shape position
	207	wxPoint beginDragHotSpot = m_dragStartPos - m_draggedShape->GetPosition();
	208
	209	// Now we do this inside the implementation: always assume
	210	// coordinates relative to the capture window (client coordinates)
68be9f09	211
aa2d25a5 JS	212	//if (fullScreen)
	213	// beginDragHotSpot -= ClientToScreen(wxPoint(0, 0));
	214
	215	if (!m_dragImage->BeginDrag(beginDragHotSpot, this, fullScreen))
68be9f09 JS	216	{
	217	delete m_dragImage;
	218	m_dragImage = (wxDragImage*) NULL;
	219	m_dragMode = TEST_DRAG_NONE;
aa2d25a5 JS	220
	221	} else
	222	{
	223	m_dragImage->Move(event.GetPosition());
	224	m_dragImage->Show();
68be9f09	225	}
68be9f09 JS	226	}
	227	else if (m_dragMode == TEST_DRAG_DRAGGING)
	228	{
	229	// We're currently dragging. See if we're over another shape.
	230	DragShape* onShape = FindShape(event.GetPosition());
	231
	232	bool mustUnhighlightOld = FALSE;
	233	bool mustHighlightNew = FALSE;
	234
	235	if (m_currentlyHighlighted)
	236	{
	237	if ((onShape == (DragShape*) NULL) \|\| (m_currentlyHighlighted != onShape))
	238	mustUnhighlightOld = TRUE;
	239	}
	240
	241	if (onShape && (onShape != m_currentlyHighlighted) && onShape->IsShown())
	242	mustHighlightNew = TRUE;
	243
	244	if (mustUnhighlightOld \|\| mustHighlightNew)
	245	m_dragImage->Hide();
	246
	247	// Now with the drag image switched off, we can change the window contents.
	248
	249	if (mustUnhighlightOld)
	250	{
	251	wxClientDC clientDC(this);
	252	m_currentlyHighlighted->Draw(clientDC);
	253	m_currentlyHighlighted = (DragShape*) NULL;
	254	}
	255	if (mustHighlightNew)
	256	{
	257	wxClientDC clientDC(this);
	258	m_currentlyHighlighted = onShape;
	259	m_currentlyHighlighted->Draw(clientDC, wxINVERT);
	260	}
	261
68be9f09	262	// Move and show the image again
aa2d25a5	263	m_dragImage->Move(event.GetPosition());
68be9f09 JS	264
	265	if (mustUnhighlightOld \|\| mustHighlightNew)
	266	m_dragImage->Show();
	267	}
	268	}
	269	}
	270
	271	void MyCanvas::DrawShapes(wxDC& dc)
	272	{
	273	wxNode* node = m_displayList.First();
	274	while (node)
	275	{
	276	DragShape* shape = (DragShape*) node->Data();
	277	if (shape->IsShown())
	278	shape->Draw(dc);
	279	node = node->Next();
	280	}
	281	}
	282
	283	void MyCanvas::EraseShape(DragShape* shape, wxDC& dc)
	284	{
	285	wxSize sz = GetClientSize();
	286	wxRect rect(0, 0, sz.x, sz.y);
	287
	288	wxRect rect2(shape->GetRect());
	289	dc.SetClippingRegion(rect2.x, rect2.y, rect2.width, rect2.height);
	290
	291	wxGetApp().TileBitmap(rect, dc, wxGetApp().GetBackgroundBitmap());
	292
	293	dc.DestroyClippingRegion();
	294	}
	295
	296	void MyCanvas::ClearShapes()
	297	{
	298	wxNode* node = m_displayList.First();
	299	while (node)
	300	{
	301	DragShape* shape = (DragShape*) node->Data();
	302	delete shape;
	303	node = node->Next();
	304	}
	305	m_displayList.Clear();
	306	}
	307
	308	DragShape* MyCanvas::FindShape(const wxPoint& pt) const
	309	{
	310	wxNode* node = m_displayList.First();
	311	while (node)
	312	{
	313	DragShape* shape = (DragShape*) node->Data();
	314	if (shape->HitTest(pt))
	315	return shape;
	316	node = node->Next();
	317	}
	318	return (DragShape*) NULL;
	319	}
	320
	321	// MyFrame
68be9f09 JS	322	IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
	323
	324	BEGIN_EVENT_TABLE(MyFrame,wxFrame)
	325	EVT_MENU (wxID_ABOUT, MyFrame::OnAbout)
	326	EVT_MENU (wxID_EXIT, MyFrame::OnQuit)
	327	END_EVENT_TABLE()
	328
	329	MyFrame::MyFrame()
	330	: wxFrame( (wxFrame *)NULL, -1, "wxDragImage sample",
	331	wxPoint(20,20), wxSize(470,360) )
	332	{
	333	wxMenu *file_menu = new wxMenu();
	334	file_menu->Append( wxID_ABOUT, "&About...");
	335	file_menu->Append( TEST_USE_SCREEN, "&Use whole screen for dragging", "Use whole screen", TRUE);
	336	file_menu->Append( wxID_EXIT, "E&xit");
	337
	338	wxMenuBar *menu_bar = new wxMenuBar();
	339	menu_bar->Append(file_menu, "&File");
	340
	341	SetMenuBar( menu_bar );
	342
	343	CreateStatusBar(2);
	344	int widths[] = { -1, 100 };
	345	SetStatusWidths( 2, widths );
	346
	347	m_canvas = new MyCanvas( this, -1, wxPoint(0,0), wxSize(10,10) );
	348	}
	349
	350	void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) )
	351	{
	352	Close( TRUE );
	353	}
	354
	355	void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
	356	{
	357	(void)wxMessageBox( "wxDragImage demo\n"
	358	"Julian Smart (c) 2000",
	359	"About wxDragImage Demo", wxICON_INFORMATION \| wxOK );
	360	}
	361
	362	//-----------------------------------------------------------------------------
	363	// MyApp
	364	//-----------------------------------------------------------------------------
	365
	366	BEGIN_EVENT_TABLE(MyApp, wxApp)
	367	EVT_MENU(TEST_USE_SCREEN, MyApp::OnUseScreen)
	368	END_EVENT_TABLE()
	369
	370	MyApp::MyApp()
	371	{
	372	// Drag across whole screen
	373	m_useScreen = FALSE;
	374	}
	375
	376	bool MyApp::OnInit()
	377	{
	378	#if wxUSE_LIBPNG
	379	wxImage::AddHandler( new wxPNGHandler );
	380	#endif
	381
	382	wxImage image;
	383	if (image.LoadFile("backgrnd.png", wxBITMAP_TYPE_PNG))
	384	{
	385	m_background = image.ConvertToBitmap();
386	}
387
68be9f09 JS	388	MyFrame *frame = new MyFrame();
	389
	390	wxString rootName("shape0");
	391
	392	int i;
	393	for (i = 1; i < 4; i++)
	394	{
	395	wxString filename;
4693b20c	396	filename.Printf(wxT("%s%d.png"), (const wxChar*)rootName, i);
68be9f09 JS	397	if (image.LoadFile(filename, wxBITMAP_TYPE_PNG))
	398	{
	399	DragShape* newShape = new DragShape(image.ConvertToBitmap());
	400	newShape->SetPosition(wxPoint(i50, i50));
	401
	402	if (i == 2)
	403	newShape->SetDragMethod(SHAPE_DRAG_TEXT);
	404	else if (i == 3)
	405	newShape->SetDragMethod(SHAPE_DRAG_ICON);
	406	else
	407	newShape->SetDragMethod(SHAPE_DRAG_BITMAP);
	408	frame->GetCanvas()->GetDisplayList().Append(newShape);
	409	}
	410	}
	411
	412	#if 0
	413	// Under Motif or GTK, this demonstrates that
	414	// wxScreenDC only gets the root window content.
	415	// We need to be able to copy the overall content
	416	// for full-screen dragging to work.
	417	int w, h;
	418	wxDisplaySize(& w, & h);
	419	wxBitmap bitmap(w, h);
	420
	421	wxScreenDC dc;
	422	wxMemoryDC memDC;
	423	memDC.SelectObject(bitmap);
	424	memDC.Blit(0, 0, w, h, & dc, 0, 0);
	425	memDC.SelectObject(wxNullBitmap);
	426	m_background = bitmap;
	427	#endif
	428
	429	frame->Show( TRUE );
	430
	431	return TRUE;
	432	}
	433
0cbff120 JS	434	int MyApp::OnExit()
0cbff120 JS	435	{
0cbff120 JS	436	return 0;
	437	}
	438
68be9f09 JS	439	bool MyApp::TileBitmap(const wxRect& rect, wxDC& dc, wxBitmap& bitmap)
	440	{
	441	int w = bitmap.GetWidth();
	442	int h = bitmap.GetHeight();
	443
	444	int i, j;
	445	for (i = rect.x; i < rect.x + rect.width; i += w)
	446	{
	447	for (j = rect.y; j < rect.y + rect.height; j+= h)
	448	dc.DrawBitmap(bitmap, i, j);
	449	}
	450	return TRUE;
	451	}
	452
	453	void MyApp::OnUseScreen(wxCommandEvent& event)
	454	{
	455	m_useScreen = !m_useScreen;
	456	}
	457
	458	// DragShape
	459
	460	DragShape::DragShape(const wxBitmap& bitmap)
	461	{
	462	m_bitmap = bitmap;
	463	m_pos.x = 0;
	464	m_pos.y = 0;
	465	m_dragMethod = SHAPE_DRAG_BITMAP;
	466	m_show = TRUE;
	467	}
	468
	469	DragShape::~DragShape()
	470	{
	471	}
	472
	473	bool DragShape::HitTest(const wxPoint& pt) const
	474	{
	475	wxRect rect(GetRect());
	476	return rect.Inside(pt.x, pt.y);
	477	}
	478
	479	bool DragShape::Draw(wxDC& dc, int op)
	480	{
	481	if (m_bitmap.Ok())
	482	{
	483	wxMemoryDC memDC;
	484	memDC.SelectObject(m_bitmap);
	485
	486	dc.Blit(m_pos.x, m_pos.y, m_bitmap.GetWidth(), m_bitmap.GetHeight(),
	487	& memDC, 0, 0, op, TRUE);
	488
	489	return TRUE;
	490	}
	491	else
	492	return FALSE;
	493	}
	494