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 IMPLEMENT_CLASS(wxResourceEditorDialogHandler, wxEvtHandler)
  38 IMPLEMENT_CLASS(wxResourceEditorControlHandler, wxEvtHandler)
  39
  40 BEGIN_EVENT_TABLE(wxResourceEditorDialogHandler, wxEvtHandler)
  41         EVT_PAINT(wxResourceEditorDialogHandler::OnPaint)
  42         EVT_MOUSE_EVENTS(wxResourceEditorDialogHandler::OnMouseEvent)
  43         EVT_SIZE(wxResourceEditorDialogHandler::OnSize)
  44 END_EVENT_TABLE()
  45
  46 BEGIN_EVENT_TABLE(wxResourceEditorControlHandler, wxEvtHandler)
  47         EVT_MOUSE_EVENTS(wxResourceEditorControlHandler::OnMouseEvent)
  48 END_EVENT_TABLE()
  49
  50 /*
  51  * Dialog box event handler
  52  */
  53
  54 wxResourceEditorDialogHandler::wxResourceEditorDialogHandler(wxPanel *dialog, wxItemResource *resource,
  55    wxEvtHandler *oldHandler, wxResourceManager *manager)
  56 {
  57   handlerDialog = dialog;
  58   handlerResource = resource;
  59   handlerOldHandler = oldHandler;
  60   resourceManager = manager;
  61
  62   dragMode = wxDRAG_MODE_NONE;
  63   dragType = wxDRAG_TYPE_NONE;
  64   dragItem = NULL;
  65   firstDragX = 0;
  66   firstDragY = 0;
  67   oldDragX = 0;
  68   oldDragY = 0;
  69   dragTolerance = 3;
  70   checkTolerance = TRUE;
  71   m_mouseCaptured = FALSE;
  72 //  m_treeItem = 0;
  73 }
  74
  75 wxResourceEditorDialogHandler::~wxResourceEditorDialogHandler(void)
  76 {
  77 }
  78
  79 void wxResourceEditorDialogHandler::OnItemSelect(wxControl *item, bool select)
  80 {
  81   if (select)
  82     resourceManager->AddSelection(item);
  83   else
  84     resourceManager->RemoveSelection(item);
  85 }
  86
  87 void wxResourceEditorDialogHandler::OnPaint(wxPaintEvent& WXUNUSED(event))
  88 {
  89         wxPaintDC dc(handlerDialog);
  90
  91         PaintSelectionHandles(dc);
  92 }
  93
  94 // Add event handlers for all children
  95 void wxResourceEditorDialogHandler::AddChildHandlers(void)
  96 {
  97   wxNode *node = handlerDialog->GetChildren().First();
  98   while ( node )
  99   {
 100         wxControl *child = (wxControl *)node->Data();
 101         wxEvtHandler *childHandler = child->GetEventHandler();
 102         if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler == child )
 103                 child->PushEventHandler(new wxResourceEditorControlHandler(child, childHandler));
 104         node = node->Next();
 105   }
 106 }
 107
 108 void wxResourceEditorDialogHandler::OnLeftClick(int x, int y, int keys)
 109 {
 110   if (keys & wxKEY_CTRL)
 111   {
 112     wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
 113     return;
 114   }
 115
 116   // Deselect all items if click on panel
 117   if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
 118   {
 119     int needsRefresh = 0;
 120     wxNode *node = handlerDialog->GetChildren().First();
 121     while (node)
 122     {
 123       wxControl *item = (wxControl *)node->Data();
 124           wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 125       if (item->IsKindOf(CLASSINFO(wxControl)) && childHandler->IsSelected())
 126       {
 127         needsRefresh ++;
 128         OnItemSelect(item, FALSE);
 129         childHandler->SelectItem(FALSE);
 130       }
 131       node = node->Next();
 132     }
 133     if (needsRefresh > 0)
 134     {
 135           wxClientDC dc(handlerDialog);
 136       dc.Clear();
 137       handlerDialog->Refresh();
 138     }
 139     return;
 140   }
 141
 142   // Round down to take account of dialog units
 143   wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
 144   if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 145   {
 146         wxPoint pt = handlerDialog->ConvertPixelsToDialog(wxPoint(x, y));
 147
 148         // Convert back so we've rounded down
 149         pt = handlerDialog->ConvertDialogToPixels(pt);
 150         pt = handlerDialog->ConvertPixelsToDialog(pt);
 151         pt = handlerDialog->ConvertDialogToPixels(pt);
 152         x = pt.x;
 153         y = pt.y;
 154   }
 155
 156   switch (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection())
 157   {
 158         case RESED_BUTTON:
 159           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxButton", x, y);
 160           break;
 161         case RESED_BMPBUTTON:
 162           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxBitmapButton", x, y, TRUE);
 163           break;
 164         case RESED_STATICTEXT:
 165           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticText", x, y);
 166           break;
 167         case RESED_STATICBMP:
 168           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBitmap", x, y, TRUE);
 169           break;
 170         case RESED_TEXTCTRL_SINGLE:
 171           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (single-line)", x, y);
 172           break;
 173         case RESED_TEXTCTRL_MULTIPLE:
 174           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (multi-line)", x, y);
 175           break;
 176         case RESED_CHOICE:
 177           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxChoice", x, y);
 178           break;
 179         case RESED_COMBOBOX:
 180           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxComboBox", x, y);
 181           break;
 182         case RESED_CHECKBOX:
 183           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxCheckBox", x, y);
 184           break;
 185         case RESED_RADIOBOX:
 186           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioBox", x, y);
 187           break;
 188         case RESED_RADIOBUTTON:
 189           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioButton", x, y);
 190           break;
 191         case RESED_LISTBOX:
 192           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxListBox", x, y);
 193           break;
 194         case RESED_SLIDER:
 195           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxSlider", x, y);
 196           break;
 197         case RESED_GAUGE:
 198           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxGauge", x, y);
 199           break;
 200         case RESED_STATICBOX:
 201           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBox", x, y);
 202           break;
 203         case RESED_SCROLLBAR:
 204           resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxScrollBar", x, y);
 205           break;
 206         default:
 207           break;
 208   }
 209
 210   // Now switch pointer on.
 211   if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() != RESED_POINTER)
 212   {
 213     wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->SetItemState(RESED_POINTER, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
 214   }
 215 }
 216
 217 void wxResourceEditorDialogHandler::OnRightClick(int x, int y, int WXUNUSED(keys))
 218 {
 219   wxMenu *menu = resourceManager->GetPopupMenu();
 220   menu->SetClientData((char *)handlerDialog);
 221   handlerDialog->PopupMenu(menu, x, y);
 222 }
 223
 224 void wxResourceEditorDialogHandler::OnItemLeftClick(wxControl *item, int WXUNUSED(x), int WXUNUSED(y), int keys)
 225 {
 226   if (keys & wxKEY_CTRL)
 227   {
 228     wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
 229     return;
 230   }
 231
 232 /*
 233   // If this is a wxStaticBox and the pointer isn't an arrow, chances
 234   // are that we really meant to place an item on the panel.
 235   // Fake this event.
 236   if ((item->GetClassInfo() == CLASSINFO(wxStaticBox)) && resourceManager->GetEditorPalette()->currentlySelected != PALETTE_ARROW)
 237   {
 238     OnLeftClick(x,  y, keys);
 239     return;
 240   }
 241 */
 242
 243   wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 244
 245   if (childHandler->IsSelected())
 246   {
 247     childHandler->SelectItem(FALSE);
 248     OnItemSelect(item, FALSE);
 249
 250     wxClientDC dc(handlerDialog);
 251     dc.Clear();
 252     handlerDialog->Refresh();
 253   }
 254   else
 255   {
 256     childHandler->SelectItem(TRUE);
 257     OnItemSelect(item, TRUE);
 258
 259     // Deselect other items if shift is not pressed
 260     int needsRefresh = 0;
 261     if (!(keys & wxKEY_SHIFT))
 262     {
 263       wxNode *node = item->GetParent()->GetChildren().First();
 264       while (node)
 265       {
 266         wxControl *child = (wxControl *)node->Data();
 267         wxResourceEditorControlHandler *childHandler2 = (wxResourceEditorControlHandler *)child->GetEventHandler();
 268         if (child->IsKindOf(CLASSINFO(wxControl)) && childHandler2->IsSelected() && child != item)
 269         {
 270           childHandler2->SelectItem(FALSE);
 271           OnItemSelect(child, FALSE);
 272           needsRefresh ++;
 273         }
 274         node = node->Next();
 275       }
 276     }
 277
 278     wxClientDC dc(handlerDialog);
 279     childHandler->DrawSelectionHandles(dc);
 280
 281     if (needsRefresh > 0)
 282     {
 283       dc.Clear();
 284       handlerDialog->Refresh();
 285     }
 286   }
 287 }
 288
 289 void wxResourceEditorDialogHandler::OnItemRightClick(wxControl *item, int x, int y, int WXUNUSED(keys))
 290 {
 291 /*
 292   if (keys & wxKEY_CTRL)
 293   {
 294     wxDebugMsg("Item %s, selected = %d\n", item->GetName(), item->IsSelected());
 295     return;
 296   }
 297 */
 298
 299   wxMenu *menu = resourceManager->GetPopupMenu();
 300   menu->SetClientData((char *)item);
 301   handlerDialog->PopupMenu(menu, x, y);
 302 }
 303
 304 // Under Windows 95, you can resize a panel interactively depending on
 305 // window styles.
 306 void wxResourceEditorDialogHandler::OnSize(wxSizeEvent& event)
 307 {
 308     // Update the associated resource
 309     int w, h;
 310     handlerDialog->GetClientSize(& w, & h);
 311
 312     wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerDialog);
 313     if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
 314     {
 315         wxSize sz = handlerDialog->ConvertPixelsToDialog(wxSize(w, h));
 316         w = sz.x; h = sz.y;
 317     }
 318     resource->SetSize(resource->GetX(), resource->GetY(), w, h);
 319 }
 320
 321 // An event outside any items: may be a drag event.
 322 void wxResourceEditorDialogHandler::OnMouseEvent(wxMouseEvent& event)
 323 {
 324   if (GetEvtHandlerEnabled())
 325   {
 326     // If we're dragging an item or selection handle,
 327     // continue dragging.
 328     if (dragMode != wxDRAG_MODE_NONE)
 329     {
 330       ProcessItemEvent(dragItem, event, dragType);
 331       return;
 332     }
 333
 334     wxCoord x, y;
 335     event.GetPosition(&x, &y);
 336
 337     // Find which selection handle we're on, if any
 338     wxNode *node = handlerDialog->GetChildren().First();
 339     while (node)
 340     {
 341       wxWindow *win = (wxWindow *)node->Data();
 342       if (win->IsKindOf(CLASSINFO(wxControl)))
 343       {
 344         wxControl *item = (wxControl *)win;
 345         wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 346         int selHandle = childHandler->SelectionHandleHitTest(x, y);
 347         if (selHandle > 0)
 348         {
 349           ProcessItemEvent(item, event, selHandle);
 350           return;
 351         }
 352       }
 353       node = node->Next();
 354     }
 355
 356     // We're not on an item or selection handle.
 357     // so... check for a left or right click event
 358     // to send to the application.
 359     int keys = 0;
 360     if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
 361     if (event.ControlDown()) keys = keys | wxKEY_CTRL;
 362
 363     if (event.LeftUp())
 364     {
 365         if (m_mouseCaptured)
 366         {
 367             handlerDialog->ReleaseMouse();
 368             m_mouseCaptured = FALSE;
 369         }
 370
 371         OnLeftClick(x, y, keys);
 372     }
 373     else if (event.RightDown())
 374     {
 375         if (m_mouseCaptured)
 376         {
 377             handlerDialog->ReleaseMouse();
 378             m_mouseCaptured = FALSE;
 379         }
 380
 381         OnRightClick(x, y, keys);
 382     }
 383     else if (event.LeftDClick())
 384     {
 385         if (m_mouseCaptured)
 386         {
 387             handlerDialog->ReleaseMouse();
 388             m_mouseCaptured = FALSE;
 389         }
 390         wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
 391     }
 392   }
 393   else
 394         event.Skip();
 395 }
 396
 397 void wxResourceEditorDialogHandler::OnItemEvent(wxControl *item, wxMouseEvent& event)
 398 {
 399   if (!GetEvtHandlerEnabled())
 400     return;
 401
 402   // Not a selection handle event: just a normal item event.
 403   // Transform to panel coordinates.
 404   wxCoord x, y;
 405   item->GetPosition(&x, &y);
 406
 407   event.m_x = event.m_x + x;
 408   event.m_y = event.m_y + y;
 409
 410   ProcessItemEvent(item, event, dragType);
 411 }
 412
 413 void wxResourceEditorDialogHandler::ProcessItemEvent(wxControl *item, wxMouseEvent& event, int selectionHandle)
 414 {
 415   wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 416
 417   wxCoord x, y;
 418   event.GetPosition(&x, &y);
 419   int keys = 0;
 420   if (event.ShiftDown()) keys = keys | wxKEY_SHIFT;
 421   if (event.ControlDown()) keys = keys | wxKEY_CTRL;
 422   bool dragging = event.Dragging();
 423   if (dragging)
 424   {
 425     int dx = (int)abs((x - firstDragX));
 426     int dy = (int)abs((y - firstDragY));
 427     if (checkTolerance && (dx <= dragTolerance) && (dy <= dragTolerance))
 428     {
 429       return;
 430     }
 431     else
 432       // If we've ignored the tolerance once, then ALWAYS ignore
 433       // tolerance in this drag, even if we come back within
 434       // the tolerance range.
 435       {
 436         checkTolerance = FALSE;
 437       }
 438   }
 439   if (event.LeftDClick())
 440   {
 441       if (m_mouseCaptured)
 442       {
 443         handlerDialog->ReleaseMouse();
 444         m_mouseCaptured = FALSE;
 445       }
 446
 447       wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
 448   }
 449   else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_LEFT)
 450   {
 451     dragMode = wxDRAG_MODE_CONTINUE_LEFT;
 452         wxClientDC dc(handlerDialog);
 453     childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
 454     oldDragX = x; oldDragY = y;
 455     if (!m_mouseCaptured)
 456     {
 457         handlerDialog->CaptureMouse();
 458         m_mouseCaptured = TRUE;
 459     }
 460   }
 461   else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 462   {
 463         wxClientDC dc(handlerDialog);
 464     childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
 465     childHandler->OnDragContinue(TRUE, x, y, keys, dc, selectionHandle);
 466     oldDragX = x; oldDragY = y;
 467   }
 468   else if (event.LeftUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
 469   {
 470         wxClientDC dc(handlerDialog);
 471     dragMode = wxDRAG_MODE_NONE;
 472     checkTolerance = TRUE;
 473
 474     childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
 475     childHandler->OnDragEnd(x, y, keys, dc, selectionHandle);
 476
 477     dragItem = NULL;
 478     dragType = wxDRAG_TYPE_NONE;
 479
 480     if (m_mouseCaptured)
 481     {
 482         handlerDialog->ReleaseMouse();
 483         m_mouseCaptured = FALSE;
 484     }
 485   }
 486   else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_RIGHT)
 487   {
 488         wxClientDC dc(handlerDialog);
 489     dragMode = wxDRAG_MODE_CONTINUE_RIGHT;
 490     childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
 491     oldDragX = x; oldDragY = y;
 492
 493     if (!m_mouseCaptured)
 494     {
 495         handlerDialog->CaptureMouse();
 496         m_mouseCaptured = TRUE;
 497     }
 498   }
 499   else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
 500   {
 501     oldDragX = x; oldDragY = y;
 502   }
 503   // Obsolete; no longer try to right-drag
 504   else if (event.RightUp() && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
 505   {
 506     dragMode = wxDRAG_MODE_NONE;
 507     checkTolerance = TRUE;
 508     dragItem = NULL;
 509     dragType = wxDRAG_TYPE_NONE;
 510
 511     if (m_mouseCaptured)
 512     {
 513         handlerDialog->ReleaseMouse();
 514         m_mouseCaptured = FALSE;
 515     }
 516   }
 517   else if (event.IsButton())
 518   {
 519     checkTolerance = TRUE;
 520
 521     if (event.LeftDown())
 522     {
 523       dragItem = item;
 524       dragMode = wxDRAG_MODE_START_LEFT;
 525       firstDragX = x;
 526       firstDragY = y;
 527       dragType = selectionHandle;
 528
 529       if (!m_mouseCaptured)
 530       {
 531         handlerDialog->CaptureMouse();
 532         m_mouseCaptured = TRUE;
 533       }
 534     }
 535     else if (event.RightDown())
 536     {
 537       if (m_mouseCaptured)
 538       {
 539         handlerDialog->ReleaseMouse();
 540         m_mouseCaptured = FALSE;
 541       }
 542
 543       if (item)
 544         childHandler->OnRightClick(x, y, keys);
 545       else
 546         OnRightClick(x, y, keys);
 547
 548       dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 549
 550       /*
 551       dragItem = item;
 552       dragMode = wxDRAG_MODE_START_RIGHT;
 553       firstDragX = x;
 554       firstDragY = y;
 555       dragType = selectionHandle;
 556
 557       if (!m_mouseCaptured)
 558       {
 559         handlerDialog->CaptureMouse();
 560         m_mouseCaptured = TRUE;
 561       }
 562       */
 563     }
 564     else if (event.LeftUp())
 565     {
 566       if (dragItem)
 567         childHandler->OnLeftClick(x, y, keys);
 568       else
 569         OnLeftClick(x, y, keys);
 570
 571       dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 572
 573       if (m_mouseCaptured)
 574       {
 575         handlerDialog->ReleaseMouse();
 576         m_mouseCaptured = FALSE;
 577       }
 578     }
 579     else if (event.RightUp())
 580     {
 581       /*
 582       if (dragItem)
 583         childHandler->OnRightClick(x, y, keys);
 584       else
 585         OnRightClick(x, y, keys);
 586
 587       dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
 588
 589       if (m_mouseCaptured)
 590       {
 591         handlerDialog->ReleaseMouse();
 592         m_mouseCaptured = FALSE;
 593       }
 594       */
 595     }
 596   }
 597 }
 598
 599 // Calls DrawSelectionHandles for all items if
 600 // edit mode is on.
 601 void wxResourceEditorDialogHandler::PaintSelectionHandles(wxDC& dc)
 602 {
 603   if (!GetEvtHandlerEnabled())
 604     return;
 605
 606   dc.BeginDrawing();
 607
 608   wxNode *node = handlerDialog->GetChildren().First();
 609   while (node)
 610   {
 611     wxWindow *win = (wxWindow *)node->Data();
 612     if (win->IsKindOf(CLASSINFO(wxControl)))
 613     {
 614       wxControl *item = (wxControl *)win;
 615       wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 616
 617       // Don't draw handles for an item that's being moved: it'll
 618       // smear.
 619       if (childHandler->IsSelected() && (item != dragItem))
 620         childHandler->DrawSelectionHandles(dc);
 621     }
 622     node = node->Next();
 623   }
 624   dc.EndDrawing();
 625 }
 626
 627 /*
 628  * Event handler for controls
 629  */
 630
 631 int wxResourceEditorControlHandler::dragOffsetX = 0;
 632 int wxResourceEditorControlHandler::dragOffsetY = 0;
 633
 634 wxResourceEditorControlHandler::wxResourceEditorControlHandler(wxControl *control,
 635    wxEvtHandler *oldHandler)
 636 {
 637   handlerControl = control;
 638   handlerOldHandler = oldHandler;
 639
 640   handleSize = 6;
 641   handleMargin = 1;
 642   isSelected = FALSE;
 643   dragOffsetX = 0;
 644   dragOffsetY = 0;
 645 //  m_treeItem = 0;
 646 }
 647
 648 wxResourceEditorControlHandler::~wxResourceEditorControlHandler(void)
 649 {
 650 }
 651
 652 /*
 653  * Manipulation and drawing of items in Edit Mode
 654  */
 655
 656 void wxResourceEditorControlHandler::SelectItem(bool select)
 657 {
 658   isSelected = select;
 659 }
 660
 661 // Returns TRUE or FALSE
 662 bool wxResourceEditorControlHandler::HitTest(int x, int y)
 663 {
 664   int xpos, ypos, width, height;
 665   handlerControl->GetPosition(&xpos, &ypos);
 666   handlerControl->GetSize(&width, &height);
 667
 668   return ((x >= xpos) && (x <= (xpos + width)) && (y >= ypos) && (y <= (ypos + height)));
 669 }
 670
 671 // Calculate position of the 8 handles
 672 void wxResourceEditorControlHandler::CalcSelectionHandles(int *hx, int *hy)
 673 {
 674   int xpos, ypos, width, height;
 675   handlerControl->GetPosition(&xpos, &ypos);
 676   handlerControl->GetSize(&width, &height);
 677   int middleX = (xpos + (width/2));
 678   int middleY = (ypos + (height/2));
 679
 680   // Start from top middle, clockwise.
 681 /*
 682   7      0      1
 683
 684   6             2
 685
 686   5      4      3
 687 */
 688
 689   hx[0] = (int)(middleX - (handleSize/2));
 690   hy[0] = ypos - handleSize - handleMargin;
 691
 692   hx[1] = xpos + width + handleMargin;
 693   hy[1] = ypos - handleSize - handleMargin;
 694
 695   hx[2] = xpos + width + handleMargin;
 696   hy[2] = (int)(middleY - (handleSize/2));
 697
 698   hx[3] = xpos + width + handleMargin;
 699   hy[3] = ypos + height + handleMargin;
 700
 701   hx[4] = (int)(middleX - (handleSize/2));
 702   hy[4] = ypos + height + handleMargin;
 703
 704   hx[5] = xpos - handleSize - handleMargin;
 705   hy[5] = ypos + height + handleMargin;
 706
 707   hx[6] = xpos - handleSize - handleMargin;
 708   hy[6] = (int)(middleY - (handleSize/2));
 709
 710   hx[7] = xpos - handleSize - handleMargin;
 711   hy[7] = ypos - handleSize - handleMargin;
 712 }
 713
 714 // Returns 0 (no hit), 1 - 8 for which selection handle
 715 // (clockwise from top middle)
 716 int wxResourceEditorControlHandler::SelectionHandleHitTest(int x, int y)
 717 {
 718   // Handle positions
 719   int hx[8];
 720   int hy[8];
 721   CalcSelectionHandles(hx, hy);
 722
 723   int i;
 724   for (i = 0; i < 8; i++)
 725   {
 726     if ((x >= hx[i]) && (x <= (hx[i] + handleSize)) && (y >= hy[i]) && (y <= (hy[i] + handleSize)))
 727       return (i + 1);
 728   }
 729   return 0;
 730 }
 731
 732 void wxResourceEditorControlHandler::DrawSelectionHandles(wxDC& dc, bool WXUNUSED(erase))
 733 {
 734   dc.SetOptimization(FALSE);
 735
 736   dc.SetLogicalFunction(wxCOPY);
 737   dc.SetPen(* wxBLACK_PEN);
 738   dc.SetBrush(* wxBLACK_BRUSH);
 739
 740   dc.SetOptimization(TRUE);
 741
 742   // Handle positions
 743   int hx[8];
 744   int hy[8];
 745   CalcSelectionHandles(hx, hy);
 746
 747   int i;
 748   for (i = 0; i < 8; i++)
 749   {
 750     dc.DrawRectangle(hx[i], hy[i], handleSize, handleSize);
 751   }
 752 }
 753
 754 void wxResourceEditorControlHandler::DrawBoundingBox(wxDC& dc, int x, int y, int w, int h)
 755 {
 756   dc.DrawRectangle(x, y, w, h);
 757 }
 758
 759 // If selectionHandle is zero, not dragging the selection handle.
 760 void wxResourceEditorControlHandler::OnDragBegin(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 761 {
 762   int xpos, ypos, width, height;
 763   handlerControl->GetPosition(&xpos, &ypos);
 764   handlerControl->GetSize(&width, &height);
 765
 766   dc.BeginDrawing();
 767
 768 //  dc.DestroyClippingRegion();
 769
 770   wxPanel *panel = (wxPanel *)handlerControl->GetParent();
 771
 772   // Erase selection handles
 773 //  DrawSelectionHandles(dc, TRUE);
 774
 775   dc.SetOptimization(FALSE);
 776
 777   dc.SetLogicalFunction(wxINVERT);
 778
 779   wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
 780   dc.SetPen(pen);
 781   dc.SetBrush(* wxTRANSPARENT_BRUSH);
 782
 783   dc.SetOptimization(TRUE);
 784
 785   if (selectionHandle > 0)
 786   {
 787     panel->Refresh();
 788
 789     DrawBoundingBox(dc, xpos, ypos, width, height);
 790   }
 791   else
 792   {
 793     panel->Refresh();
 794
 795     dragOffsetX = (x - xpos);
 796     dragOffsetY = (y - ypos);
 797
 798       DrawBoundingBox(dc, xpos, ypos, width, height);
 799
 800       // Also draw bounding boxes for other selected items
 801       wxNode *node = panel->GetChildren().First();
 802       while (node)
 803       {
 804         wxWindow *win = (wxWindow *)node->Data();
 805         if (win->IsKindOf(CLASSINFO(wxControl)))
 806         {
 807           wxControl *item = (wxControl *)win;
 808                   wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 809           if ((item != handlerControl) && handler->IsSelected())
 810           {
 811             int x1, y1, w1, h1;
 812             item->GetPosition(&x1, &y1);
 813             item->GetSize(&w1, &h1);
 814             handler->DrawBoundingBox(dc, x1, y1, w1, h1);
 815           }
 816         }
 817         node = node->Next();
 818       }
 819   }
 820   dc.EndDrawing();
 821 }
 822
 823 void wxResourceEditorControlHandler::OnDragContinue(bool WXUNUSED(paintIt), int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 824 {
 825   wxPanel *panel = (wxPanel *)handlerControl->GetParent();
 826   int xpos, ypos, width, height;
 827   handlerControl->GetPosition(&xpos, &ypos);
 828   handlerControl->GetSize(&width, &height);
 829
 830   if (selectionHandle > 0)
 831   {
 832 /*
 833   8      1      2
 834
 835   7             3
 836
 837   6      5      4
 838 */
 839
 840     int x1, y1, width1, height1;
 841
 842     switch (selectionHandle)
 843     {
 844       case 1:
 845         x1 = xpos;
 846         y1 = y;
 847         width1 = width;
 848         height1 = (ypos + height) - y;
 849         break;
 850       case 5:
 851         x1 = xpos;
 852         y1 = ypos;
 853         width1 = width;
 854         height1 = (y - ypos);
 855         break;
 856       case 3:
 857         x1 = xpos;
 858         y1 = ypos;
 859         width1 = (x - xpos);
 860         height1 = height;
 861         break;
 862       case 7:
 863         x1 = x;
 864         y1 = ypos;
 865         width1 = (xpos + width) - x;
 866         height1 = height;
 867         break;
 868       case 2:
 869         x1 = xpos;
 870         y1 = y;
 871         width1 = (x - xpos);
 872         height1 = (ypos + height) - y;
 873         break;
 874       case 4:
 875         x1 = xpos;
 876         y1 = ypos;
 877         width1 = (x - xpos);
 878         height1 = (y - ypos);
 879         break;
 880       case 6:
 881         x1 = x;
 882         y1 = ypos;
 883         width1 = (xpos + width) - x;
 884         height1 = y - ypos;
 885         break;
 886       case 8:
 887         x1 = x;
 888         y1 = y;
 889         width1 = (xpos + width) - x;
 890         height1 = (ypos + height) - y;
 891         break;
 892     }
 893     dc.BeginDrawing();
 894
 895     dc.SetLogicalFunction(wxINVERT);
 896     wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
 897     dc.SetPen(pen);
 898     dc.SetBrush(* wxTRANSPARENT_BRUSH);
 899
 900     DrawBoundingBox(dc, x1, y1, width1, height1);
 901
 902     dc.EndDrawing();
 903   }
 904   else
 905   {
 906       dc.BeginDrawing();
 907       dc.SetLogicalFunction(wxINVERT);
 908       wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
 909       dc.SetPen(pen);
 910       dc.SetBrush(* wxTRANSPARENT_BRUSH);
 911
 912       DrawBoundingBox(dc, (int)(x - dragOffsetX), (int)(y - dragOffsetY), width, height);
 913
 914       // Also draw bounding boxes for other selected items
 915       wxNode *node = panel->GetChildren().First();
 916       while (node)
 917       {
 918         wxWindow *win = (wxWindow *)node->Data();
 919         if (win->IsKindOf(CLASSINFO(wxControl)))
 920         {
 921           wxControl *item = (wxControl *)win;
 922                   wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
 923           if ((item != handlerControl) && handler->IsSelected())
 924           {
 925             int x1, y1, w1, h1;
 926             item->GetPosition(&x1, &y1);
 927             item->GetSize(&w1, &h1);
 928             int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
 929             int y2 = (int)(y1 + (y - dragOffsetY) - ypos);
 930             handler->DrawBoundingBox(dc, x2, y2, w1, h1);
 931           }
 932         }
 933         node = node->Next();
 934       }
 935       dc.EndDrawing();
 936   }
 937 }
 938
 939 void wxResourceEditorControlHandler::OnDragEnd(int x, int y, int WXUNUSED(keys), wxDC& dc, int selectionHandle)
 940 {
 941   wxPanel *panel = (wxPanel *)handlerControl->GetParent();
 942
 943   dc.BeginDrawing();
 944
 945   int xpos, ypos, width, height;
 946   handlerControl->GetPosition(&xpos, &ypos);
 947   handlerControl->GetSize(&width, &height);
 948
 949   wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl);
 950   wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(handlerControl->GetParent());
 951
 952   if (selectionHandle > 0)
 953   {
 954     int x1, y1, width1, height1;
 955
 956     switch (selectionHandle)
 957     {
 958       case 1:
 959         x1 = xpos;
 960         y1 = y;
 961         width1 = width;
 962         height1 = (ypos + height) - y;
 963         break;
 964       case 5:
 965         x1 = xpos;
 966         y1 = ypos;
 967         width1 = width;
 968         height1 = (y - ypos);
 969         break;
 970       case 3:
 971         x1 = xpos;
 972         y1 = ypos;
 973         width1 = (x - xpos);
 974         height1 = height;
 975         break;
 976       case 7:
 977         x1 = x;
 978         y1 = ypos;
 979         width1 = (xpos + width) - x;
 980         height1 = height;
 981         break;
 982       case 2:
 983         x1 = xpos;
 984         y1 = y;
 985         width1 = (x - xpos);
 986         height1 = (ypos + height) - y;
 987         break;
 988       case 4:
 989         x1 = xpos;
 990         y1 = ypos;
 991         width1 = (x - xpos);
 992         height1 = (y - ypos);
 993         break;
 994       case 6:
 995         x1 = x;
 996         y1 = ypos;
 997         width1 = (xpos + width) - x;
 998         height1 = y - ypos;
 999         break;
1000       case 8:
1001         x1 = x;
1002         y1 = y;
1003         width1 = (xpos + width) - x;
1004         height1 = (ypos + height) - y;
1005         break;
1006     }
1007     // Update the associated resource
1008     // We need to convert to dialog units if this is not a dialog or panel, but
1009     // the parent resource specifies dialog units.
1010     int resourceX = x1;
1011     int resourceY = y1;
1012     int resourceWidth = width1;
1013     int resourceHeight = height1;
1014
1015     if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1016     {
1017         wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(x1, y1));
1018         wxSize sz = handlerControl->GetParent()->ConvertPixelsToDialog(wxSize(width1, height1));
1019
1020         // Convert back so we've rounded down
1021         sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
1022         sz = handlerControl->GetParent()->ConvertPixelsToDialog(sz);
1023         resourceWidth = sz.x; resourceHeight = sz.y;
1024
1025         sz = handlerControl->GetParent()->ConvertDialogToPixels(sz);
1026         width1 = sz.x;
1027         height1 = sz.y;
1028
1029         pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1030         pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
1031         resourceX = pt.x; resourceY = pt.y;
1032
1033         pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1034         x1 = pt.x;
1035         y1 = pt.y;
1036     }
1037     handlerControl->SetSize(x1, y1, width1, height1);
1038     resource->SetSize(resourceX, resourceY, resourceWidth, resourceHeight);
1039   }
1040   else
1041   {
1042     // Correction 31/12/98. We need to round down the values to take into account
1043     // the fact that several pixels map to the same dialog unit.
1044
1045     int newX = (int)(x - dragOffsetX);
1046     int newY = (int)(y - dragOffsetY);
1047     int resourceX = newX;
1048     int resourceY = newY;
1049
1050     // Update the associated resource
1051     if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1052     {
1053         wxPoint pt = handlerControl->GetParent()->ConvertPixelsToDialog(wxPoint(newX, newY));
1054         pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1055         pt = handlerControl->GetParent()->ConvertPixelsToDialog(pt);
1056         resourceX = pt.x; resourceY = pt.y;
1057         pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1058
1059         // Having converted it several times, we know it'll map to dialog units exactly.
1060         newX = pt.x;
1061         newY = pt.y;
1062     }
1063     handlerControl->Move(newX, newY);
1064     OldOnMove(newX, newY);
1065
1066     resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());
1067
1068     // Also move other selected items
1069     wxNode *node = panel->GetChildren().First();
1070     while (node)
1071     {
1072       wxWindow *win = (wxWindow *)node->Data();
1073       if (win->IsKindOf(CLASSINFO(wxControl)))
1074       {
1075         wxControl *item = (wxControl *)win;
1076         wxResourceEditorControlHandler *handler = (wxResourceEditorControlHandler *)item->GetEventHandler();
1077         if ((item != handlerControl) && handler->IsSelected())
1078         {
1079           int x1, y1;
1080           item->GetPosition(&x1, &y1);
1081           int x2 = (int)(x1 + (x - dragOffsetX) - xpos);
1082           int y2 = (int)(y1 + (y - dragOffsetY) - ypos);
1083
1084           // Update the associated resource
1085           resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(item);
1086           if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
1087           {
1088             wxPoint pt = item->GetParent()->ConvertPixelsToDialog(wxPoint(x2, y2));
1089             pt = item->GetParent()->ConvertDialogToPixels(pt);
1090             pt = item->GetParent()->ConvertPixelsToDialog(pt);
1091
1092             resourceX = pt.x; resourceY = pt.y;
1093             pt = handlerControl->GetParent()->ConvertDialogToPixels(pt);
1094
1095             // Having converted it several times, we know it'll map to dialog units exactly
1096             x2 = pt.x;
1097             y2 = pt.y;
1098           }
1099
1100           item->Move(x2, y2);
1101           ((wxResourceEditorControlHandler *)item->GetEventHandler())->OldOnMove(x2, y2);
1102           ((wxResourceEditorControlHandler *)item->GetEventHandler())->DrawSelectionHandles(dc);
1103
1104           resource->SetSize(resourceX, resourceY, resource->GetWidth(), resource->GetHeight());
1105
1106         }
1107       }
1108       node = node->Next();
1109     }
1110   }
1111   dc.SetOptimization(FALSE);
1112
1113   dc.SetLogicalFunction(wxCOPY);
1114   dc.SetPen(* wxBLACK_PEN);
1115   dc.SetBrush(* wxBLACK_BRUSH);
1116
1117   dc.SetOptimization(TRUE);
1118
1119   // Force it to repaint the selection handles (if any)
1120   // since the panel thinks we're still within a drag and
1121   // won't paint the handles.
1122   if (IsSelected())
1123     DrawSelectionHandles(dc);
1124
1125   dc.EndDrawing();
1126
1127   panel->Refresh();
1128 }
1129
1130 // These functions call OnItemEvent, OnItemMove and OnItemSize
1131 // by default.
1132 void wxResourceEditorControlHandler::OnMouseEvent(wxMouseEvent& event)
1133 {
1134 /*
1135   if ((event.m_eventType == wxEVENT_TYPE_LEFT_DCLICK) ||
1136       (event.m_eventType == wxEVENT_TYPE_RIGHT_DCLICK))
1137     return;
1138 */
1139   wxWindow *panel = handlerControl->GetParent();
1140   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1141         return;
1142   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1143   if ( !panelHandler->GetEvtHandlerEnabled() )
1144   {
1145         event.Skip();
1146         return;
1147   }
1148
1149   panelHandler->OnItemEvent(handlerControl, event);
1150 }
1151
1152 void wxResourceEditorControlHandler::OldOnMove(int x, int y)
1153 {
1154   wxWindow *panel = handlerControl->GetParent();
1155   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1156         return;
1157
1158   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1159   panelHandler->OnItemMove(handlerControl, x, y);
1160 }
1161
1162 void wxResourceEditorControlHandler::OldOnSize(int w, int h)
1163 {
1164   wxWindow *panel = handlerControl->GetParent();
1165   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1166         return;
1167
1168   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1169   panelHandler->OnItemSize(handlerControl, w, h);
1170 }
1171
1172 void wxResourceEditorControlHandler::OnSelect(bool select)
1173 {
1174   wxWindow *panel = handlerControl->GetParent();
1175   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1176         return;
1177
1178   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1179   panelHandler->OnItemSelect(handlerControl, select);
1180 }
1181
1182 void wxResourceEditorControlHandler::OnLeftClick(int x, int y, int keys)
1183 {
1184   wxWindow *panel = handlerControl->GetParent();
1185   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1186         return;
1187
1188   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1189   panelHandler->OnItemLeftClick(handlerControl, x, y, keys);
1190 }
1191
1192 void wxResourceEditorControlHandler::OnRightClick(int x, int y, int keys)
1193 {
1194   wxWindow *panel = handlerControl->GetParent();
1195   if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
1196         return;
1197
1198   wxResourceEditorDialogHandler *panelHandler = (wxResourceEditorDialogHandler *)panel->GetEventHandler();
1199   panelHandler->OnItemRightClick(handlerControl, x, y, keys);
1200 }
1201
1202