Reenabled OSS support

[wxWidgets.git] / utils / dialoged / src / dlghndlr.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dlghndlr.cpp
// Purpose:     Dialog handler
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation
#endif

// 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 <ctype.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "reseditr.h"
#include "winprop.h"
#include "dlghndlr.h"
#include "edlist.h"

IMPLEMENT_CLASS(wxResourceEditorDialogHandler, wxEvtHandler)
IMPLEMENT_CLASS(wxResourceEditorControlHandler, wxEvtHandler)

BEGIN_EVENT_TABLE(wxResourceEditorDialogHandler, wxEvtHandler)
	EVT_PAINT(wxResourceEditorDialogHandler::OnPaint)
	EVT_MOUSE_EVENTS(wxResourceEditorDialogHandler::OnMouseEvent)
	EVT_SIZE(wxResourceEditorDialogHandler::OnSize)
END_EVENT_TABLE()

BEGIN_EVENT_TABLE(wxResourceEditorControlHandler, wxEvtHandler)
	EVT_MOUSE_EVENTS(wxResourceEditorControlHandler::OnMouseEvent)
END_EVENT_TABLE()

/*
 * Dialog box event handler
 */

wxResourceEditorDialogHandler::wxResourceEditorDialogHandler(wxPanel *dialog, wxItemResource *resource,
   wxEvtHandler *oldHandler, wxResourceManager *manager)
{
  handlerDialog = dialog;
  handlerResource = resource;
  handlerOldHandler = oldHandler;
  resourceManager = manager;

  dragMode = wxDRAG_MODE_NONE;
  dragType = wxDRAG_TYPE_NONE;
  dragItem = NULL;
  firstDragX = 0;
  firstDragY = 0;
  oldDragX = 0;
  oldDragY = 0;
  dragTolerance = 3;
  checkTolerance = TRUE;
  m_mouseCaptured = FALSE;
//  m_treeItem = 0;
}

wxResourceEditorDialogHandler::~wxResourceEditorDialogHandler(void)
{
}

void wxResourceEditorDialogHandler::OnItemSelect(wxControl *item, bool select)
{
  if (select)
    resourceManager->AddSelection(item);
  else
    resourceManager->RemoveSelection(item);
}

void wxResourceEditorDialogHandler::OnPaint(wxPaintEvent& WXUNUSED(event))
{
	wxPaintDC dc(handlerDialog);

	PaintSelectionHandles(dc);
}

// Add event handlers for all children
void wxResourceEditorDialogHandler::AddChildHandlers(void)
{
  wxNode *node = handlerDialog->GetChildren().First();
  while ( node )
  {
	wxControl *child = (wxControl *)node->Data();
	wxEvtHandler *childHandler = child->GetEventHandler();
	if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler == child )
		child->PushEventHandler(new wxResourceEditorControlHandler(child, childHandler));
	node = node->Next();
  }
}

void wxResourceEditorDialogHandler::OnLeftClick(int x, int y, int keys)
{
  if (keys & wxKEY_CTRL)
  {
    wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
    return;
  }

  // Deselect all items if click on panel
  if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
  {
    int needsRefresh = 0;
    wxNode *node = handlerDialog->GetChildren().First();
    while (node)
    {
      wxControl *item = (wxControl *)node->Data();
	  wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
      if (item->IsKindOf(CLASSINFO(wxControl)) && childHandler->IsSelected())
      {
        needsRefresh ++;
        OnItemSelect(item, FALSE);
        childHandler->SelectItem(FALSE);
      }
      node = node->Next();
    }
    if (needsRefresh > 0)
    {
	  wxClientDC dc(handlerDialog);
      dc.Clear();
      handlerDialog->Refresh();
    }
    return;
  }

  // Round down to take account of dialog units
  wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
  if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
  {
        wxPoint pt = handlerDialog->ConvertPixelsToDialog(wxPoint(x, y));

        // Convert back so we've rounded down
        pt = handlerDialog->ConvertDialogToPixels(pt);
        pt = handlerDialog->ConvertPixelsToDialog(pt);
        pt = handlerDialog->ConvertDialogToPixels(pt);
        x = pt.x;
        y = pt.y;
  }

  switch (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection())
  {
        case RESED_BUTTON:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxButton", x, y);
          break;
        case RESED_BMPBUTTON:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxBitmapButton", x, y, TRUE);
          break;
        case RESED_STATICTEXT:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticText", x, y);
          break;
        case RESED_STATICBMP:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBitmap", x, y, TRUE);
          break;
        case RESED_TEXTCTRL_SINGLE:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (single-line)", x, y);
          break;
        case RESED_TEXTCTRL_MULTIPLE:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (multi-line)", x, y);
          break;
        case RESED_CHOICE:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxChoice", x, y);
          break;
        case RESED_COMBOBOX:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxComboBox", x, y);
          break;
        case RESED_CHECKBOX:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxCheckBox", x, y);
          break;
        case RESED_RADIOBOX:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioBox", x, y);
          break;
        case RESED_RADIOBUTTON:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioButton", x, y);
          break;
        case RESED_LISTBOX:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxListBox", x, y);
          break;
        case RESED_SLIDER:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxSlider", x, y);
          break;
        case RESED_GAUGE:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxGauge", x, y);
          break;
        case RESED_STATICBOX:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBox", x, y);
          break;
        case RESED_SCROLLBAR:
          resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxScrollBar", x, y);
          break;
        default:
          break;
  }

  // Now switch pointer on.
  if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() != RESED_POINTER)
  {
    wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->SetItemState(RESED_POINTER, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
  }
}

void wxResourceEditorDialogHandler::OnRightClick(int x, int y, int WXUNUSED(keys))
{
  wxMenu *menu = resourceManager->GetPopupMenu();
  menu->SetClientData((char *)handlerDialog);
  handlerDialog->PopupMenu(menu, x, y);
}

void wxResourceEditorDialogHandler::OnItemLeftClick(wxControl *item, int WXUNUSED(x), int WXUNUSED(y), int keys)
{
  if (keys & wxKEY_CTRL)
  {
    wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
    return;
  }

/*
  // If this is a wxStaticBox and the pointer isn't an arrow, chances
  // are that we really meant to place an item on the panel.
  // Fake this event.
  if ((item->GetClassInfo() == CLASSINFO(wxStaticBox)) && resourceManager->GetEditorPalette()->currentlySelected != PALETTE_ARROW)
  {
    OnLeftClick(x,  y, keys);
    return;
  }
*/
  
  wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();

  if (childHandler->IsSelected())
  {
    childHandler->SelectItem(FALSE);
    OnItemSelect(item, FALSE);

    wxClientDC dc(handlerDialog);
    dc.Clear();
    handlerDialog->Refresh();
  }
  else
  {
    childHandler->SelectItem(TRUE);
    OnItemSelect(item, TRUE);
    
    // Deselect other items if shift is not pressed
    int needsRefresh = 0;
    if (!(keys & wxKEY_SHIFT))
    {
      wxNode *node = item->GetParent()->GetChildren().First();
      while (node)
      {
        wxControl *child = (wxControl *)node->Data();
        wxResourceEditorControlHandler *childHandler2 = (wxResourceEditorControlHandler *)child->GetEventHandler();
        if (child->IsKindOf(CLASSINFO(wxControl)) && childHandler2->IsSelected() && child != item)
        {
          childHandler2->SelectItem(FALSE);
          OnItemSelect(child, FALSE);
          needsRefresh ++;
        }
        node = node->Next();
      }
    }

    wxClientDC dc(handlerDialog);
    childHandler->DrawSelectionHandles(dc);

    if (needsRefresh > 0)
    {
      dc.Clear();
      handlerDialog->Refresh();
    }
  }
}

void wxResourceEditorDialogHandler::OnItemRightClick(wxControl *item, int x, int y, int WXUNUSED(keys))
{
/*
  if (keys & wxKEY_CTRL)
  {
    wxDebugMsg("Item %s, selected = %d\n", item->GetName(), item->IsSelected());
    return;
  }
*/

  wxMenu *menu = resourceManager->GetPopupMenu();
  menu->SetClientData((char *)item);
  handlerDialog->PopupMenu(menu, x, y);
}

// Under Windows 95, you can resize a panel interactively depending on
// window styles.
void wxResourceEditorDialogHandler::OnSize(wxSizeEvent& event)
{
    // Update the associated resource
    int w, h;
    handlerDialog->GetClientSize(& w, & h);

    wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
    if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
    {
        wxSize sz = handlerDialog->ConvertPixelsToDialog(wxSize(w, h));
        w = sz.x; h = sz.y;
    }
    resource->SetSize(resource->GetX(), resource->GetY(), w, h);
}

// An event outside any items: may be a drag event.
void wxResourceEditorDialogHandler::OnMouseEvent(wxMouseEvent& event)
{
  if (GetEvtHandlerEnabled())
  {
    // If we're dragging an item or selection handle,
    // continue dragging.
    if (dragMode != wxDRAG_MODE_NONE)
    {
      ProcessItemEvent(dragItem, event, dragType);
      return;
    }
  
    wxCoord x, y;
    event.GetPosition(&x, &y);

    // Find which selection handle we're on, if any
    wxNode *node = handlerDialog->GetChildren().First();
    while (node)
    {
      wxWindow *win = (wxWindow *)node->Data();
      if (win->IsKindOf(CLASSINFO(wxControl)))
      {
        wxControl *item = (wxControl *)win;
        wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
        int selHandle = childHandler->SelectionHandleHitTest(x, y);
        if (selHandle > 0)
        {
          ProcessItemEvent(item, event, selHandle);
          return;
        }
      }
      node = node->Next();
    }

    // We're not on an item or selection handle.
    // so... check for a left or right click event
    // to send to the application.
    int keys = 0;
    if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
    if (event.ControlDown()) keys = keys | wxKEY_CTRL;

    if (event.LeftUp())
    {
        if (m_mouseCaptured)
        {
            handlerDialog->ReleaseMouse();
            m_mouseCaptured = FALSE;
        }

        OnLeftClick(x, y, keys);
    }
    else if (event.RightDown())
    {
        if (m_mouseCaptured)
        {
            handlerDialog->ReleaseMouse();
            m_mouseCaptured = FALSE;
        }

        OnRightClick(x, y, keys);
    }
    else if (event.LeftDClick())
    {
        if (m_mouseCaptured)
        {
            handlerDialog->ReleaseMouse();
            m_mouseCaptured = FALSE;
        }
        wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
    }
  }
  else
	event.Skip();
}

void wxResourceEditorDialogHandler::OnItemEvent(wxControl *item, wxMouseEvent& event)
{
  if (!GetEvtHandlerEnabled())
    return;

  // Not a selection handle event: just a normal item event.
  // Transform to panel coordinates.
  wxCoord x, y;
  item->GetPosition(&x, &y);

  event.m_x = event.m_x + x;
  event.m_y = event.m_y + y;
  
  ProcessItemEvent(item, event, dragType);
}

void wxResourceEditorDialogHandler::ProcessItemEvent(wxControl *item, wxMouseEvent& event, int selectionHandle)
{
  wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
  
  wxCoord x, y;
  event.GetPosition(&x, &y);
  int keys = 0;
  if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
  if (event.ControlDown()) keys = keys | wxKEY_CTRL;
  bool dragging = event.Dragging();
  if (dragging)
  {
    int dx = (int)abs((x - firstDragX));
    int dy = (int)abs((y - firstDragY));
    if (checkTolerance && (dx <= dragTolerance) && (dy <= dragTolerance))
    {
      return;
    }
    else
      // If we've ignored the tolerance once, then ALWAYS ignore
      // tolerance in this drag, even if we come back within
      // the tolerance range.
      {
        checkTolerance = FALSE;
      }
  }
  if (event.LeftDClick())
  {
      if (m_mouseCaptured)
      {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
      }

      wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
  }
  else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_LEFT)
  {
    dragMode = wxDRAG_MODE_CONTINUE_LEFT;
	wxClientDC dc(handlerDialog);
    childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
    oldDragX = x; oldDragY = y;
    if (!m_mouseCaptured)
    {
        handlerDialog->CaptureMouse();
        m_mouseCaptured = TRUE;
    }
  }
  else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
  { 
	wxClientDC dc(handlerDialog);
    childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
    childHandler->OnDragContinue(TRUE, x, y, keys, dc, selectionHandle);
    oldDragX = x; oldDragY = y;
  }
  else if (event.LeftUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
  {
	wxClientDC dc(handlerDialog);
    dragMode = wxDRAG_MODE_NONE;
    checkTolerance = TRUE;

    childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
    childHandler->OnDragEnd(x, y, keys, dc, selectionHandle);

    dragItem = NULL;
    dragType = wxDRAG_TYPE_NONE;

    if (m_mouseCaptured)
    {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
    }
  }
  else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_RIGHT)
  {
	wxClientDC dc(handlerDialog);
    dragMode = wxDRAG_MODE_CONTINUE_RIGHT;
    childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
    oldDragX = x; oldDragY = y;

    if (!m_mouseCaptured)
    {
        handlerDialog->CaptureMouse();
        m_mouseCaptured = TRUE;
    }
  }
  else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
  { 
    oldDragX = x; oldDragY = y;
  }
  // Obsolete; no longer try to right-drag
  else if (event.RightUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
  {
    dragMode = wxDRAG_MODE_NONE;
    checkTolerance = TRUE;
    dragItem = NULL;
    dragType = wxDRAG_TYPE_NONE;

    if (m_mouseCaptured)
    {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
    }
  }
  else if (event.IsButton())
  {
    checkTolerance = TRUE;

    if (event.LeftDown())
    {
      dragItem = item;
      dragMode = wxDRAG_MODE_START_LEFT;
      firstDragX = x;
      firstDragY = y;
      dragType = selectionHandle;

      if (!m_mouseCaptured)
      {
        handlerDialog->CaptureMouse();
        m_mouseCaptured = TRUE;
      }
    }
    else if (event.RightDown())
    {
      if (m_mouseCaptured)
      {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
      }

      if (item)
        childHandler->OnRightClick(x, y, keys);
      else
        OnRightClick(x, y, keys);

      dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;

      /*
      dragItem = item;
      dragMode = wxDRAG_MODE_START_RIGHT;
      firstDragX = x;
      firstDragY = y;
      dragType = selectionHandle;

      if (!m_mouseCaptured)
      {
        handlerDialog->CaptureMouse();
        m_mouseCaptured = TRUE;
      }
      */
    }
    else if (event.LeftUp())
    {
      if (dragItem)
        childHandler->OnLeftClick(x, y, keys);
      else
        OnLeftClick(x, y, keys);

      dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;

      if (m_mouseCaptured)
      {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
      }
    }
    else if (event.RightUp())
    {
      /*
      if (dragItem)
        childHandler->OnRightClick(x, y, keys);
      else
        OnRightClick(x, y, keys);

      dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;

      if (m_mouseCaptured)
      {
        handlerDialog->ReleaseMouse();
        m_mouseCaptured = FALSE;
      }
      */
    }
  }
}

// Calls DrawSelectionHandles for all items if
// edit mode is on.
void wxResourceEditorDialogHandler::PaintSelectionHandles(wxDC& dc)
{
  if (!GetEvtHandlerEnabled())
    return;

  dc.BeginDrawing();

  wxNode *node = handlerDialog->GetChildren().First();
  while (node)
  {
    wxWindow *win = (wxWindow *)node->Data();
    if (win->IsKindOf(CLASSINFO(wxControl)))
    {
      wxControl *item = (wxControl *)win;
      wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();

      // Don't draw handles for an item that's being moved: it'll
      // smear.
      if (childHandler->IsSelected() && (item != dragItem))
        childHandler->DrawSelectionHandles(dc);
    }
    node = node->Next();
  }
  dc.EndDrawing();
}

/*
 * Event handler for controls
 */

int wxResourceEditorControlHandler::dragOffsetX = 0;
int wxResourceEditorControlHandler::dragOffsetY = 0;

wxResourceEditorControlHandler::wxResourceEditorControlHandler(wxControl *control,
   wxEvtHandler *oldHandler)
{
  handlerControl = control;
  handlerOldHandler = oldHandler;

  handleSize = 6;
  handleMargin = 1;
  isSelected = FALSE;
  dragOffsetX = 0;
  dragOffsetY = 0;
//  m_treeItem = 0;
}

wxResourceEditorControlHandler::~wxResourceEditorControlHandler(void)
{
}

/*
 * Manipulation and drawing of items in Edit Mode
 */
 
void wxResourceEditorControlHandler::SelectItem(bool select)
{
  isSelected = select;
}

// Returns TRUE or FALSE
bool wxResourceEditorControlHandler::HitTest(int x, int y)
{
  int xpos, ypos, width, height;
  handlerControl->GetPosition(&xpos, &ypos);
  handlerControl->GetSize(&width, &height);

  return ((x >= xpos) && (x <= (xpos + width)) && (y >= ypos) && (y <= (ypos + height)));
}

// Calculate position of the 8 handles
void wxResourceEditorControlHandler::CalcSelectionHandles(int *hx, int *hy)
{
  int xpos, ypos, width, height;
  handlerControl->GetPosition(&xpos, &ypos);
  handlerControl->GetSize(&width, &height);
  int middleX = (xpos + (width/2));
  int middleY = (ypos + (height/2));

  // Start from top middle, clockwise.
/*
  7      0      1

  6             2

  5      4      3
*/

  hx[0] = (int)(middleX - (handleSize/2));
  hy[0] = ypos - handleSize - handleMargin;

  hx[1] = xpos + width + handleMargin;
  hy[1] = ypos - handleSize - handleMargin;

  hx[2] = xpos + width + handleMargin;
  hy[2] = (int)(middleY - (handleSize/2));

  hx[3] = xpos + width + handleMargin;
  hy[3] = ypos + height + handleMargin;

  hx[4] = (int)(middleX - (handleSize/2));
  hy[4] = ypos + height + handleMargin;

  hx[5] = xpos - handleSize - handleMargin;
  hy[5] = ypos + height + handleMargin;

  hx[6] = xpos - handleSize - handleMargin;
  hy[6] = (int)(middleY - (handleSize/2));

  hx[7] = xpos - handleSize - handleMargin;
  hy[7] = ypos - handleSize - handleMargin;
}

// Returns 0 (no hit), 1 - 8 for which selection handle
// (clockwise from top middle)
int wxResourceEditorControlHandler::SelectionHandleHitTest(int x, int y)
{
  // Handle positions
  int hx[8];
  int hy[8];
  CalcSelectionHandles(hx, hy);

  int i;
  for (i = 0; i < 8; i++)
  {
    if ((x >= hx[i]) && (x <= (hx[i] + handleSize)) && (y >= hy[i]) && (y <= (hy[i] + handleSize)))
      return (i + 1);
  }
  return 0;
}

void wxResourceEditorControlHandler::DrawSelectionHandles(wxDC& dc, bool WXUNUSED(erase))
{
  dc.SetOptimization(FALSE);

  dc.SetLogicalFunction(wxCOPY);
  dc.SetPen(* wxBLACK_PEN);
  dc.SetBrush(* wxBLACK_BRUSH);

  dc.SetOptimization(TRUE);

  // Handle positions
  int hx[8];
  int hy[8];
  CalcSelectionHandles(hx, hy);

  int i;
  for (i = 0; i < 8; i++)
  {
    dc.DrawRectangle(hx[i], hy[i], handleSize, handleSize);
  }
}

void wxResourceEditorControlHandler::DrawBoundingBox(wxDC& dc, int x, int y, int w, int h)
{
  dc.DrawRectangle(x, y, w, h);
}

// If selectionHandle is zero, not dragging the selection handle.
void wxResourceEditorControlHandler::OnDragBegin(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
{
  int xpos, ypos, width, height;
  handlerControl->GetPosition(&xpos, &ypos);
  handlerControl->GetSize(&width, &height);

  dc.BeginDrawing();

//  dc.DestroyClippingRegion();

  wxPanel *panel = (wxPanel *)handlerControl->GetParent();

  // Erase selection handles
//  DrawSelectionHandles(dc, TRUE);

  dc.SetOptimization(FALSE);

  dc.SetLogicalFunction(wxINVERT);

  wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
  dc.SetPen(pen);
  dc.SetBrush(* wxTRANSPARENT_BRUSH);

  dc.SetOptimization(TRUE);

  if (selectionHandle > 0)
  {
    panel->Refresh();

    DrawBoundingBox(dc, xpos, ypos, width, height);
  }
  else
  {
    panel->Refresh();

    dragOffsetX = (x - xpos);
    dragOffsetY = (y - ypos);

      DrawBoundingBox(dc, xpos, ypos, width, height);

      // Also draw bounding boxes for other selected items
      wxNode *node = panel->GetChildren().First();
      while (node)
      {
        wxWindow *win = (wxWindow *)node->Data();
        if (win->IsKindOf(CLASSINFO(wxControl)))
        {
          wxControl *item = (wxControl *)win;
		  wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
          if ((item != handlerControl) && handler->IsSelected())
          {
            int x1, y1, w1, h1;
            item->GetPosition(&x1, &y1);
            item->GetSize(&w1, &h1);
            handler->DrawBoundingBox(dc, x1, y1, w1, h1);
          }
        }
        node = node->Next();
      }
  }
  dc.EndDrawing();
}

void wxResourceEditorControlHandler::OnDragContinue(bool WXUNUSED(paintIt), int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
{
  wxPanel *panel = (wxPanel *)handlerControl->GetParent();
  int xpos, ypos, width, height;
  handlerControl->GetPosition(&xpos, &ypos);
  handlerControl->GetSize(&width, &height);
  
  if (selectionHandle > 0)
  {
/*
  8      1      2

  7             3

  6      5      4
*/

    int x1, y1, width1, height1;
  
    switch (selectionHandle)
    {
      case 1:
        x1 = xpos;
        y1 = y;
        width1 = width;
        height1 = (ypos + height) - y;
        break;
      case 5:
        x1 = xpos;
        y1 = ypos;
        width1 = width;
        height1 = (y - ypos);
        break;
      case 3:
        x1 = xpos;
        y1 = ypos;
        width1 = (x - xpos);
        height1 = height;
        break;
      case 7:
        x1 = x;
        y1 = ypos;
        width1 = (xpos + width) - x;
        height1 = height;
        break;
      case 2:
        x1 = xpos;
        y1 = y;
        width1 = (x - xpos);
        height1 = (ypos + height) - y;
        break;
      case 4:
        x1 = xpos;
        y1 = ypos;
        width1 = (x - xpos);
        height1 = (y - ypos);
        break;
      case 6:
        x1 = x;
        y1 = ypos;
        width1 = (xpos + width) - x;
        height1 = y - ypos;
        break;
      case 8:
        x1 = x;
        y1 = y;
        width1 = (xpos + width) - x;
        height1 = (ypos + height) - y;
        break;
    }
    dc.BeginDrawing();

    dc.SetLogicalFunction(wxINVERT);
    wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
    dc.SetPen(pen);
    dc.SetBrush(* wxTRANSPARENT_BRUSH);

    DrawBoundingBox(dc, x1, y1, width1, height1);

    dc.EndDrawing();
  }
  else
  {
      dc.BeginDrawing();
      dc.SetLogicalFunction(wxINVERT);
      wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
      dc.SetPen(pen);
      dc.SetBrush(* wxTRANSPARENT_BRUSH);

      DrawBoundingBox(dc, (int)(x - dragOffsetX), (int)(y - dragOffsetY), width, height);

      // Also draw bounding boxes for other selected items
      wxNode *node = panel->GetChildren().First();
      while (node)
      {
        wxWindow *win = (wxWindow *)node->Data();
        if (win->IsKindOf(CLASSINFO(wxControl)))
        {
          wxControl *item = (wxControl *)win;
		  wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
          if ((item != handlerControl) && handler->IsSelected())
          {
            int x1, y1, w1, h1;
            item->GetPosition(&x1, &y1);
            item->GetSize(&w1, &h1);
            int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
            int y2 = (int)(y1 + (y - dragOffsetY) - ypos);
            handler->DrawBoundingBox(dc, x2, y2, w1, h1);
          }
        }
        node = node->Next();
      }
      dc.EndDrawing();
  }
}

void wxResourceEditorControlHandler::OnDragEnd(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
{
  wxPanel *panel = (wxPanel *)handlerControl->GetParent();

  dc.BeginDrawing();

  int xpos, ypos, width, height;
  handlerControl->GetPosition(&xpos, &ypos);
  handlerControl->GetSize(&width, &height);

  wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl);
  wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl->GetParent());

  if (selectionHandle > 0)
  {
    int x1, y1, width1, height1;
  
    switch (selectionHandle)
    {
      case 1:
        x1 = xpos;
        y1 = y;
        width1 = width;
        height1 = (ypos + height) - y;
        break;
      case 5:
        x1 = xpos;
        y1 = ypos;
        width1 = width;
        height1 = (y - ypos);
        break;
      case 3:
        x1 = xpos;
        y1 = ypos;
        width1 = (x - xpos);
        height1 = height;
        break;
      case 7:
        x1 = x;
        y1 = ypos;
        width1 = (xpos + width) - x;
        height1 = height;
        break;
      case 2:
        x1 = xpos;
        y1 = y;
        width1 = (x - xpos);
        height1 = (ypos + height) - y;
        break;
      case 4:
        x1 = xpos;
        y1 = ypos;
        width1 = (x - xpos);
        height1 = (y - ypos);
        break;
      case 6:
        x1 = x;
        y1 = ypos;
        width1 = (xpos + width) - x;
        height1 = y - ypos;
        break;
      case 8:
        x1 = x;
        y1 = y;
        width1 = (xpos + width) - x;
        height1 = (ypos + height) - y;
        break;
    }
    // Update the associated resource
    // We need to convert to dialog units if this is not a dialog or panel, but
    // the parent resource specifies dialog units.
    int resourceX = x1;
    int resourceY = y1;
    int resourceWidth = width1;
    int resourceHeight = height1;

    if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
    {
        wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(x1, y1));
        wxSize sz = handlerControl->GetParent()->ConvertPixelsToDialog(wxSize(width1, height1));

        // Convert back so we've rounded down
        sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
        sz = handlerControl->GetParent()->ConvertPixelsToDialog(sz);
        resourceWidth = sz.x; resourceHeight = sz.y;

        sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
        width1 = sz.x;
        height1 = sz.y;

        pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
        pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
        resourceX = pt.x; resourceY = pt.y;

        pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
        x1 = pt.x;
        y1 = pt.y;
    }
    handlerControl->SetSize(x1, y1, width1, height1);
    resource->SetSize(resourceX, resourceY, resourceWidth, resourceHeight);
  }
  else
  {
    // Correction 31/12/98. We need to round down the values to take into account
    // the fact that several pixels map to the same dialog unit.

    int newX = (int)(x - dragOffsetX);
    int newY = (int)(y - dragOffsetY);
    int resourceX = newX;
    int resourceY = newY;

    // Update the associated resource
    if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
    {
        wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(newX, newY));
        pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
        pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
        resourceX = pt.x; resourceY = pt.y;
        pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);

        // Having converted it several times, we know it'll map to dialog units exactly.
        newX = pt.x;
        newY = pt.y;
    }
    handlerControl->Move(newX, newY);
    OldOnMove(newX, newY);

    resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());

    // Also move other selected items
    wxNode *node = panel->GetChildren().First();
    while (node)
    {
      wxWindow *win = (wxWindow *)node->Data();
      if (win->IsKindOf(CLASSINFO(wxControl)))
      {
        wxControl *item = (wxControl *)win;
        wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
        if ((item != handlerControl) && handler->IsSelected())
        {
          int x1, y1;
          item->GetPosition(&x1, &y1);
          int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
          int y2 = (int)(y1 + (y - dragOffsetY) - ypos);

          // Update the associated resource
          resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
          if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
          {
            wxPoint pt = item->GetParent()->ConvertPixelsToDialog(wxPoint(x2, y2));
            pt = item->GetParent()->ConvertDialogToPixels(pt);
            pt = item->GetParent()->ConvertPixelsToDialog(pt);

            resourceX = pt.x; resourceY = pt.y;
            pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);

            // Having converted it several times, we know it'll map to dialog units exactly
            x2 = pt.x;
            y2 = pt.y;
          }

          item->Move(x2, y2);
          ((wxResourceEditorControlHandler *)item->GetEventHandler())->OldOnMove(x2, y2);
          ((wxResourceEditorControlHandler *)item->GetEventHandler())->DrawSelectionHandles(dc);

          resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());

        }
      }
      node = node->Next();
    }
  }
  dc.SetOptimization(FALSE);

  dc.SetLogicalFunction(wxCOPY);
  dc.SetPen(* wxBLACK_PEN);
  dc.SetBrush(* wxBLACK_BRUSH);

  dc.SetOptimization(TRUE);

  // Force it to repaint the selection handles (if any)
  // since the panel thinks we're still within a drag and
  // won't paint the handles.
  if (IsSelected())
    DrawSelectionHandles(dc);

  dc.EndDrawing();

  panel->Refresh();
}

// These functions call OnItemEvent, OnItemMove and OnItemSize
// by default.
void wxResourceEditorControlHandler::OnMouseEvent(wxMouseEvent& event)
{
/*
  if ((event.m_eventType == wxEVENT_TYPE_LEFT_DCLICK) ||
      (event.m_eventType == wxEVENT_TYPE_RIGHT_DCLICK))
    return;
*/
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;
  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  if ( !panelHandler->GetEvtHandlerEnabled() )
  {
	event.Skip();
	return;
  }
    
  panelHandler->OnItemEvent(handlerControl, event);
}

void wxResourceEditorControlHandler::OldOnMove(int x, int y)
{
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;

  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  panelHandler->OnItemMove(handlerControl, x, y);
}

void wxResourceEditorControlHandler::OldOnSize(int w, int h)
{
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;

  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  panelHandler->OnItemSize(handlerControl, w, h);
}

void wxResourceEditorControlHandler::OnSelect(bool select)
{
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;

  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  panelHandler->OnItemSelect(handlerControl, select);
}

void wxResourceEditorControlHandler::OnLeftClick(int x, int y, int keys)
{
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;

  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  panelHandler->OnItemLeftClick(handlerControl, x, y, keys);
}

void wxResourceEditorControlHandler::OnRightClick(int x, int y, int keys)
{
  wxWindow *panel = handlerControl->GetParent();
  if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
	return;

  wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
  panelHandler->OnItemRightClick(handlerControl, x, y, keys);
}