contrib/src/deprecated/tbarsmpl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        contrib/src/deprecated//tbarsmpl.cpp
   3 // Purpose:     wxToolBarSimple
   4 // Author:      Julian Smart
   5 // Modified by: VZ on 14.12.99 during wxToolBarSimple reorganization
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "tbarsmpl.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_TOOLBAR && wxUSE_TOOLBAR_SIMPLE
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/settings.h"
  35     #include "wx/window.h"
  36     #include "wx/dcclient.h"
  37     #include "wx/dcmemory.h"
  38 #endif
  39
  40 #include "wx/toolbar.h"
  41 #include "wx/deprecated/tbarsmpl.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // private classes
  45 // ----------------------------------------------------------------------------
  46
  47 class WXDLLIMPEXP_DEPRECATED wxToolBarToolSimple : public wxToolBarToolBase
  48 {
  49 public:
  50     wxToolBarToolSimple(wxToolBarSimple *tbar,
  51                         int id,
  52                         const wxString& label,
  53                         const wxBitmap& bmpNormal,
  54                         const wxBitmap& bmpDisabled,
  55                         wxItemKind kind,
  56                         wxObject *clientData,
  57                         const wxString& shortHelp,
  58                         const wxString& longHelp)
  59         : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
  60                             clientData, shortHelp, longHelp)
  61     {
  62     }
  63
  64     wxToolBarToolSimple(wxToolBarSimple *tbar, wxControl *control)
  65         : wxToolBarToolBase(tbar, control)
  66     {
  67     }
  68
  69     void SetSize(const wxSize& size)
  70     {
  71         m_width = size.x;
  72         m_height = size.y;
  73     }
  74
  75     wxCoord GetWidth() const { return m_width; }
  76     wxCoord GetHeight() const { return m_height; }
  77
  78     wxCoord m_x;
  79     wxCoord m_y;
  80     wxCoord m_width;
  81     wxCoord m_height;
  82
  83     DECLARE_NO_COPY_CLASS(wxToolBarToolSimple)
  84 };
  85
  86 // ----------------------------------------------------------------------------
  87 // wxWin macros
  88 // ----------------------------------------------------------------------------
  89
  90 IMPLEMENT_DYNAMIC_CLASS(wxToolBarSimple, wxControl)
  91
  92 #if !wxUSE_TOOLBAR_NATIVE && !defined(__WXUNIVERSAL__)
  93     IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarSimple)
  94 #endif
  95
  96 BEGIN_EVENT_TABLE(wxToolBarSimple, wxToolBarBase)
  97     EVT_SIZE(wxToolBarSimple::OnSize)
  98     EVT_SCROLL(wxToolBarSimple::OnScroll)
  99     EVT_PAINT(wxToolBarSimple::OnPaint)
 100     EVT_KILL_FOCUS(wxToolBarSimple::OnKillFocus)
 101     EVT_MOUSE_EVENTS(wxToolBarSimple::OnMouseEvent)
 102 END_EVENT_TABLE()
 103
 104 // ============================================================================
 105 // implementation
 106 // ============================================================================
 107
 108 // ----------------------------------------------------------------------------
 109 // tool bar tools creation
 110 // ----------------------------------------------------------------------------
 111
 112 wxToolBarToolBase *wxToolBarSimple::CreateTool(int id,
 113                                                const wxString& label,
 114                                                const wxBitmap& bmpNormal,
 115                                                const wxBitmap& bmpDisabled,
 116                                                wxItemKind kind,
 117                                                wxObject *clientData,
 118                                                const wxString& shortHelp,
 119                                                const wxString& longHelp)
 120 {
 121     return new wxToolBarToolSimple(this, id, label, bmpNormal, bmpDisabled,
 122                                    kind, clientData, shortHelp, longHelp);
 123 }
 124
 125 wxToolBarToolBase *wxToolBarSimple::CreateTool(wxControl *control)
 126 {
 127     return new wxToolBarToolSimple(this, control);
 128 }
 129
 130 // ----------------------------------------------------------------------------
 131 // wxToolBarSimple creation
 132 // ----------------------------------------------------------------------------
 133
 134 void wxToolBarSimple::Init()
 135 {
 136     m_currentRowsOrColumns = 0;
 137
 138     m_lastX =
 139     m_lastY = 0;
 140
 141     m_maxWidth =
 142     m_maxHeight = 0;
 143
 144     m_pressedTool =
 145     m_currentTool = -1;
 146
 147     m_xPos =
 148     m_yPos = wxDefaultCoord;
 149
 150     m_toolPacking = 1;
 151     m_toolSeparation = 5;
 152
 153     m_defaultWidth = 16;
 154     m_defaultHeight = 15;
 155
 156     m_xScrollPixelsPerLine = 1;
 157     m_yScrollPixelsPerLine = 1;
 158     m_xScrollingEnabled = false;
 159     m_yScrollingEnabled = false;
 160     m_xScrollPosition = 0;
 161     m_yScrollPosition = 0;
 162     m_xScrollLines = 0;
 163     m_yScrollLines = 0;
 164     m_xScrollLinesPerPage = 0;
 165     m_yScrollLinesPerPage = 0;
 166 }
 167
 168 wxToolBarToolBase *wxToolBarSimple::DoAddTool(int id,
 169                                               const wxString& label,
 170                                               const wxBitmap& bitmap,
 171                                               const wxBitmap& bmpDisabled,
 172                                               wxItemKind kind,
 173                                               const wxString& shortHelp,
 174                                               const wxString& longHelp,
 175                                               wxObject *clientData,
 176                                               wxCoord xPos,
 177                                               wxCoord yPos)
 178 {
 179     // rememeber the position for DoInsertTool()
 180     m_xPos = xPos;
 181     m_yPos = yPos;
 182
 183     return wxToolBarBase::DoAddTool(id, label, bitmap, bmpDisabled, kind,
 184                                     shortHelp, longHelp,
 185                                     clientData, xPos, yPos);
 186 }
 187
 188 bool wxToolBarSimple::DoInsertTool(size_t WXUNUSED(pos),
 189                                    wxToolBarToolBase *toolBase)
 190 {
 191     wxToolBarToolSimple *tool = (wxToolBarToolSimple *)toolBase;
 192
 193     wxCHECK_MSG( !tool->IsControl(), false,
 194                  _T("generic wxToolBarSimple doesn't support controls") );
 195
 196     tool->m_x = m_xPos;
 197     if ( tool->m_x == wxDefaultCoord )
 198         tool->m_x = m_xMargin;
 199
 200     tool->m_y = m_yPos;
 201     if ( tool->m_y == wxDefaultCoord )
 202         tool->m_y = m_yMargin;
 203
 204     tool->SetSize(GetToolSize());
 205
 206     if ( tool->IsButton() )
 207     {
 208         // Calculate reasonable max size in case Layout() not called
 209         if ((tool->m_x + tool->GetNormalBitmap().GetWidth() + m_xMargin) > m_maxWidth)
 210             m_maxWidth = (wxCoord)((tool->m_x + tool->GetWidth() + m_xMargin));
 211
 212         if ((tool->m_y + tool->GetNormalBitmap().GetHeight() + m_yMargin) > m_maxHeight)
 213             m_maxHeight = (wxCoord)((tool->m_y + tool->GetHeight() + m_yMargin));
 214     }
 215
 216     return true;
 217 }
 218
 219 bool wxToolBarSimple::DoDeleteTool(size_t WXUNUSED(pos),
 220                                    wxToolBarToolBase *tool)
 221 {
 222     // VZ: didn't test whether it works, but why not...
 223     tool->Detach();
 224
 225     Refresh();
 226
 227     return true;
 228 }
 229
 230 bool wxToolBarSimple::Create(wxWindow *parent,
 231                              wxWindowID id,
 232                              const wxPoint& pos,
 233                              const wxSize& size,
 234                              long style,
 235                              const wxString& name)
 236 {
 237     if ( !wxWindow::Create(parent, id, pos, size, style, name) )
 238         return false;
 239
 240     // Set it to grey (or other 3D face colour)
 241     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 242
 243     if ( GetWindowStyleFlag() & wxTB_VERTICAL )
 244     {
 245         m_lastX = 7;
 246         m_lastY = 3;
 247
 248         m_maxRows = 32000;      // a lot
 249         m_maxCols = 1;
 250     }
 251     else
 252     {
 253         m_lastX = 3;
 254         m_lastY = 7;
 255
 256         m_maxRows = 1;
 257         m_maxCols = 32000;      // a lot
 258     }
 259
 260     SetCursor(*wxSTANDARD_CURSOR);
 261
 262     return true;
 263 }
 264
 265 wxToolBarSimple::~wxToolBarSimple()
 266 {
 267 }
 268
 269 bool wxToolBarSimple::Realize()
 270 {
 271     m_currentRowsOrColumns = 0;
 272     m_lastX = m_xMargin;
 273     m_lastY = m_yMargin;
 274     m_maxWidth = 0;
 275     m_maxHeight = 0;
 276
 277     int maxToolWidth = 0;
 278     int maxToolHeight = 0;
 279
 280     // Find the maximum tool width and height
 281     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 282     while ( node )
 283     {
 284         wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 285         if ( tool->GetWidth() > maxToolWidth )
 286             maxToolWidth = tool->GetWidth();
 287         if (tool->GetHeight() > maxToolHeight)
 288             maxToolHeight = tool->GetHeight();
 289
 290         node = node->GetNext();
 291     }
 292
 293     int separatorSize = m_toolSeparation;
 294
 295     node = m_tools.GetFirst();
 296     while ( node )
 297     {
 298         wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 299         if ( tool->IsSeparator() )
 300         {
 301             if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 302             {
 303                 if (m_currentRowsOrColumns >= m_maxCols)
 304                     m_lastY += separatorSize;
 305                 else
 306                     m_lastX += separatorSize;
 307             }
 308             else
 309             {
 310                 if (m_currentRowsOrColumns >= m_maxRows)
 311                     m_lastX += separatorSize;
 312                 else
 313                     m_lastY += separatorSize;
 314             }
 315         }
 316         else if ( tool->IsButton() )
 317         {
 318             if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 319             {
 320                 if (m_currentRowsOrColumns >= m_maxCols)
 321                 {
 322                     m_currentRowsOrColumns = 0;
 323                     m_lastX = m_xMargin;
 324                     m_lastY += maxToolHeight + m_toolPacking;
 325                 }
 326                 tool->m_x = (wxCoord)(m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 327                 tool->m_y = (wxCoord)(m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 328
 329                 m_lastX += maxToolWidth + m_toolPacking;
 330             }
 331             else
 332             {
 333                 if (m_currentRowsOrColumns >= m_maxRows)
 334                 {
 335                     m_currentRowsOrColumns = 0;
 336                     m_lastX += (maxToolWidth + m_toolPacking);
 337                     m_lastY = m_yMargin;
 338                 }
 339                 tool->m_x = (wxCoord)(m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 340                 tool->m_y = (wxCoord)(m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 341
 342                 m_lastY += maxToolHeight + m_toolPacking;
 343             }
 344             m_currentRowsOrColumns ++;
 345         }
 346         else
 347         {
 348             // TODO: support the controls
 349         }
 350
 351         if (m_lastX > m_maxWidth)
 352             m_maxWidth = m_lastX;
 353         if (m_lastY > m_maxHeight)
 354             m_maxHeight = m_lastY;
 355
 356         node = node->GetNext();
 357     }
 358
 359     if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 360         m_maxHeight += maxToolHeight;
 361     else
 362         m_maxWidth += maxToolWidth;
 363
 364     m_maxWidth += m_xMargin;
 365     m_maxHeight += m_yMargin;
 366
 367     SetSize(m_maxWidth, m_maxHeight);
 368
 369     return true;
 370 }
 371
 372 // ----------------------------------------------------------------------------
 373 // event handlers
 374 // ----------------------------------------------------------------------------
 375
 376 void wxToolBarSimple::OnPaint (wxPaintEvent& WXUNUSED(event))
 377 {
 378     wxPaintDC dc(this);
 379     PrepareDC(dc);
 380
 381     static int count = 0;
 382     // Prevent reentry of OnPaint which would cause wxMemoryDC errors.
 383     if ( count > 0 )
 384         return;
 385     count++;
 386
 387     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 388           node;
 389           node = node->GetNext() )
 390     {
 391         wxToolBarToolBase *tool = node->GetData();
 392         if ( tool->IsButton() )
 393             DrawTool(dc, tool);
 394     }
 395
 396     count--;
 397 }
 398
 399 void wxToolBarSimple::OnSize (wxSizeEvent& WXUNUSED(event))
 400 {
 401     if (GetAutoLayout())
 402         Layout();
 403
 404     AdjustScrollbars();
 405 }
 406
 407 void wxToolBarSimple::OnKillFocus(wxFocusEvent& WXUNUSED(event))
 408 {
 409     OnMouseEnter(m_pressedTool = m_currentTool = -1);
 410 }
 411
 412 void wxToolBarSimple::OnMouseEvent(wxMouseEvent & event)
 413 {
 414     wxCoord x, y;
 415     event.GetPosition(&x, &y);
 416     wxToolBarToolSimple *tool = (wxToolBarToolSimple *)FindToolForPosition(x, y);
 417
 418     if (event.LeftDown())
 419     {
 420         CaptureMouse();
 421     }
 422     if (event.LeftUp())
 423     {
 424         ReleaseMouse();
 425     }
 426
 427     if (!tool)
 428     {
 429         if (m_currentTool > -1)
 430         {
 431             if (event.LeftIsDown())
 432                 SpringUpButton(m_currentTool);
 433             m_currentTool = -1;
 434             OnMouseEnter(-1);
 435         }
 436         return;
 437     }
 438
 439     if (!event.IsButton())
 440     {
 441         if ( tool->GetId() != m_currentTool )
 442         {
 443             // If the left button is kept down and moved over buttons,
 444             // press those buttons.
 445             if ( event.LeftIsDown() && tool->IsEnabled() )
 446             {
 447                 SpringUpButton(m_currentTool);
 448
 449                 if ( tool->CanBeToggled() )
 450                 {
 451                     tool->Toggle();
 452                 }
 453
 454                 DrawTool(tool);
 455             }
 456
 457             m_currentTool = tool->GetId();
 458             OnMouseEnter(m_currentTool);
 459         }
 460         return;
 461     }
 462
 463     // Left button pressed.
 464     if ( event.LeftDown() && tool->IsEnabled() )
 465     {
 466         if ( tool->CanBeToggled() )
 467         {
 468             tool->Toggle();
 469         }
 470
 471         DrawTool(tool);
 472     }
 473     else if (event.RightDown())
 474     {
 475         OnRightClick(tool->GetId(), x, y);
 476     }
 477
 478     // Left Button Released.  Only this action confirms selection.
 479     // If the button is enabled and it is not a toggle tool and it is
 480     // in the pressed state, then raise the button and call OnLeftClick.
 481     //
 482     if ( event.LeftUp() && tool->IsEnabled() )
 483     {
 484         // Pass the OnLeftClick event to tool
 485         if ( !OnLeftClick(tool->GetId(), tool->IsToggled()) &&
 486                           tool->CanBeToggled() )
 487         {
 488             // If it was a toggle, and OnLeftClick says No Toggle allowed,
 489             // then change it back
 490             tool->Toggle();
 491         }
 492
 493         DrawTool(tool);
 494     }
 495 }
 496
 497 // ----------------------------------------------------------------------------
 498 // drawing
 499 // ----------------------------------------------------------------------------
 500
 501 void wxToolBarSimple::DrawTool(wxToolBarToolBase *tool)
 502 {
 503     wxClientDC dc(this);
 504     DrawTool(dc, tool);
 505 }
 506
 507 void wxToolBarSimple::DrawTool(wxDC& dc, wxToolBarToolBase *toolBase)
 508 {
 509     wxToolBarToolSimple *tool = (wxToolBarToolSimple *)toolBase;
 510
 511     wxMemoryDC memDC;
 512     PrepareDC(dc);
 513
 514     wxPen dark_grey_pen(wxColour( 85,85,85 ), 1, wxSOLID);
 515     wxPen white_pen(wxT("WHITE"), 1, wxSOLID);
 516     wxPen black_pen(wxT("BLACK"), 1, wxSOLID);
 517
 518     wxBitmap bitmap = tool->GetNormalBitmap();
 519     if (!bitmap.Ok())
 520         return;
 521
 522     if ( !tool->IsToggled() )
 523     {
 524 #if wxUSE_PALETTE
 525 #ifndef __WXGTK__
 526         if (bitmap.GetPalette())
 527             memDC.SetPalette(*bitmap.GetPalette());
 528 #endif
 529 #endif // wxUSE_PALETTE
 530
 531         int ax = (int)tool->m_x,
 532         ay = (int)tool->m_y,
 533         bx = (int)(tool->m_x+tool->GetWidth()),
 534         by = (int)(tool->m_y+tool->GetHeight());
 535
 536         memDC.SelectObject(bitmap);
 537         if (m_windowStyle & wxTB_3DBUTTONS)
 538         {
 539             dc.SetClippingRegion(ax, ay, (bx-ax+1), (by-ay+1));
 540             dc.Blit((ax+1), (ay+1), (bx-ax-2), (by-ay-2), &memDC, 0, 0);
 541             wxPen * old_pen = & dc.GetPen();
 542             dc.SetPen( white_pen );
 543             dc.DrawLine(ax,(by-1),ax,ay);
 544             dc.DrawLine(ax,ay,(bx-1),ay);
 545             dc.SetPen( dark_grey_pen );
 546             dc.DrawLine((bx-1),(ay+1),(bx-1),(by-1));
 547             dc.DrawLine((bx-1),(by-1),(ax+1),(by-1));
 548             dc.SetPen( black_pen );
 549             dc.DrawLine(bx,ay,bx,by);
 550             dc.DrawLine(bx,by,ax,by);
 551             dc.SetPen( *old_pen );
 552             dc.DestroyClippingRegion();
 553             // Select bitmap out of the DC
 554         }
 555         else
 556         {
 557             dc.Blit(tool->m_x, tool->m_y,
 558                     bitmap.GetWidth(), bitmap.GetHeight(),
 559                     &memDC, 0, 0);
 560         }
 561         memDC.SelectObject(wxNullBitmap);
 562
 563 #if wxUSE_PALETTE
 564 #ifndef __WXGTK__
 565         if (bitmap.GetPalette())
 566             memDC.SetPalette(wxNullPalette);
 567 #endif
 568 #endif // wxUSE_PALETTE
 569     }
 570     // No second bitmap, so draw a thick line around bitmap, or invert if mono
 571     else if ( tool->IsToggled() )
 572     {
 573         bool drawBorder = false;
 574 #ifdef __X__ // X doesn't invert properly on colour
 575         drawBorder = wxColourDisplay();
 576 #else       // Inversion works fine under Windows
 577         drawBorder = false;
 578 #endif
 579
 580         if (!drawBorder)
 581         {
 582             memDC.SelectObject(tool->GetNormalBitmap());
 583             dc.Blit(tool->m_x, tool->m_y, tool->GetWidth(), tool->GetHeight(),
 584                     &memDC, 0, 0, wxSRC_INVERT);
 585             memDC.SelectObject(wxNullBitmap);
 586         }
 587         else
 588         {
 589             bitmap = tool->GetNormalBitmap();
 590
 591             if (m_windowStyle & wxTB_3DBUTTONS)
 592             {
 593                 int ax = (int)tool->m_x,
 594                 ay = (int)tool->m_y,
 595                 bx = (int)(tool->m_x+tool->GetWidth()),
 596                 by = (int)(tool->m_y+tool->GetHeight());
 597
 598                 memDC.SelectObject(bitmap);
 599                 dc.SetClippingRegion(ax, ay, (bx-ax+1), (by-ay+1));
 600                 dc.Blit((ax+2), (ay+2), (bx-ax-2), (by-ay-2), &memDC, 0, 0);
 601                 wxPen * old_pen = & dc.GetPen();
 602                 dc.SetPen( black_pen );
 603                 dc.DrawLine(ax,(by-1),ax,ay);
 604                 dc.DrawLine(ax,ay,(bx-1),ay);
 605                 dc.SetPen( dark_grey_pen );
 606                 dc.DrawLine((ax+1),(by-2),(ax+1),(ay+1));
 607                 dc.DrawLine((ax+1),(ay+1),(bx-2),(ay+1));
 608                 dc.SetPen( white_pen );
 609                 dc.DrawLine(bx,ay,bx,by);
 610                 dc.DrawLine(bx,by,ax,by);
 611                 dc.SetPen( *old_pen );
 612                 dc.DestroyClippingRegion();
 613                 memDC.SelectObject(wxNullBitmap);
 614             }
 615             else
 616             {
 617                 wxCoord x = tool->m_x;
 618                 wxCoord y = tool->m_y;
 619                 wxCoord w = bitmap.GetWidth();
 620                 wxCoord h = bitmap.GetHeight();
 621                 wxPen thick_black_pen(wxT("BLACK"), 3, wxSOLID);
 622
 623                 memDC.SelectObject(bitmap);
 624                 dc.SetClippingRegion(tool->m_x, tool->m_y, w, h);
 625                 dc.Blit(tool->m_x, tool->m_y, w, h,
 626                         &memDC, 0, 0);
 627                 dc.SetPen(thick_black_pen);
 628                 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 629                 dc.DrawRectangle(x, y, w-1, h-1);
 630                 dc.DestroyClippingRegion();
 631                 memDC.SelectObject(wxNullBitmap);
 632             }
 633         }
 634     }
 635 }
 636
 637 // ----------------------------------------------------------------------------
 638 // toolbar geometry
 639 // ----------------------------------------------------------------------------
 640
 641 void wxToolBarSimple::SetRows(int nRows)
 642 {
 643     wxCHECK_RET( nRows != 0, _T("max number of rows must be > 0") );
 644
 645     m_maxCols = (GetToolsCount() + nRows - 1) / nRows;
 646
 647     AdjustScrollbars();
 648     Refresh();
 649 }
 650
 651 wxToolBarToolBase *wxToolBarSimple::FindToolForPosition(wxCoord x,
 652                                                         wxCoord y) const
 653 {
 654     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 655     while (node)
 656     {
 657         wxToolBarToolSimple *tool = (wxToolBarToolSimple *)node->GetData();
 658         if ((x >= tool->m_x) && (y >= tool->m_y) &&
 659             (x <= (tool->m_x + tool->GetWidth())) &&
 660             (y <= (tool->m_y + tool->GetHeight())))
 661         {
 662             return tool;
 663         }
 664
 665         node = node->GetNext();
 666     }
 667
 668     return (wxToolBarToolBase *)NULL;
 669 }
 670
 671 // ----------------------------------------------------------------------------
 672 // tool state change handlers
 673 // ----------------------------------------------------------------------------
 674
 675 void wxToolBarSimple::DoEnableTool(wxToolBarToolBase *tool,
 676                                    bool WXUNUSED(enable))
 677 {
 678     DrawTool(tool);
 679 }
 680
 681 void wxToolBarSimple::DoToggleTool(wxToolBarToolBase *tool,
 682                                    bool WXUNUSED(toggle))
 683 {
 684     DrawTool(tool);
 685 }
 686
 687 void wxToolBarSimple::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
 688                                   bool WXUNUSED(toggle))
 689 {
 690     // nothing to do
 691 }
 692
 693 // Okay, so we've left the tool we're in ... we must check if the tool we're
 694 // leaving was a 'sprung push button' and if so, spring it back to the up
 695 // state.
 696 void wxToolBarSimple::SpringUpButton(int id)
 697 {
 698     wxToolBarToolBase *tool = FindById(id);
 699
 700     if ( tool && tool->CanBeToggled() )
 701     {
 702         if (tool->IsToggled())
 703             tool->Toggle();
 704
 705         DrawTool(tool);
 706     }
 707 }
 708
 709 // ----------------------------------------------------------------------------
 710 // scrolling implementation
 711 // ----------------------------------------------------------------------------
 712
 713 /*
 714  * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
 715  * noUnitsX/noUnitsY:        : no. units per scrollbar
 716  */
 717 void wxToolBarSimple::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
 718                                    int noUnitsX, int noUnitsY,
 719                                    int xPos, int yPos)
 720 {
 721     m_xScrollPixelsPerLine = pixelsPerUnitX;
 722     m_yScrollPixelsPerLine = pixelsPerUnitY;
 723     m_xScrollLines = noUnitsX;
 724     m_yScrollLines = noUnitsY;
 725
 726     int w, h;
 727     GetSize(&w, &h);
 728
 729     // Recalculate scroll bar range and position
 730     if (m_xScrollLines > 0)
 731     {
 732         m_xScrollPosition = xPos;
 733         SetScrollPos (wxHORIZONTAL, m_xScrollPosition, true);
 734     }
 735     else
 736     {
 737         SetScrollbar(wxHORIZONTAL, 0, 0, 0, false);
 738         m_xScrollPosition = 0;
 739     }
 740
 741     if (m_yScrollLines > 0)
 742     {
 743         m_yScrollPosition = yPos;
 744         SetScrollPos (wxVERTICAL, m_yScrollPosition, true);
 745     }
 746     else
 747     {
 748         SetScrollbar(wxVERTICAL, 0, 0, 0, false);
 749         m_yScrollPosition = 0;
 750     }
 751     AdjustScrollbars();
 752     Refresh();
 753
 754 #if 0 //def __WXMSW__
 755     ::UpdateWindow ((HWND) GetHWND());
 756 #endif
 757 }
 758
 759 void wxToolBarSimple::OnScroll(wxScrollEvent& event)
 760 {
 761     int orient = event.GetOrientation();
 762
 763     int nScrollInc = CalcScrollInc(event);
 764     if (nScrollInc == 0)
 765         return;
 766
 767     if (orient == wxHORIZONTAL)
 768     {
 769         int newPos = m_xScrollPosition + nScrollInc;
 770         SetScrollPos(wxHORIZONTAL, newPos, true );
 771     }
 772     else
 773     {
 774         int newPos = m_yScrollPosition + nScrollInc;
 775         SetScrollPos(wxVERTICAL, newPos, true );
 776     }
 777
 778     if (orient == wxHORIZONTAL)
 779     {
 780         if (m_xScrollingEnabled)
 781             ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, NULL);
 782         else
 783             Refresh();
 784     }
 785     else
 786     {
 787         if (m_yScrollingEnabled)
 788             ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, NULL);
 789         else
 790             Refresh();
 791     }
 792
 793     if (orient == wxHORIZONTAL)
 794     {
 795         m_xScrollPosition += nScrollInc;
 796     }
 797     else
 798     {
 799         m_yScrollPosition += nScrollInc;
 800     }
 801
 802 }
 803
 804 int wxToolBarSimple::CalcScrollInc(wxScrollEvent& event)
 805 {
 806     int pos = event.GetPosition();
 807     int orient = event.GetOrientation();
 808
 809     int nScrollInc = 0;
 810     if (event.GetEventType() == wxEVT_SCROLL_TOP)
 811     {
 812             if (orient == wxHORIZONTAL)
 813                 nScrollInc = - m_xScrollPosition;
 814             else
 815                 nScrollInc = - m_yScrollPosition;
 816     } else
 817     if (event.GetEventType() == wxEVT_SCROLL_BOTTOM)
 818     {
 819             if (orient == wxHORIZONTAL)
 820                 nScrollInc = m_xScrollLines - m_xScrollPosition;
 821             else
 822                 nScrollInc = m_yScrollLines - m_yScrollPosition;
 823     } else
 824     if (event.GetEventType() == wxEVT_SCROLL_LINEUP)
 825     {
 826             nScrollInc = -1;
 827     } else
 828     if (event.GetEventType() == wxEVT_SCROLL_LINEDOWN)
 829     {
 830             nScrollInc = 1;
 831     } else
 832     if (event.GetEventType() == wxEVT_SCROLL_PAGEUP)
 833     {
 834             if (orient == wxHORIZONTAL)
 835                 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
 836             else
 837                 nScrollInc = -GetScrollPageSize(wxVERTICAL);
 838     } else
 839     if (event.GetEventType() == wxEVT_SCROLL_PAGEDOWN)
 840     {
 841             if (orient == wxHORIZONTAL)
 842                 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
 843             else
 844                 nScrollInc = GetScrollPageSize(wxVERTICAL);
 845     } else
 846     if ((event.GetEventType() == wxEVT_SCROLL_THUMBTRACK) ||
 847         (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE))
 848     {
 849             if (orient == wxHORIZONTAL)
 850                 nScrollInc = pos - m_xScrollPosition;
 851             else
 852                 nScrollInc = pos - m_yScrollPosition;
 853     }
 854
 855     if (orient == wxHORIZONTAL)
 856     {
 857         int w, h;
 858         GetClientSize(&w, &h);
 859
 860         int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 861         int noPositions = (int) ( ((nMaxWidth - w)/(float)m_xScrollPixelsPerLine) + 0.5 );
 862         if (noPositions < 0)
 863             noPositions = 0;
 864
 865         if ( (m_xScrollPosition + nScrollInc) < 0 )
 866             nScrollInc = -m_xScrollPosition; // As -ve as we can go
 867         else if ( (m_xScrollPosition + nScrollInc) > noPositions )
 868             nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
 869
 870         return nScrollInc;
 871     }
 872     else
 873     {
 874         int w, h;
 875         GetClientSize(&w, &h);
 876
 877         int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 878         int noPositions = (int) ( ((nMaxHeight - h)/(float)m_yScrollPixelsPerLine) + 0.5 );
 879         if (noPositions < 0)
 880             noPositions = 0;
 881
 882         if ( (m_yScrollPosition + nScrollInc) < 0 )
 883             nScrollInc = -m_yScrollPosition; // As -ve as we can go
 884         else if ( (m_yScrollPosition + nScrollInc) > noPositions )
 885             nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
 886
 887         return nScrollInc;
 888     }
 889 }
 890
 891 // Adjust the scrollbars - new version.
 892 void wxToolBarSimple::AdjustScrollbars()
 893 {
 894     int w, h;
 895     GetClientSize(&w, &h);
 896
 897     // Recalculate scroll bar range and position
 898     if (m_xScrollLines > 0)
 899     {
 900         int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 901         int newRange = (int) ( ((nMaxWidth)/(float)m_xScrollPixelsPerLine) + 0.5 );
 902         if (newRange < 0)
 903             newRange = 0;
 904
 905         m_xScrollPosition = wxMin(newRange, m_xScrollPosition);
 906
 907         // Calculate page size i.e. number of scroll units you get on the
 908         // current client window
 909         int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 );
 910         if (noPagePositions < 1)
 911             noPagePositions = 1;
 912
 913         SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, newRange);
 914         SetScrollPageSize(wxHORIZONTAL, noPagePositions);
 915     }
 916     if (m_yScrollLines > 0)
 917     {
 918         int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 919         int newRange = (int) ( ((nMaxHeight)/(float)m_yScrollPixelsPerLine) + 0.5 );
 920         if (newRange < 0)
 921             newRange = 0;
 922
 923         m_yScrollPosition = wxMin(newRange, m_yScrollPosition);
 924
 925         // Calculate page size i.e. number of scroll units you get on the
 926         // current client window
 927         int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 );
 928         if (noPagePositions < 1)
 929             noPagePositions = 1;
 930
 931         SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, newRange);
 932         SetScrollPageSize(wxVERTICAL, noPagePositions);
 933     }
 934 }
 935
 936 // Prepare the DC by translating it according to the current scroll position
 937 void wxToolBarSimple::PrepareDC(wxDC& dc)
 938 {
 939     dc.SetDeviceOrigin(- m_xScrollPosition * m_xScrollPixelsPerLine, - m_yScrollPosition * m_yScrollPixelsPerLine);
 940 }
 941
 942 void wxToolBarSimple::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 943 {
 944       *x_unit = m_xScrollPixelsPerLine;
 945       *y_unit = m_yScrollPixelsPerLine;
 946 }
 947
 948 int wxToolBarSimple::GetScrollPageSize(int orient) const
 949 {
 950     if ( orient == wxHORIZONTAL )
 951         return m_xScrollLinesPerPage;
 952     else
 953         return m_yScrollLinesPerPage;
 954 }
 955
 956 void wxToolBarSimple::SetScrollPageSize(int orient, int pageSize)
 957 {
 958     if ( orient == wxHORIZONTAL )
 959         m_xScrollLinesPerPage = pageSize;
 960     else
 961         m_yScrollLinesPerPage = pageSize;
 962 }
 963
 964 /*
 965  * Scroll to given position (scroll position, not pixel position)
 966  */
 967 void wxToolBarSimple::Scroll (int x_pos, int y_pos)
 968 {
 969     int old_x, old_y;
 970     ViewStart (&old_x, &old_y);
 971     if (((x_pos == wxDefaultCoord) || (x_pos == old_x)) && ((y_pos == wxDefaultCoord) || (y_pos == old_y)))
 972         return;
 973
 974     if (x_pos != wxDefaultCoord)
 975     {
 976         m_xScrollPosition = x_pos;
 977         SetScrollPos (wxHORIZONTAL, x_pos, true);
 978     }
 979     if (y_pos != wxDefaultCoord)
 980     {
 981         m_yScrollPosition = y_pos;
 982         SetScrollPos (wxVERTICAL, y_pos, true);
 983     }
 984     Refresh();
 985
 986 #if 0 //def __WXMSW__
 987     UpdateWindow ((HWND) GetHWND());
 988 #endif
 989 }
 990
 991 void wxToolBarSimple::EnableScrolling (bool x_scroll, bool y_scroll)
 992 {
 993     m_xScrollingEnabled = x_scroll;
 994     m_yScrollingEnabled = y_scroll;
 995 }
 996
 997 void wxToolBarSimple::GetVirtualSize (int *x, int *y) const
 998 {
 999     *x = m_xScrollPixelsPerLine * m_xScrollLines;
1000     *y = m_yScrollPixelsPerLine * m_yScrollLines;
1001 }
1002
1003 // Where the current view starts from
1004 void wxToolBarSimple::ViewStart (int *x, int *y) const
1005 {
1006     *x = m_xScrollPosition;
1007     *y = m_yScrollPosition;
1008 }
1009
1010 #endif // wxUSE_TOOLBAR_SIMPLE
1011