contrib/src/fl/dyntbar.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dyntbar.cpp
   3 // Purpose:     wxDynamicToolBar implementation
   4 // Author:      Aleksandras Gluchovas
   5 // Modified by:
   6 // Created:     ??/10/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Aleksandras Gluchovas
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "dyntbar.h"
  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 "wx/utils.h"     // import wxMin,wxMax macros
  28
  29 #include "wx/fl/dyntbar.h"
  30 #include "wx/fl/newbmpbtn.h"
  31
  32 IMPLEMENT_DYNAMIC_CLASS( wxDynamicToolBar, wxObject )
  33
  34 BEGIN_EVENT_TABLE( wxDynamicToolBar, wxToolBarBase )
  35
  36     EVT_SIZE ( wxDynamicToolBar::OnSize  )
  37     EVT_PAINT( wxDynamicToolBar::OnPaint )
  38     //EVT_ERASE_BACKGROUND( wxDynamicToolBar::OnEraseBackground )
  39
  40 END_EVENT_TABLE()
  41
  42 /***** Implementation for class wxToolLayoutItem *****/
  43
  44 IMPLEMENT_DYNAMIC_CLASS(wxToolLayoutItem, wxObject)
  45
  46
  47 /***** Implementation for class wxDynToolInfo *****/
  48
  49 IMPLEMENT_DYNAMIC_CLASS(wxDynToolInfo, wxToolLayoutItem)
  50
  51 /***** Implementation for class wxDynamicToolBar *****/
  52
  53 wxDynamicToolBar::wxDynamicToolBar()
  54     : mpLayoutMan( NULL ),
  55       mSepartorSize( 8 ),
  56       mVertGap ( 0 ),
  57       mHorizGap( 0 )
  58 {
  59 }
  60
  61 wxDynamicToolBar::wxDynamicToolBar(wxWindow *parent, const wxWindowID id,
  62                                    const wxPoint& pos, const wxSize& size,
  63                                    const long style, const int orientation,
  64                                    const int RowsOrColumns, const wxString& name )
  65     : mpLayoutMan( NULL ),
  66       mSepartorSize( 8 ),
  67       mVertGap ( 0 ),
  68       mHorizGap( 0 )
  69 {
  70     Create(parent, id, pos, size, style, orientation, RowsOrColumns, name);
  71
  72     SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE) );
  73 }
  74
  75 bool wxDynamicToolBar::Create(wxWindow *parent, const wxWindowID id,
  76                               const wxPoint& pos,
  77                               const wxSize& size,
  78                               const long style,
  79                               const int WXUNUSED(orientation), const int WXUNUSED(RowsOrColumns),
  80                               const wxString& name)
  81 {
  82     // cut&pasted from wxtbatsmpl.h
  83
  84     if ( ! wxWindow::Create(parent, id, pos, size, style, name) )
  85         return false;
  86
  87     SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ));
  88
  89     return true;
  90 }
  91
  92 bool wxDynamicToolBar::Realize(void)
  93 {
  94     // FOR NOW:: nothing
  95     return true;
  96 }
  97
  98 wxDynamicToolBar::~wxDynamicToolBar(void)
  99 {
 100     if ( mpLayoutMan )
 101         delete mpLayoutMan;
 102
 103     size_t i;
 104     for( i = 0; i != mTools.Count(); ++i )
 105     {
 106         delete mTools[i];
 107     }
 108 }
 109
 110 void wxDynamicToolBar::AddTool( int toolIndex,
 111                                 wxWindow* pToolWindow,
 112                                 const wxSize& WXUNUSED(size)
 113                               )
 114 {
 115     wxDynToolInfo* pInfo = new wxDynToolInfo();
 116
 117     pInfo->mpToolWnd    = pToolWindow;
 118     pInfo->mIndex       = toolIndex;
 119     pInfo->mIsSeparator    = false;
 120
 121     int x,y;
 122     pToolWindow->GetSize( &x, &y );
 123     pInfo->mRealSize.x = x;
 124     pInfo->mRealSize.y = y;
 125     pInfo->mRect.width = x;
 126     pInfo->mRect.height = y;
 127
 128     mTools.Add( pInfo );
 129 }
 130
 131 void wxDynamicToolBar::AddTool( int toolIndex,
 132                                 const wxString& imageFileName,
 133                                 wxBitmapType imageFileType,
 134                                 const wxString& labelText, bool alignTextRight,
 135                                 bool isFlat )
 136 {
 137     wxNewBitmapButton* pBtn =
 138
 139       new wxNewBitmapButton( imageFileName, imageFileType,
 140                              labelText,
 141                              ( alignTextRight )
 142                              ? NB_ALIGN_TEXT_RIGHT
 143                              : NB_ALIGN_TEXT_BOTTOM,
 144                              isFlat
 145                            );
 146
 147     pBtn->Create( this, toolIndex );
 148
 149     pBtn->Reshape();
 150
 151     AddTool( toolIndex, pBtn );
 152 }
 153 void wxDynamicToolBar::AddTool( int toolIndex, wxBitmap labelBmp,
 154                                 const wxString& labelText, bool alignTextRight,
 155                                 bool isFlat )
 156 {
 157     wxNewBitmapButton* pBtn =
 158
 159       new wxNewBitmapButton( labelBmp,
 160                              labelText,
 161                              ( alignTextRight )
 162                              ? NB_ALIGN_TEXT_RIGHT
 163                              : NB_ALIGN_TEXT_BOTTOM,
 164                              isFlat
 165                            );
 166
 167     pBtn->Create( this, toolIndex );
 168
 169     pBtn->Reshape();
 170
 171     AddTool( toolIndex, pBtn );
 172 }
 173
 174
 175 wxToolBarToolBase*
 176       wxDynamicToolBar::AddTool(const int toolIndex, const wxBitmap& bitmap,
 177                                 const wxBitmap& WXUNUSED(pushedBitmap),
 178                                 const bool WXUNUSED(toggle), const long WXUNUSED(xPos),
 179                                 const long WXUNUSED(yPos), wxObject *WXUNUSED(clientData),
 180                                 const wxString& helpString1, const wxString& WXUNUSED(helpString2))
 181 {
 182     wxNewBitmapButton* pBmpBtn = new wxNewBitmapButton( bitmap );
 183
 184     pBmpBtn->Create( this, toolIndex );
 185
 186     pBmpBtn->Reshape();
 187
 188 #if wxUSE_TOOLTIPS
 189     pBmpBtn->SetToolTip( helpString1 );
 190 #endif  // wxUSE_TOOLTIPS
 191
 192     AddTool( toolIndex, pBmpBtn );
 193
 194     return NULL;
 195 }
 196
 197
 198 wxDynToolInfo* wxDynamicToolBar::GetToolInfo( int toolIndex )
 199 {
 200     size_t i;
 201     for( i = 0; i != mTools.Count(); ++i )
 202     {
 203         if ( mTools[i]->mIndex == toolIndex )
 204             return mTools[i];
 205     }
 206
 207     return NULL;
 208 }
 209
 210 void wxDynamicToolBar::RemveTool( int toolIndex )
 211 {
 212     size_t i;
 213     for( i = 0; i != mTools.Count(); ++i )
 214     {
 215         if ( mTools[i]->mIndex == toolIndex )
 216         {
 217             if ( mTools[i]->mpToolWnd )
 218             {
 219                 mTools[i]->mpToolWnd->Destroy();
 220             }
 221             delete mTools[i]; // HVL To be tested!!!
 222 #if wxCHECK_VERSION(2,3,2)
 223             mTools.RemoveAt(i);
 224 #else
 225             mTools.Remove(i);
 226 #endif
 227             Layout();
 228
 229             return;
 230         }
 231     }
 232     // TODO:: if not found, should it be an assertion?
 233 }
 234
 235 void wxDynamicToolBar::AddSeparator( wxWindow* pSepartorWnd )
 236 {
 237     wxDynToolInfo* pInfo = new wxDynToolInfo();
 238
 239     pInfo->mpToolWnd    = pSepartorWnd;
 240     pInfo->mIndex       = -1;
 241     pInfo->mIsSeparator = true;
 242
 243     // Do we draw a separator or is a other object?
 244     if ( pSepartorWnd )
 245     {
 246         // hvl => Is there a way to know if it was already created?
 247         // hvl => shouldn't the pSepartorWnd be created? (like one should expect?)
 248         // pSepartorWnd->Create( this, -1 );
 249
 250         int x,y;
 251         pSepartorWnd->GetSize( &x, &y );
 252         pInfo->mRealSize.x = x;
 253         pInfo->mRealSize.y = y;
 254
 255         pInfo->mRect.width = x;
 256         pInfo->mRect.height = y;
 257     }
 258     else
 259     {
 260         // Init x and y to the default.
 261         pInfo->mRealSize.x = 0;
 262         pInfo->mRealSize.y = 0;
 263
 264         // Init height and width to the normal size of a separator.
 265         pInfo->mRect.width  = mSepartorSize;
 266         pInfo->mRect.height = mSepartorSize;
 267     }
 268
 269     mTools.Add( pInfo );
 270 }
 271
 272 void wxDynamicToolBar::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 273 {
 274     // FOR NOW:: nothing
 275 }
 276
 277 void wxDynamicToolBar::OnSize( wxSizeEvent& WXUNUSED(event) )
 278 {
 279     //SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
 280
 281     Layout();
 282 }
 283
 284 void wxDynamicToolBar::DrawSeparator( wxDynToolInfo& info, wxDC& dc )
 285 {
 286     // check the orientation of separator
 287     if ( info.mRect.width < info.mRect.height )
 288     {
 289         int midX = info.mRect.x + info.mRect.width/2 - 1;
 290
 291         dc.SetPen( *wxGREY_PEN );
 292         dc.DrawLine( midX, info.mRect.y,
 293                      midX, info.mRect.y + info.mRect.height+1 );
 294
 295         dc.SetPen( *wxWHITE_PEN );
 296         dc.DrawLine( midX+1, info.mRect.y,
 297                      midX+1, info.mRect.y + info.mRect.height+1 );
 298     }
 299     else
 300     {
 301         int midY = info.mRect.y + info.mRect.height/2 - 1;
 302
 303         dc.SetPen( *wxGREY_PEN );
 304         dc.DrawLine( info.mRect.x, midY,
 305                      info.mRect.x + info.mRect.width+1, midY );
 306
 307         dc.SetPen( *wxWHITE_PEN );
 308         dc.DrawLine( info.mRect.x, midY + 1,
 309                      info.mRect.x + info.mRect.width+1, midY + 1 );
 310     }
 311 }
 312
 313 void wxDynamicToolBar::OnPaint( wxPaintEvent& WXUNUSED(event) )
 314 {
 315     // draw separators if any
 316     wxPaintDC dc(this);
 317
 318     size_t i;
 319     for( i = 0; i != mTools.Count(); ++i )
 320     {
 321         if ( mTools[i]->mIsSeparator )
 322         {
 323             // check if separator doesn't have it's own window
 324             // if so, then draw it using built-in drawing method
 325             if ( !mTools[i]->mpToolWnd )
 326                 DrawSeparator( *mTools[i], dc );
 327         }
 328     }
 329 }
 330
 331 // FOR NOW:: quick fix
 332 #include "wx/choice.h"
 333
 334 void wxDynamicToolBar::SizeToolWindows()
 335 {
 336     bool bStateCheckDone = false;
 337     bool bHorzSeparator  = false;
 338     int maxWidth         = 0;
 339     int maxHeight        = 0;
 340
 341     size_t i;
 342     for( i = 0; i != mTools.Count(); ++i )
 343     {
 344         wxDynToolInfo& info = *mTools[i];
 345
 346         if ( !info.mIsSeparator )
 347         {
 348             // center real rectangle within the rectangle
 349             // provided by the layout manager
 350
 351             int x = info.mRect.x;
 352             int y = info.mRect.y + (info.mRect.height - info.mRealSize.y)/2;
 353
 354             // FOR NOW FOR NOW:: quick & dirty fix
 355             if ( info.mpToolWnd->IsKindOf( CLASSINFO( wxChoice ) ) )
 356             {
 357                 info.mpToolWnd->SetSize( x, y,
 358                                          info.mRealSize.x - 3,
 359                                          info.mRealSize.y);
 360             }
 361             else
 362             {
 363                 info.mpToolWnd->SetSize( x, y,
 364                                          info.mRealSize.x,
 365                                          info.mRealSize.y );
 366             }
 367         }
 368         else
 369         {
 370             // We performer this code here, so we only execute it when we have
 371             // separators and we do it only once (all to do with performance...)
 372             if (!bStateCheckDone)
 373             {
 374                 bStateCheckDone = true;
 375
 376                 size_t j;
 377                 wxDynToolInfo *pInfo;
 378                 wxDynToolInfo *pPrevInfo = NULL;
 379                 int nVertSeparators = 0;
 380
 381                 for( j = 0; j != mTools.Count(); ++j )
 382                 {
 383                     pInfo = mTools[j];
 384
 385                     // Count all Vert Separators.
 386                     if ( pInfo->mIsSeparator )
 387                         nVertSeparators++;
 388
 389                     // Check if the new row starts with a Separator.
 390                     if ( pPrevInfo && pInfo->mIsSeparator &&
 391                          // pPrevInfo->mRect.x >= pInfo->mRect.x &&
 392                          pPrevInfo->mRect.y < pInfo->mRect.y)
 393                     {
 394                         // If the Separator is shown on the next row and it's
 395                         // the only object on the row it would mean that the
 396                         // Separator should be shown as Horizontal one.
 397                         if (j+1 != mTools.Count())
 398                         {
 399                             if (pInfo->mRect.y < mTools[j+1]->mRect.y)
 400                                 nVertSeparators--;
 401                         }
 402                         else
 403                         {
 404                             nVertSeparators--;
 405                         }
 406                     }
 407
 408                     pPrevInfo = pInfo;
 409
 410                     maxWidth = wxMax(pInfo->mRect.width, maxWidth);
 411                     maxHeight = wxMax(pInfo->mRect.height, maxHeight);
 412                 }
 413
 414                 bHorzSeparator = nVertSeparators == 0;
 415             }
 416
 417             // Check if we should draw Horz or Vert...
 418             if ( !bHorzSeparator )
 419             {
 420                 info.mRect.width = mSepartorSize;
 421                 info.mRect.height = maxHeight;
 422             }
 423             else
 424             {
 425                 info.mRect.width = maxWidth;
 426                 info.mRect.height = mSepartorSize;
 427             }
 428
 429             // Do we need to set a new size to a separator object?
 430             if ( info.mpToolWnd )
 431             {
 432                 info.mpToolWnd->SetSize( info.mRect.x,
 433                                          info.mRect.y,
 434                                          info.mRect.width,
 435                                          info.mRect.height);
 436             }
 437
 438         }
 439     }
 440 }
 441
 442 bool wxDynamicToolBar::Layout()
 443 {
 444     int x,y;
 445     GetSize( &x, &y );
 446     wxSize wndDim(x,y);
 447     wxSize result;
 448     size_t i;
 449     wxDynToolInfo *pInfo;
 450
 451     // Reset the size of separators...
 452     for( i = 0; i != mTools.Count(); ++i )
 453     {
 454         pInfo = mTools[i];
 455
 456         if ( pInfo->mIsSeparator )
 457         {
 458             pInfo->mRect.width  = mSepartorSize;
 459             pInfo->mRect.height = mSepartorSize;
 460         }
 461     }
 462
 463     // Calc and set the best layout
 464     GetPreferredDim( wndDim, result );
 465
 466     SizeToolWindows();
 467     return true;
 468 }
 469
 470 void wxDynamicToolBar::GetPreferredDim( const wxSize& givenDim, wxSize& prefDim )
 471 {
 472     if ( !mpLayoutMan )
 473         mpLayoutMan = CreateDefaultLayout();
 474
 475     wxLayoutItemArrayT items;
 476
 477     // safe conversion
 478     size_t i;
 479     for( i = 0; i != mTools.Count(); ++i )
 480         items.Add( mTools[i] );
 481
 482     mpLayoutMan->Layout( givenDim, prefDim, items, mVertGap, mHorizGap );
 483 }
 484
 485 void wxDynamicToolBar::SetLayout( LayoutManagerBase* pLayout )
 486 {
 487     if ( mpLayoutMan )
 488         delete mpLayoutMan;
 489
 490     mpLayoutMan = pLayout;
 491
 492     Layout();
 493 }
 494
 495 void wxDynamicToolBar::EnableTool(int toolIndex, bool enable )
 496 {
 497     wxDynToolInfo* pInfo = GetToolInfo( toolIndex );
 498
 499     if ( !pInfo )
 500         return;
 501
 502     if ( pInfo->mIsSeparator || !pInfo->mpToolWnd )
 503         return;
 504
 505     pInfo->mpToolWnd->Enable( enable );
 506 }
 507
 508 /***** Implementation for class BagLayout *****/
 509
 510 void BagLayout::Layout(  const wxSize&       parentDim,
 511                          wxSize&             resultingDim,
 512                          wxLayoutItemArrayT& items,
 513                          int                 horizGap,
 514                          int                 vertGap
 515                       )
 516 {
 517     int maxWidth = 0;
 518     int curY  = 0;
 519     int nRows = 0;
 520
 521     size_t i = 0;
 522
 523     while( i < items.Count() )
 524     {
 525         int curX   = 0;
 526         int height = 0;
 527         // int nItems = 0;
 528
 529         // int firstItem  = i;
 530         int itemsInRow = 0;
 531
 532         if ( nRows > 0 )
 533             curY += vertGap;
 534
 535         // step #1 - arrange horizontal positions of items in the row
 536
 537         do
 538         {
 539             if ( itemsInRow > 0 )
 540                 curX += horizGap;
 541
 542             wxRect& r = items[i]->mRect;
 543
 544             if ( curX + r.width > parentDim.x )
 545             {
 546                 if ( itemsInRow > 0 )
 547                     break;
 548             }
 549             r.x = curX;
 550             r.y = curY;
 551
 552             curX += r.width;
 553
 554             height = wxMax( height, r.height );
 555
 556             ++itemsInRow;
 557             ++i;
 558
 559         } while( i < items.Count() );
 560
 561         curY += height;
 562
 563         maxWidth = wxMax( maxWidth, curX );
 564     }
 565
 566     resultingDim.x = maxWidth;
 567     resultingDim.y = curY;
 568 }
 569
 570 //////// stuff from 2.1.15 ///////////
 571
 572 wxToolBarToolBase* wxDynamicToolBar::FindToolForPosition( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y) ) const
 573 {
 574     return NULL;
 575 }
 576
 577 bool wxDynamicToolBar::DoInsertTool( size_t WXUNUSED(pos), wxToolBarToolBase* WXUNUSED(tool) )
 578 {
 579     return true;
 580 }
 581
 582 bool wxDynamicToolBar::DoDeleteTool( size_t WXUNUSED(pos), wxToolBarToolBase* WXUNUSED(tool) )
 583 {
 584     return true;
 585 }
 586
 587 void wxDynamicToolBar::DoEnableTool( wxToolBarToolBase* WXUNUSED(tool), bool WXUNUSED(enable) )
 588 {
 589 }
 590
 591 void wxDynamicToolBar::DoToggleTool( wxToolBarToolBase* WXUNUSED(tool), bool WXUNUSED(toggle) )
 592 {
 593 }
 594
 595 void wxDynamicToolBar::DoSetToggle( wxToolBarToolBase* WXUNUSED(tool), bool WXUNUSED(toggle) )
 596 {
 597 }
 598
 599 wxToolBarToolBase* wxDynamicToolBar::CreateTool( int WXUNUSED(id),
 600                                                  const wxString& WXUNUSED(label),
 601                                                  const wxBitmap& WXUNUSED(bmpNormal),
 602                                                  const wxBitmap& WXUNUSED(bmpDisabled),
 603                                                  wxItemKind WXUNUSED(kind),
 604                                                  wxObject *WXUNUSED(clientData),
 605                                                  const wxString& WXUNUSED(shortHelp),
 606                                                  const wxString& WXUNUSED(longHelp)
 607                                                 )
 608 {
 609     return NULL;
 610 }
 611
 612 wxToolBarToolBase* wxDynamicToolBar::CreateTool( wxControl* WXUNUSED(control) )
 613 {
 614     return NULL;
 615 }
 616