utils/dialoged/src/dlghndlr.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dlghndlr.cpp
   3 // Purpose:     Dialog handler
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx/wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25 #endif
  26
  27 #include <ctype.h>
  28 #include <stdlib.h>
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #include "reseditr.h"
  33 #include "winprop.h"
  34 #include "dlghndlr.h"
  35 #include "edlist.h"
  36
  37
  38 IMPLEMENT_CLASS(wxResourceEditorDialogHandler, wxEvtHandler)
  39 IMPLEMENT_CLASS(wxResourceEditorControlHandler, wxEvtHandler)
  40
  41 BEGIN_EVENT_TABLE(wxResourceEditorDialogHandler, wxEvtHandler)
  42 EVT_PAINT(wxResourceEditorDialogHandler::OnPaint)
  43 EVT_MOUSE_EVENTS(wxResourceEditorDialogHandler::OnMouseEvent)
  44 EVT_SIZE(wxResourceEditorDialogHandler::OnSize)
  45 EVT_MENU(OBJECT_MENU_EDIT, wxResourceEditorDialogHandler::OnObjectEdit)
  46 EVT_MENU(OBJECT_MENU_DELETE, wxResourceEditorDialogHandler::OnObjectDelete)
  47 END_EVENT_TABLE()
  48
  49 BEGIN_EVENT_TABLE(wxResourceEditorControlHandler, wxEvtHandler)
  50 EVT_MOUSE_EVENTS(wxResourceEditorControlHandler::OnMouseEvent)
  51 END_EVENT_TABLE()
  52
  53 /*
  54 * Dialog box event handler
  55 */
  56
  57 wxResourceEditorDialogHandler::wxResourceEditorDialogHandler(wxPanel *dialog, wxItemResource *resource,
  58                                                              wxEvtHandler *oldHandler, wxResourceManager *manager)
  59 {
  60     handlerDialog = dialog;
  61     handlerResource = resource;
  62     handlerOldHandler = oldHandler;
  63     resourceManager = manager;
  64
  65     dragMode = wxDRAG_MODE_NONE;
  66     dragType = wxDRAG_TYPE_NONE;
  67     dragItem = NULL;
  68     firstDragX = 0;
  69     firstDragY = 0;
  70     oldDragX = 0;
  71     oldDragY = 0;
  72     dragTolerance = 3;
  73     checkTolerance = TRUE;
  74     m_mouseCaptured = FALSE;
  75     //  m_treeItem = 0;
  76 }
  77
  78 wxResourceEditorDialogHandler::~wxResourceEditorDialogHandler(void)
  79 {
  80 }
  81
  82 void wxResourceEditorDialogHandler::OnItemSelect(wxControl *item, bool select)
  83 {
  84     if (select)
  85         resourceManager->AddSelection(item);
  86     else
  87         resourceManager->RemoveSelection(item);
  88 }
  89
  90 void wxResourceEditorDialogHandler::OnPaint(wxPaintEvent& WXUNUSED(event))
  91 {
  92     wxPaintDC dc(handlerDialog);
  93
  94     PaintSelectionHandles(dc);
  95 }
  96
  97 // Add event handlers for all children
  98 void wxResourceEditorDialogHandler::AddChildHandlers(void)
  99 {
 100     wxNode *node = handlerDialog->GetChildren().First();
 101     while ( node )
 102     {
 103         wxControl *child = (wxControl *)node->Data();
 104         wxEvtHandler *childHandler = child->GetEventHandler();
 105         if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler == child )
 106             child->PushEventHandler(new wxResourceEditorControlHandler(child, childHandler));
 107         node = node->Next();
 108     }
 109 }
 110
 111 void wxResourceEditorDialogHandler::OnLeftClick(int x, int y, int keys)
 112 {
 113     if (keys & wxKEY_CTRL)
 114     {
 115         wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
 116         return;
 117     }
 118
 119     // Deselect all items if click on panel
 120     if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
 121     {
 122         int needsRefresh = 0;
 123         wxNode *node = handlerDialog->GetChildren().First();
 124         while (node)
 125         {
 126             wxControl *item = (wxControl *)node->Data();
 127             wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 128             if (item->IsKindOf(CLASSINFO(wxControl)) && childHandler->IsSelected())
 129             {
 130                 needsRefresh ++;
 131                 OnItemSelect(item, FALSE);
 132                 childHandler->SelectItem(FALSE);
 133             }
 134             node = node->Next();
 135         }
 136         if (needsRefresh > 0)
 137         {
 138             wxClientDC dc(handlerDialog);
 139             dc.Clear();
 140             handlerDialog->Refresh();
 141         }
 142         return;
 143     }
 144
 145     // Round down to take account of dialog units
 146     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
 147     if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 148     {
 149         wxPoint pt = handlerDialog->ConvertPixelsToDialog(wxPoint(x, y));
 150
 151         // Convert back so we've rounded down
 152         pt = handlerDialog->ConvertDialogToPixels(pt);
 153         pt = handlerDialog->ConvertPixelsToDialog(pt);
 154         pt = handlerDialog->ConvertDialogToPixels(pt);
 155         x = pt.x;
 156         y = pt.y;
 157     }
 158
 159     switch (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection())
 160     {
 161     case RESED_BUTTON:
 162         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxButton", x, y);
 163         break;
 164     case RESED_BMPBUTTON:
 165         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxBitmapButton", x, y, TRUE);
 166         break;
 167     case RESED_STATICTEXT:
 168         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticText", x, y);
 169         break;
 170     case RESED_STATICBMP:
 171         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBitmap", x, y, TRUE);
 172         break;
 173     case RESED_TEXTCTRL_SINGLE:
 174         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (single-line)", x, y);
 175         break;
 176     case RESED_TEXTCTRL_MULTIPLE:
 177         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (multi-line)", x, y);
 178         break;
 179     case RESED_CHOICE:
 180         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxChoice", x, y);
 181         break;
 182     case RESED_COMBOBOX:
 183         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxComboBox", x, y);
 184         break;
 185     case RESED_CHECKBOX:
 186         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxCheckBox", x, y);
 187         break;
 188     case RESED_RADIOBOX:
 189         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioBox", x, y);
 190         break;
 191     case RESED_RADIOBUTTON:
 192         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioButton", x, y);
 193         break;
 194     case RESED_LISTBOX:
 195         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxListBox", x, y);
 196         break;
 197     case RESED_SLIDER:
 198         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxSlider", x, y);
 199         break;
 200     case RESED_GAUGE:
 201         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxGauge", x, y);
 202         break;
 203     case RESED_STATICBOX:
 204         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBox", x, y);
 205         break;
 206     case RESED_SCROLLBAR:
 207         resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxScrollBar", x, y);
 208         break;
 209     default:
 210         break;
 211     }
 212
 213     // Now switch pointer on.
 214     if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() != RESED_POINTER)
 215     {
 216         wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->SetItemState(RESED_POINTER, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
 217     }
 218 }
 219
 220 void wxResourceEditorDialogHandler::OnRightClick(int x, int y, int WXUNUSED(keys))
 221 {
 222     wxMenu *menu = resourceManager->GetPopupMenu();
 223     menu->SetClientData((char *)handlerDialog);
 224
 225     wxString str("wxDialog : ");
 226     str += handlerDialog->GetName();
 227
 228     menu->SetLabel(OBJECT_MENU_TITLE,str);
 229
 230     handlerDialog->PopupMenu(menu, x, y);
 231 }
 232
 233 void wxResourceEditorDialogHandler::OnItemLeftClick(wxControl *item, int WXUNUSED(x), int WXUNUSED(y), int keys)
 234 {
 235     if (keys & wxKEY_CTRL)
 236     {
 237         wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
 238         return;
 239     }
 240
 241     /*
 242     // If this is a wxStaticBox and the pointer isn't an arrow, chances
 243     // are that we really meant to place an item on the panel.
 244     // Fake this event.
 245     if ((item->GetClassInfo() == CLASSINFO(wxStaticBox)) && resourceManager->GetEditorPalette()->currentlySelected != PALETTE_ARROW)
 246     {
 247     OnLeftClick(x,  y, keys);
 248     return;
 249     }
 250     */
 251
 252     wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 253
 254     if (childHandler->IsSelected())
 255     {
 256         childHandler->SelectItem(FALSE);
 257         OnItemSelect(item, FALSE);
 258
 259         wxClientDC dc(handlerDialog);
 260         dc.Clear();
 261         handlerDialog->Refresh();
 262     }
 263     else
 264     {
 265         childHandler->SelectItem(TRUE);
 266         OnItemSelect(item, TRUE);
 267
 268         // Deselect other items if shift is not pressed
 269         int needsRefresh = 0;
 270         if (!(keys & wxKEY_SHIFT))
 271         {
 272             wxNode *node = item->GetParent()->GetChildren().First();
 273             while (node)
 274             {
 275                 wxControl *child = (wxControl *)node->Data();
 276                 wxResourceEditorControlHandler *childHandler2 = (wxResourceEditorControlHandler *)child->GetEventHandler();
 277                 if (child->IsKindOf(CLASSINFO(wxControl)) && childHandler2->IsSelected() && child != item)
 278                 {
 279                     childHandler2->SelectItem(FALSE);
 280                     OnItemSelect(child, FALSE);
 281                     needsRefresh ++;
 282                 }
 283                 node = node->Next();
 284             }
 285         }
 286
 287         wxClientDC dc(handlerDialog);
 288         childHandler->DrawSelectionHandles(dc);
 289
 290         if (needsRefresh > 0)
 291         {
 292             dc.Clear();
 293             handlerDialog->Refresh();
 294         }
 295     }
 296 }
 297
 298 void wxResourceEditorDialogHandler::OnItemRightClick(wxControl *item, int x, int y, int WXUNUSED(keys))
 299 {
 300 /*
 301 if (keys & wxKEY_CTRL)
 302 {
 303 wxDebugMsg("Item %s, selected = %d\n", item->GetName(), item->IsSelected());
 304 return;
 305 }
 306     */
 307
 308     wxMenu *menu = resourceManager->GetPopupMenu();
 309     menu->SetClientData((char *)item);
 310
 311     wxWindow *win = (wxWindow *)item;
 312
 313     wxWindowPropertyInfo *info = resourceManager->CreatePropertyInfoForWindow(win);
 314     if (info)
 315     {
 316         info->SetResource(resourceManager->FindResourceForWindow(win));
 317         wxString str;
 318         str = win->GetClassInfo()->GetClassName();
 319         str += " : ";
 320         if (win->GetName() != "")
 321             str += win->GetName();
 322
 323         menu->SetLabel(OBJECT_MENU_TITLE,str);
 324     }
 325
 326     handlerDialog->PopupMenu(menu, x, y);
 327 }
 328
 329 // Under Windows 95, you can resize a panel interactively depending on
 330 // window styles.
 331 void wxResourceEditorDialogHandler::OnSize(wxSizeEvent& event)
 332 {
 333     // Update the associated resource
 334     int w, h;
 335     handlerDialog->GetClientSize(& w, & h);
 336
 337     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
 338     if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 339     {
 340         wxSize sz = handlerDialog->ConvertPixelsToDialog(wxSize(w, h));
 341         w = sz.x; h = sz.y;
 342     }
 343     resource->SetSize(resource->GetX(), resource->GetY(), w, h);
 344 }
 345
 346 // An event outside any items: may be a drag event.
 347 void wxResourceEditorDialogHandler::OnMouseEvent(wxMouseEvent& event)
 348 {
 349     if (GetEvtHandlerEnabled())
 350     {
 351         // If we're dragging an item or selection handle,
 352         // continue dragging.
 353         if (dragMode != wxDRAG_MODE_NONE)
 354         {
 355             if (dragType != wxDRAG_TYPE_BOUNDING_BOX &&
 356                 dragItem != NULL)
 357             {
 358                 ProcessItemEvent(dragItem, event, dragType);
 359                 return;
 360             }
 361         }
 362
 363         wxCoord x, y;
 364         event.GetPosition(&x, &y);
 365
 366         // Find which selection handle we're on, if any
 367         wxNode *node = handlerDialog->GetChildren().First();
 368         while (node)
 369         {
 370             wxWindow *win = (wxWindow *)node->Data();
 371             if (win->IsKindOf(CLASSINFO(wxControl)))
 372             {
 373                 wxControl *item = (wxControl *)win;
 374                 wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 375                 int selHandle = childHandler->SelectionHandleHitTest(x, y);
 376                 if (selHandle > 0)
 377                 {
 378                     ProcessItemEvent(item, event, selHandle);
 379                     return;
 380                 }
 381             }
 382             node = node->Next();
 383         }
 384
 385         // We're not on an item or selection handle.
 386         // so... check for a left or right click event
 387         // to send to the application.
 388         int keys = 0;
 389         if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
 390         if (event.ControlDown()) keys = keys | wxKEY_CTRL;
 391
 392         if (node == NULL)
 393         {
 394             if (event.Dragging() &&
 395                 (dragType == wxDRAG_TYPE_BOUNDING_BOX))
 396
 397             {
 398                 if (dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 399                 {
 400                     wxClientDC dc(handlerDialog);
 401                     OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, NULL);
 402                     OnDragContinue(TRUE, x, y, keys, dc, NULL);
 403                     oldDragX = x; oldDragY = y;
 404                 }
 405 /*
 406                 else if (event.LeftUp() && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 407                 {
 408
 409                     wxClientDC dc(handlerDialog);
 410                     OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, NULL);
 411                     OnDragContinue(TRUE, x, y, keys, dc, NULL);
 412                     oldDragX = x; oldDragY = y;
 413                 }
 414 */
 415             }
 416         }
 417
 418         if (event.LeftDown())
 419         {
 420             if (!m_mouseCaptured)
 421             {
 422                 handlerDialog->CaptureMouse();
 423                 m_mouseCaptured = TRUE;
 424             }
 425
 426             // Starting to draw a bounding box around
 427             // some numbe of controls on the dialog
 428             if (node == NULL &&
 429                 wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
 430             {
 431                 dragItem = NULL;
 432                 dragMode = wxDRAG_MODE_START_LEFT;
 433                 firstDragX = x;
 434                 firstDragY = y;
 435                 dragType = wxDRAG_TYPE_BOUNDING_BOX;
 436                 wxClientDC dc(handlerDialog);
 437                 OnDragBegin(x, y, keys, dc, 0);
 438                 dragMode = wxDRAG_MODE_CONTINUE_LEFT;
 439                 oldDragX = x; oldDragY = y;
 440             }
 441
 442             event.Skip();
 443         }
 444         else if (event.LeftUp())
 445         {
 446             if (m_mouseCaptured)
 447             {
 448                 handlerDialog->ReleaseMouse();
 449                 m_mouseCaptured = FALSE;
 450             }
 451
 452             if (dragType == wxDRAG_TYPE_BOUNDING_BOX)
 453             {
 454                 // Determine the bounds of the surrounding box
 455                 int upperLeftX =  (x < firstDragX) ? x : firstDragX;
 456                 int upperLeftY =  (y < firstDragY) ? y : firstDragY;
 457                 int lowerRightX = (x > firstDragX) ? x : firstDragX;
 458                 int lowerRightY = (y > firstDragY) ? y : firstDragY;
 459
 460                 int xpos,ypos;
 461                 int width,height;
 462
 463                 bool widgetWithinBounds = FALSE;
 464
 465                 int needsRefresh = 0;
 466
 467                 wxClientDC dc(handlerDialog);
 468
 469                 // Determine what widgets which fall within the bounding box
 470                 // and select them
 471                 wxNode *node = handlerDialog->GetChildren().First();
 472                 while (node)
 473                 {
 474                     widgetWithinBounds = FALSE;
 475                     wxWindow *win = (wxWindow *)node->Data();
 476                     if (win->IsKindOf(CLASSINFO(wxControl)))
 477                     {
 478                         wxControl *item = (wxControl *)win;
 479                         wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 480
 481                         // Unselect all widgets that are currently selected
 482                         if (!(keys & wxKEY_SHIFT) && childHandler->IsSelected())
 483                         {
 484                             needsRefresh ++;
 485                             OnItemSelect(item, FALSE);
 486                             childHandler->SelectItem(FALSE);
 487                         }
 488
 489                         // Get X,Y and WIDTH,HEIGHT of the widget to be able
 490                         // to determine if any portion of it is within the bounded
 491                         // area
 492                         childHandler->handlerControl->GetPosition(&xpos, &ypos);
 493                         childHandler->handlerControl->GetSize(&width, &height);
 494
 495                         // Check if the current widget is inside the rectangle
 496                         // that was just bounded
 497                         if (xpos >= upperLeftX && xpos <= lowerRightX)
 498                         {
 499                             if (ypos >= upperLeftY && ypos <= lowerRightY)
 500                                 widgetWithinBounds = TRUE;
 501                             else if (ypos+height >= upperLeftY && ypos+height <= lowerRightY)
 502                                 widgetWithinBounds = TRUE;
 503                         }
 504                         else if (xpos+width >= upperLeftX && xpos <= lowerRightX)
 505                         {
 506                             if (ypos >= upperLeftY && ypos <= lowerRightY)
 507                                 widgetWithinBounds = TRUE;
 508                             else if (ypos+height >= upperLeftY && ypos+height <= lowerRightY)
 509                                 widgetWithinBounds = TRUE;
 510                         }
 511
 512                         if (widgetWithinBounds)
 513                         {
 514                             childHandler->SelectItem(TRUE);
 515                             OnItemSelect(item, TRUE);
 516
 517 //                            childHandler->DrawSelectionHandles(dc);
 518                         }
 519
 520                     }
 521                     node = node->Next();
 522                 }
 523
 524                 OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, NULL);
 525                 OnDragEnd(x, y, keys, dc, NULL);
 526
 527                 if (needsRefresh > 0)
 528                 {
 529                     dc.Clear();
 530                     handlerDialog->Refresh();
 531                 }
 532
 533                 // Always paint, in case the bounding box overlapped with
 534                 // the handles of any selected widgets, that way when the
 535                 // bounding box is cleared, the handles don't get partially
 536                 // erased where the overlap occured
 537                 PaintSelectionHandles(dc);
 538
 539                 dragMode = wxDRAG_MODE_NONE;
 540                 checkTolerance = TRUE;
 541                 dragItem = NULL;
 542                 dragType = wxDRAG_TYPE_NONE;
 543             }
 544             else
 545                 OnLeftClick(x, y, keys);
 546         }
 547         else if (event.RightDown())
 548         {
 549             if (m_mouseCaptured)
 550             {
 551                 handlerDialog->ReleaseMouse();
 552                 m_mouseCaptured = FALSE;
 553             }
 554
 555             OnRightClick(x, y, keys);
 556         }
 557         else if (event.LeftDClick())
 558         {
 559             if (m_mouseCaptured)
 560             {
 561                 handlerDialog->ReleaseMouse();
 562                 m_mouseCaptured = FALSE;
 563             }
 564             wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
 565         }
 566     }
 567     else
 568         event.Skip();
 569 }
 570
 571 void wxResourceEditorDialogHandler::OnItemEvent(wxControl *item, wxMouseEvent& event)
 572 {
 573     if (!GetEvtHandlerEnabled())
 574         return;
 575
 576     // Not a selection handle event: just a normal item event.
 577     // Transform to panel coordinates.
 578     wxCoord x, y;
 579     item->GetPosition(&x, &y);
 580
 581     event.m_x = event.m_x + x;
 582     event.m_y = event.m_y + y;
 583
 584     ProcessItemEvent(item, event, dragType);
 585 }
 586
 587 void wxResourceEditorDialogHandler::ProcessItemEvent(wxControl *item, wxMouseEvent& event, int selectionHandle)
 588 {
 589     wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 590
 591     wxCoord x, y;
 592     event.GetPosition(&x, &y);
 593     int keys = 0;
 594     if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
 595     if (event.ControlDown()) keys = keys | wxKEY_CTRL;
 596     bool dragging = event.Dragging();
 597
 598     if (dragging)
 599     {
 600         int dx = (int)abs((x - firstDragX));
 601         int dy = (int)abs((y - firstDragY));
 602         if (checkTolerance && (dx <= dragTolerance) && (dy <= dragTolerance))
 603         {
 604             return;
 605         }
 606         else
 607             // If we've ignored the tolerance once, then ALWAYS ignore
 608             // tolerance in this drag, even if we come back within
 609             // the tolerance range.
 610         {
 611             checkTolerance = FALSE;
 612         }
 613     }
 614     if (event.LeftDClick())
 615     {
 616         if (m_mouseCaptured)
 617         {
 618             handlerDialog->ReleaseMouse();
 619             m_mouseCaptured = FALSE;
 620         }
 621
 622         wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
 623     }
 624     else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_LEFT)
 625     {
 626         dragMode = wxDRAG_MODE_CONTINUE_LEFT;
 627         wxClientDC dc(handlerDialog);
 628         childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
 629         oldDragX = x; oldDragY = y;
 630         if (!m_mouseCaptured)
 631         {
 632             handlerDialog->CaptureMouse();
 633             m_mouseCaptured = TRUE;
 634         }
 635     }
 636     else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 637     {
 638         wxClientDC dc(handlerDialog);
 639         childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
 640         childHandler->OnDragContinue(TRUE, x, y, keys, dc, selectionHandle);
 641         oldDragX = x; oldDragY = y;
 642     }
 643     else if (event.LeftUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 644     {
 645         wxClientDC dc(handlerDialog);
 646         dragMode = wxDRAG_MODE_NONE;
 647         checkTolerance = TRUE;
 648
 649         childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
 650         childHandler->OnDragEnd(x, y, keys, dc, selectionHandle);
 651
 652         dragItem = NULL;
 653         dragType = wxDRAG_TYPE_NONE;
 654
 655         if (m_mouseCaptured)
 656         {
 657             handlerDialog->ReleaseMouse();
 658             m_mouseCaptured = FALSE;
 659         }
 660     }
 661     else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_RIGHT)
 662     {
 663         wxClientDC dc(handlerDialog);
 664         dragMode = wxDRAG_MODE_CONTINUE_RIGHT;
 665         childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
 666         oldDragX = x; oldDragY = y;
 667
 668         if (!m_mouseCaptured)
 669         {
 670             handlerDialog->CaptureMouse();
 671             m_mouseCaptured = TRUE;
 672         }
 673     }
 674     else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
 675     {
 676         oldDragX = x; oldDragY = y;
 677     }
 678     // Obsolete; no longer try to right-drag
 679     else if (event.RightUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
 680     {
 681         dragMode = wxDRAG_MODE_NONE;
 682         checkTolerance = TRUE;
 683         dragItem = NULL;
 684         dragType = wxDRAG_TYPE_NONE;
 685
 686         if (m_mouseCaptured)
 687         {
 688             handlerDialog->ReleaseMouse();
 689             m_mouseCaptured = FALSE;
 690         }
 691     }
 692     else if (event.IsButton())
 693     {
 694         checkTolerance = TRUE;
 695
 696         if (event.LeftDown())
 697         {
 698             dragItem = item;
 699             dragMode = wxDRAG_MODE_START_LEFT;
 700             firstDragX = x;
 701             firstDragY = y;
 702             dragType = selectionHandle;
 703
 704             if (!m_mouseCaptured)
 705             {
 706                 handlerDialog->CaptureMouse();
 707                 m_mouseCaptured = TRUE;
 708             }
 709         }
 710         else if (event.RightDown())
 711         {
 712             if (m_mouseCaptured)
 713             {
 714                 handlerDialog->ReleaseMouse();
 715                 m_mouseCaptured = FALSE;
 716             }
 717
 718             if (item)
 719                 childHandler->OnRightClick(x, y, keys);
 720             else
 721                 OnRightClick(x, y, keys);
 722
 723             dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 724
 725             /*
 726             dragItem = item;
 727             dragMode = wxDRAG_MODE_START_RIGHT;
 728             firstDragX = x;
 729             firstDragY = y;
 730             dragType = selectionHandle;
 731
 732               if (!m_mouseCaptured)
 733               {
 734               handlerDialog->CaptureMouse();
 735               m_mouseCaptured = TRUE;
 736               }
 737             */
 738         }
 739         else if (event.LeftUp())
 740         {
 741             if (dragItem)
 742                 childHandler->OnLeftClick(x, y, keys);
 743             else
 744                 OnLeftClick(x, y, keys);
 745
 746             dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 747
 748             if (m_mouseCaptured)
 749             {
 750                 handlerDialog->ReleaseMouse();
 751                 m_mouseCaptured = FALSE;
 752             }
 753         }
 754         else if (event.RightUp())
 755         {
 756         /*
 757         if (dragItem)
 758         childHandler->OnRightClick(x, y, keys);
 759         else
 760         OnRightClick(x, y, keys);
 761
 762           dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 763
 764             if (m_mouseCaptured)
 765             {
 766             handlerDialog->ReleaseMouse();
 767             m_mouseCaptured = FALSE;
 768             }
 769             */
 770         }
 771     }
 772 }
 773
 774 // Calls DrawSelectionHandles for all items if
 775 // edit mode is on.
 776 void wxResourceEditorDialogHandler::PaintSelectionHandles(wxDC& dc)
 777 {
 778     if (!GetEvtHandlerEnabled())
 779         return;
 780
 781     dc.BeginDrawing();
 782
 783     wxNode *node = handlerDialog->GetChildren().First();
 784     while (node)
 785     {
 786         wxWindow *win = (wxWindow *)node->Data();
 787         if (win->IsKindOf(CLASSINFO(wxControl)))
 788         {
 789             wxControl *item = (wxControl *)win;
 790             wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 791
 792             // Don't draw handles for an item that's being moved: it'll
 793             // smear.
 794             if (childHandler->IsSelected() && (item != dragItem))
 795                 childHandler->DrawSelectionHandles(dc);
 796         }
 797         node = node->Next();
 798     }
 799     dc.EndDrawing();
 800 }
 801
 802
 803
 804 void wxResourceEditorDialogHandler::DrawBoundingBox(wxDC& dc, int x, int y, int w, int h)
 805 {
 806     dc.DrawRectangle(x, y, w, h);
 807 }
 808
 809
 810 void wxResourceEditorDialogHandler::OnDragBegin(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 811 {
 812 /*
 813     dc.BeginDrawing();
 814
 815     dc.SetOptimization(FALSE);
 816
 817     dc.SetLogicalFunction(wxINVERT);
 818
 819     wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
 820     dc.SetPen(pen);
 821     dc.SetBrush(* wxTRANSPARENT_BRUSH);
 822
 823     dc.SetOptimization(TRUE);
 824
 825 //    Refresh();
 826 //    DrawBoundingBox(dc, xpos, ypos, width, height);
 827
 828     dc.EndDrawing();
 829 */
 830 }  //wxResourceEditorDialogHandler::OnDragBegin()
 831
 832
 833 void wxResourceEditorDialogHandler::OnDragContinue(bool WXUNUSED(paintIt), int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 834 {
 835     int upperLeftX =  (x < firstDragX) ? x : firstDragX;
 836     int upperLeftY =  (y < firstDragY) ? y : firstDragY;
 837     int lowerRightX = (x > firstDragX) ? x : firstDragX;
 838     int lowerRightY = (y > firstDragY) ? y : firstDragY;
 839
 840     dc.BeginDrawing();
 841     dc.SetLogicalFunction(wxINVERT);
 842     wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
 843     dc.SetPen(pen);
 844     dc.SetBrush(* wxTRANSPARENT_BRUSH);
 845
 846     DrawBoundingBox(dc, (int)upperLeftX, upperLeftY,
 847                     lowerRightX-upperLeftX, lowerRightY-upperLeftY);
 848
 849     dc.EndDrawing();
 850
 851 }  // wxResourceEditorDialogHandler::OnDragContinue()
 852
 853
 854 void wxResourceEditorDialogHandler::OnDragEnd(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 855 {
 856 /*
 857     dc.BeginDrawing();
 858
 859     dc.SetOptimization(FALSE);
 860
 861     dc.SetLogicalFunction(wxCOPY);
 862     dc.SetPen(* wxBLACK_PEN);
 863     dc.SetBrush(* wxBLACK_BRUSH);
 864
 865     dc.SetOptimization(TRUE);
 866
 867     dc.EndDrawing();
 868 */
 869
 870 }  // wxResourceEditorDialogHandler::OnDragEnd()
 871
 872 void wxResourceEditorDialogHandler::OnObjectEdit(wxCommandEvent& event)
 873 {
 874         wxMenu* menu = (wxMenu*) event.GetEventObject();
 875
 876     wxWindow *data = (wxWindow *)menu->GetClientData();
 877     if (!data)
 878         return;
 879
 880     wxResourceManager::GetCurrentResourceManager()->EditWindow(data);
 881 }
 882
 883 void wxResourceEditorDialogHandler::OnObjectDelete(wxCommandEvent& event)
 884 {
 885         wxMenu* menu = (wxMenu*) event.GetEventObject();
 886
 887     wxWindow *data = (wxWindow *)menu->GetClientData();
 888     if (!data)
 889         return;
 890
 891         // Before deleting a dialog, give the user a last chance
 892         // change their mind, in case they accidentally right
 893         // clicked the dialog rather than the widget they were
 894         // aiming for.
 895         if (data->IsKindOf(CLASSINFO(wxPanel)))
 896         {
 897                 wxString str(wxT("Deleting dialog : "));
 898                 str += data->GetName();
 899                 if (wxMessageBox(wxT("Are you sure?"), str, wxYES_NO | wxCENTRE) == wxNO)
 900                         return;
 901         }
 902
 903         wxResourceManager::GetCurrentResourceManager()->DeselectItemIfNecessary(data);
 904
 905         wxResourceManager::GetCurrentResourceManager()->SaveInfoAndDeleteHandler(data);
 906         wxResourceManager::GetCurrentResourceManager()->DeleteResource(data);
 907         wxResourceManager::GetCurrentResourceManager()->DeleteWindow(data);
 908 }
 909
 910
 911
 912 /*
 913 * Event handler for controls
 914 */
 915
 916 int wxResourceEditorControlHandler::dragOffsetX = 0;
 917 int wxResourceEditorControlHandler::dragOffsetY = 0;
 918
 919 wxResourceEditorControlHandler::wxResourceEditorControlHandler(wxControl *control,
 920                                                                wxEvtHandler *oldHandler)
 921 {
 922     handlerControl = control;
 923     handlerOldHandler = oldHandler;
 924
 925     handleSize = 6;
 926     handleMargin = 1;
 927     isSelected = FALSE;
 928     dragOffsetX = 0;
 929     dragOffsetY = 0;
 930     //  m_treeItem = 0;
 931 }
 932
 933 wxResourceEditorControlHandler::~wxResourceEditorControlHandler(void)
 934 {
 935 }
 936
 937 /*
 938 * Manipulation and drawing of items in Edit Mode
 939 */
 940
 941 void wxResourceEditorControlHandler::SelectItem(bool select)
 942 {
 943     isSelected = select;
 944 }
 945
 946 // Returns TRUE or FALSE
 947 bool wxResourceEditorControlHandler::HitTest(int x, int y)
 948 {
 949     int xpos, ypos, width, height;
 950     handlerControl->GetPosition(&xpos, &ypos);
 951     handlerControl->GetSize(&width, &height);
 952
 953     return ((x >= xpos) && (x <= (xpos + width)) && (y >= ypos) && (y <= (ypos + height)));
 954 }
 955
 956 // Calculate position of the 8 handles
 957 void wxResourceEditorControlHandler::CalcSelectionHandles(int *hx, int *hy)
 958 {
 959     int xpos, ypos, width, height;
 960     handlerControl->GetPosition(&xpos, &ypos);
 961     handlerControl->GetSize(&width, &height);
 962     int middleX = (xpos + (width/2));
 963     int middleY = (ypos + (height/2));
 964
 965     // Start from top middle, clockwise.
 966     /*
 967     7      0      1
 968
 969       6             2
 970
 971         5      4      3
 972     */
 973
 974     hx[0] = (int)(middleX - (handleSize/2));
 975     hy[0] = ypos - handleSize - handleMargin;
 976
 977     hx[1] = xpos + width + handleMargin;
 978     hy[1] = ypos - handleSize - handleMargin;
 979
 980     hx[2] = xpos + width + handleMargin;
 981     hy[2] = (int)(middleY - (handleSize/2));
 982
 983     hx[3] = xpos + width + handleMargin;
 984     hy[3] = ypos + height + handleMargin;
 985
 986     hx[4] = (int)(middleX - (handleSize/2));
 987     hy[4] = ypos + height + handleMargin;
 988
 989     hx[5] = xpos - handleSize - handleMargin;
 990     hy[5] = ypos + height + handleMargin;
 991
 992     hx[6] = xpos - handleSize - handleMargin;
 993     hy[6] = (int)(middleY - (handleSize/2));
 994
 995     hx[7] = xpos - handleSize - handleMargin;
 996     hy[7] = ypos - handleSize - handleMargin;
 997 }
 998
 999 // Returns 0 (no hit), 1 - 8 for which selection handle
1000 // (clockwise from top middle)
1001 int wxResourceEditorControlHandler::SelectionHandleHitTest(int x, int y)
1002 {
1003     // Handle positions
1004     int hx[8];
1005     int hy[8];
1006     CalcSelectionHandles(hx, hy);
1007
1008     int i;
1009     for (i = 0; i < 8; i++)
1010     {
1011         if ((x >= hx[i]) && (x <= (hx[i] + handleSize)) && (y >= hy[i]) && (y <= (hy[i] + handleSize)))
1012             return (i + 1);
1013     }
1014     return 0;
1015 }
1016
1017 void wxResourceEditorControlHandler::DrawSelectionHandles(wxDC& dc, bool WXUNUSED(erase))
1018 {
1019     dc.SetOptimization(FALSE);
1020
1021     dc.SetLogicalFunction(wxCOPY);
1022     dc.SetPen(* wxBLACK_PEN);
1023     dc.SetBrush(* wxBLACK_BRUSH);
1024
1025     dc.SetOptimization(TRUE);
1026
1027     // Handle positions
1028     int hx[8];
1029     int hy[8];
1030     CalcSelectionHandles(hx, hy);
1031
1032     int i;
1033     for (i = 0; i < 8; i++)
1034     {
1035         dc.DrawRectangle(hx[i], hy[i], handleSize, handleSize);
1036     }
1037 }
1038
1039 void wxResourceEditorControlHandler::DrawBoundingBox(wxDC& dc, int x, int y, int w, int h)
1040 {
1041     dc.DrawRectangle(x, y, w, h);
1042 }
1043
1044 // If selectionHandle is zero, not dragging the selection handle.
1045 void wxResourceEditorControlHandler::OnDragBegin(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
1046 {
1047     int xpos, ypos, width, height;
1048     handlerControl->GetPosition(&xpos, &ypos);
1049     handlerControl->GetSize(&width, &height);
1050
1051     dc.BeginDrawing();
1052
1053     //  dc.DestroyClippingRegion();
1054
1055     wxPanel *panel = (wxPanel *)handlerControl->GetParent();
1056
1057     // Erase selection handles
1058     //  DrawSelectionHandles(dc, TRUE);
1059
1060     dc.SetOptimization(FALSE);
1061
1062     dc.SetLogicalFunction(wxINVERT);
1063
1064     wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
1065     dc.SetPen(pen);
1066     dc.SetBrush(* wxTRANSPARENT_BRUSH);
1067
1068     dc.SetOptimization(TRUE);
1069
1070     if (selectionHandle > 0)
1071     {
1072         panel->Refresh();
1073
1074         DrawBoundingBox(dc, xpos, ypos, width, height);
1075     }
1076     else
1077     {
1078         panel->Refresh();
1079
1080         dragOffsetX = (x - xpos);
1081         dragOffsetY = (y - ypos);
1082
1083         DrawBoundingBox(dc, xpos, ypos, width, height);
1084
1085         // Also draw bounding boxes for other selected items
1086         wxNode *node = panel->GetChildren().First();
1087         while (node)
1088         {
1089             wxWindow *win = (wxWindow *)node->Data();
1090             if (win->IsKindOf(CLASSINFO(wxControl)))
1091             {
1092                 wxControl *item = (wxControl *)win;
1093                 wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1094                 if ((item != handlerControl) && handler->IsSelected())
1095                 {
1096                     int x1, y1, w1, h1;
1097                     item->GetPosition(&x1, &y1);
1098                     item->GetSize(&w1, &h1);
1099                     handler->DrawBoundingBox(dc, x1, y1, w1, h1);
1100                 }
1101             }
1102             node = node->Next();
1103         }
1104     }
1105     dc.EndDrawing();
1106 }
1107
1108 void wxResourceEditorControlHandler::OnDragContinue(bool WXUNUSED(paintIt), int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
1109 {
1110     wxPanel *panel = (wxPanel *)handlerControl->GetParent();
1111     int xpos, ypos, width, height;
1112     handlerControl->GetPosition(&xpos, &ypos);
1113     handlerControl->GetSize(&width, &height);
1114
1115     if (selectionHandle > 0)
1116     {
1117     /*
1118     8      1      2
1119
1120       7             3
1121
1122         6      5      4
1123         */
1124
1125         int x1, y1, width1, height1;
1126
1127         switch (selectionHandle)
1128         {
1129         case 1:
1130             x1 = xpos;
1131             y1 = y;
1132             width1 = width;
1133             height1 = (ypos + height) - y;
1134             break;
1135         case 5:
1136             x1 = xpos;
1137             y1 = ypos;
1138             width1 = width;
1139             height1 = (y - ypos);
1140             break;
1141         case 3:
1142             x1 = xpos;
1143             y1 = ypos;
1144             width1 = (x - xpos);
1145             height1 = height;
1146             break;
1147         case 7:
1148             x1 = x;
1149             y1 = ypos;
1150             width1 = (xpos + width) - x;
1151             height1 = height;
1152             break;
1153         case 2:
1154             x1 = xpos;
1155             y1 = y;
1156             width1 = (x - xpos);
1157             height1 = (ypos + height) - y;
1158             break;
1159         case 4:
1160             x1 = xpos;
1161             y1 = ypos;
1162             width1 = (x - xpos);
1163             height1 = (y - ypos);
1164             break;
1165         case 6:
1166             x1 = x;
1167             y1 = ypos;
1168             width1 = (xpos + width) - x;
1169             height1 = y - ypos;
1170             break;
1171         case 8:
1172             x1 = x;
1173             y1 = y;
1174             width1 = (xpos + width) - x;
1175             height1 = (ypos + height) - y;
1176             break;
1177         }
1178         dc.BeginDrawing();
1179
1180         dc.SetLogicalFunction(wxINVERT);
1181         wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
1182         dc.SetPen(pen);
1183         dc.SetBrush(* wxTRANSPARENT_BRUSH);
1184
1185         DrawBoundingBox(dc, x1, y1, width1, height1);
1186
1187         dc.EndDrawing();
1188     }
1189     else
1190     {
1191         dc.BeginDrawing();
1192         dc.SetLogicalFunction(wxINVERT);
1193         wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
1194         dc.SetPen(pen);
1195         dc.SetBrush(* wxTRANSPARENT_BRUSH);
1196
1197         DrawBoundingBox(dc, (int)(x - dragOffsetX), (int)(y - dragOffsetY), width, height);
1198
1199         // Also draw bounding boxes for other selected items
1200         wxNode *node = panel->GetChildren().First();
1201         while (node)
1202         {
1203             wxWindow *win = (wxWindow *)node->Data();
1204             if (win->IsKindOf(CLASSINFO(wxControl)))
1205             {
1206                 wxControl *item = (wxControl *)win;
1207                 wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1208                 if ((item != handlerControl) && handler->IsSelected())
1209                 {
1210                     int x1, y1, w1, h1;
1211                     item->GetPosition(&x1, &y1);
1212                     item->GetSize(&w1, &h1);
1213                     int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
1214                     int y2 = (int)(y1 + (y - dragOffsetY) - ypos);
1215                     handler->DrawBoundingBox(dc, x2, y2, w1, h1);
1216                 }
1217             }
1218             node = node->Next();
1219         }
1220         dc.EndDrawing();
1221     }
1222 }
1223
1224 void wxResourceEditorControlHandler::OnDragEnd(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
1225 {
1226     wxPanel *panel = (wxPanel *)handlerControl->GetParent();
1227
1228     dc.BeginDrawing();
1229
1230     int xpos, ypos, width, height;
1231     handlerControl->GetPosition(&xpos, &ypos);
1232     handlerControl->GetSize(&width, &height);
1233
1234     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl);
1235     wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl->GetParent());
1236
1237     if (selectionHandle > 0)
1238     {
1239         int x1, y1, width1, height1;
1240
1241         switch (selectionHandle)
1242         {
1243         case 1:
1244             x1 = xpos;
1245             y1 = y;
1246             width1 = width;
1247             height1 = (ypos + height) - y;
1248             break;
1249         case 5:
1250             x1 = xpos;
1251             y1 = ypos;
1252             width1 = width;
1253             height1 = (y - ypos);
1254             break;
1255         case 3:
1256             x1 = xpos;
1257             y1 = ypos;
1258             width1 = (x - xpos);
1259             height1 = height;
1260             break;
1261         case 7:
1262             x1 = x;
1263             y1 = ypos;
1264             width1 = (xpos + width) - x;
1265             height1 = height;
1266             break;
1267         case 2:
1268             x1 = xpos;
1269             y1 = y;
1270             width1 = (x - xpos);
1271             height1 = (ypos + height) - y;
1272             break;
1273         case 4:
1274             x1 = xpos;
1275             y1 = ypos;
1276             width1 = (x - xpos);
1277             height1 = (y - ypos);
1278             break;
1279         case 6:
1280             x1 = x;
1281             y1 = ypos;
1282             width1 = (xpos + width) - x;
1283             height1 = y - ypos;
1284             break;
1285         case 8:
1286             x1 = x;
1287             y1 = y;
1288             width1 = (xpos + width) - x;
1289             height1 = (ypos + height) - y;
1290             break;
1291         }
1292         // Update the associated resource
1293         // We need to convert to dialog units if this is not a dialog or panel, but
1294         // the parent resource specifies dialog units.
1295         int resourceX = x1;
1296         int resourceY = y1;
1297         int resourceWidth = width1;
1298         int resourceHeight = height1;
1299
1300         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1301         {
1302             wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(x1, y1));
1303             wxSize sz = handlerControl->GetParent()->ConvertPixelsToDialog(wxSize(width1, height1));
1304
1305             // Convert back so we've rounded down
1306             sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
1307             sz = handlerControl->GetParent()->ConvertPixelsToDialog(sz);
1308             resourceWidth = sz.x; resourceHeight = sz.y;
1309
1310             sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
1311             width1 = sz.x;
1312             height1 = sz.y;
1313
1314             pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1315             pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
1316             resourceX = pt.x; resourceY = pt.y;
1317
1318             pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1319             x1 = pt.x;
1320             y1 = pt.y;
1321         }
1322         handlerControl->SetSize(x1, y1, width1, height1);
1323         resource->SetSize(resourceX, resourceY, resourceWidth, resourceHeight);
1324     }
1325     else
1326     {
1327         // Correction 31/12/98. We need to round down the values to take into account
1328         // the fact that several pixels map to the same dialog unit.
1329
1330         int newX = (int)(x - dragOffsetX);
1331         int newY = (int)(y - dragOffsetY);
1332         int resourceX = newX;
1333         int resourceY = newY;
1334
1335         // Update the associated resource
1336         if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1337         {
1338             wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(newX, newY));
1339             pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1340             pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
1341             resourceX = pt.x; resourceY = pt.y;
1342             pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1343
1344             // Having converted it several times, we know it'll map to dialog units exactly.
1345             newX = pt.x;
1346             newY = pt.y;
1347         }
1348         handlerControl->Move(newX, newY);
1349         OldOnMove(newX, newY);
1350
1351         resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());
1352
1353         // Also move other selected items
1354         wxNode *node = panel->GetChildren().First();
1355         while (node)
1356         {
1357             wxWindow *win = (wxWindow *)node->Data();
1358             if (win->IsKindOf(CLASSINFO(wxControl)))
1359             {
1360                 wxControl *item = (wxControl *)win;
1361                 wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1362                 if ((item != handlerControl) && handler->IsSelected())
1363                 {
1364                     int x1, y1;
1365                     item->GetPosition(&x1, &y1);
1366                     int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
1367                     int y2 = (int)(y1 + (y - dragOffsetY) - ypos);
1368
1369                     resourceX = x2;
1370                     resourceY = y2;
1371
1372                     // Update the associated resource
1373                     resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
1374                     if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1375                     {
1376                         wxPoint pt = item->GetParent()->ConvertPixelsToDialog(wxPoint(x2, y2));
1377                         pt = item->GetParent()->ConvertDialogToPixels(pt);
1378                         pt = item->GetParent()->ConvertPixelsToDialog(pt);
1379
1380                         resourceX = pt.x; resourceY = pt.y;
1381                         pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1382
1383                         // Having converted it several times, we know it'll map to dialog units exactly
1384                         x2 = pt.x;
1385                         y2 = pt.y;
1386                     }
1387
1388                     item->Move(x2, y2);
1389                     ((wxResourceEditorControlHandler *)item->GetEventHandler())->OldOnMove(x2, y2);
1390                     ((wxResourceEditorControlHandler *)item->GetEventHandler())->DrawSelectionHandles(dc);
1391
1392                     resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());
1393
1394                 }
1395             }
1396             node = node->Next();
1397         }
1398     }
1399     dc.SetOptimization(FALSE);
1400
1401     dc.SetLogicalFunction(wxCOPY);
1402     dc.SetPen(* wxBLACK_PEN);
1403     dc.SetBrush(* wxBLACK_BRUSH);
1404
1405     dc.SetOptimization(TRUE);
1406
1407     // Force it to repaint the selection handles (if any)
1408     // since the panel thinks we're still within a drag and
1409     // won't paint the handles.
1410     if (IsSelected())
1411         DrawSelectionHandles(dc);
1412
1413     dc.EndDrawing();
1414
1415     panel->Refresh();
1416 }
1417
1418 // These functions call OnItemEvent, OnItemMove and OnItemSize
1419 // by default.
1420 void wxResourceEditorControlHandler::OnMouseEvent(wxMouseEvent& event)
1421 {
1422 /*
1423 if ((event.m_eventType == wxEVENT_TYPE_LEFT_DCLICK) ||
1424 (event.m_eventType == wxEVENT_TYPE_RIGHT_DCLICK))
1425 return;
1426     */
1427     wxWindow *panel = handlerControl->GetParent();
1428     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1429         return;
1430     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1431     if ( !panelHandler->GetEvtHandlerEnabled() )
1432     {
1433         event.Skip();
1434         return;
1435     }
1436
1437     panelHandler->OnItemEvent(handlerControl, event);
1438 }
1439
1440 void wxResourceEditorControlHandler::OldOnMove(int x, int y)
1441 {
1442     wxWindow *panel = handlerControl->GetParent();
1443     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1444         return;
1445
1446     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1447     panelHandler->OnItemMove(handlerControl, x, y);
1448 }
1449
1450 void wxResourceEditorControlHandler::OldOnSize(int w, int h)
1451 {
1452     wxWindow *panel = handlerControl->GetParent();
1453     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1454         return;
1455
1456     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1457     panelHandler->OnItemSize(handlerControl, w, h);
1458 }
1459
1460 void wxResourceEditorControlHandler::OnSelect(bool select)
1461 {
1462     wxWindow *panel = handlerControl->GetParent();
1463     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1464         return;
1465
1466     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1467     panelHandler->OnItemSelect(handlerControl, select);
1468 }
1469
1470 void wxResourceEditorControlHandler::OnLeftClick(int x, int y, int keys)
1471 {
1472     wxWindow *panel = handlerControl->GetParent();
1473     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1474         return;
1475
1476     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1477     panelHandler->OnItemLeftClick(handlerControl, x, y, keys);
1478 }
1479
1480 void wxResourceEditorControlHandler::OnRightClick(int x, int y, int keys)
1481 {
1482     wxWindow *panel = handlerControl->GetParent();
1483     if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1484         return;
1485
1486     wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1487     panelHandler->OnItemRightClick(handlerControl, x, y, keys);
1488 }
1489
1490