demos/dbbrowse/tabpgwin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        No names yet.
   3 // Purpose:     Contrib. demo
   4 // Author:      Aleksandras Gluchovas
   5 // Modified by: 19990908 : mj10777@gmx.net
   6 //              - rename to tabpgwin
   7 //              - restruction of Variable declaration
   8 //              - to prevent Warnings under MingGW32
   9 // Modified by: 19990909 : mj10777@gmx.net
  10 //              - mNoVertScroll TRUE = no / FALSE = Original Code
  11 //                the Original Code Paints a Vertical Scroll in wxPaggedWindow
  12 //                which is not needed in this Version. Use TRUE for this.
  13 // Created:     07/09/98
  14 // RCS-ID:      $Id$
  15 // Copyright:   (c) Aleksandras Gluchovas
  16 // Licence:    wxWindows license
  17 /////////////////////////////////////////////////////////////////////////////
  18
  19 #ifdef __GNUG__
  20 #pragma implementation "controlarea.h"
  21 // #pragma interface
  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 #ifndef WX_PRECOMP
  32 #include "wx/wx.h"
  33 #endif
  34
  35 #include <math.h>
  36 #include <stdlib.h>
  37
  38 #include "wx/string.h"
  39 #include "wx/utils.h"     // import wxMin/wxMax macros and wxFileExist(..)
  40
  41 #include "tabpgwin.h"
  42 //---------------------------------------------------------------------------
  43 // Implementation for class twTabInfo
  44 //---------------------------------------------------------------------------
  45 IMPLEMENT_DYNAMIC_CLASS( twTabInfo, wxObject )
  46   //---------------------------------------------------------------------------
  47   twTabInfo::twTabInfo()
  48     : mpContent( 0 )
  49 {}
  50 //---------------------------------------------------------------------------
  51 twTabInfo::~twTabInfo()
  52 {
  53   // FOR NOW:: nothing
  54 }
  55 //---------------------------------------------------------------------------
  56 int twTabInfo::ImgWidth()
  57 {
  58   if ( mBitMap.Ok() ) return mBitMap.GetWidth();
  59   else return 0;
  60 }
  61 //---------------------------------------------------------------------------
  62 int twTabInfo::ImgHeight()
  63 {
  64   if ( mBitMap.Ok() ) return mBitMap.GetHeight();
  65   else return 0;
  66 }
  67 //---------------------------------------------------------------------------
  68 int twTabInfo::ImageToTxtGap( int prefGap )
  69 {
  70   if ( mBitMap.Ok() ) return prefGap;
  71   else return 0;
  72 }
  73 //---------------------------------------------------------------------------
  74 bool twTabInfo::HasImg()
  75 {
  76   return mBitMap.Ok();
  77 }
  78 //---------------------------------------------------------------------------
  79 // bool twTabInfo::HasText();
  80 unsigned int twTabInfo::HasText()
  81 {
  82   return mText.Length();
  83 }
  84 //---------------------------------------------------------------------------
  85 wxBitmap& twTabInfo::GetImg()
  86 {
  87   return mBitMap;
  88 }
  89 //---------------------------------------------------------------------------
  90 wxString& twTabInfo::GetText()
  91 {
  92   return mText;
  93 }
  94 //---------------------------------------------------------------------------
  95 wxWindow& twTabInfo::GetContent()
  96 {
  97   return *mpContent;
  98 }
  99 //---------------------------------------------------------------------------
 100 // Implementation for class wxTabbedWindow
 101 //---------------------------------------------------------------------------
 102 IMPLEMENT_DYNAMIC_CLASS( wxTabbedWindow, wxPanel )
 103   //---------------------------------------------------------------------------
 104   BEGIN_EVENT_TABLE( wxTabbedWindow, wxPanel )
 105   EVT_SIZE ( wxTabbedWindow::OnSize )
 106   EVT_PAINT( wxTabbedWindow::OnPaint )
 107   EVT_LEFT_DOWN( wxTabbedWindow::OnLButtonDown )
 108   // TDB:: filciker reduction
 109   // EVT_ERASE_BACKGROUND( wxTabbedWindow::OnBkErase )
 110   END_EVENT_TABLE()
 111   //---------------------------------------------------------------------------
 112   wxTabbedWindow::wxTabbedWindow()
 113
 114     : mpTabScroll  ( NULL ),
 115       mpHorizScroll( NULL ),
 116       mpVertScroll ( NULL ),
 117
 118       mVertGap ( 0 ),
 119       mHorizGap( 0 ),
 120
 121       mTitleVertGap ( 3  ),
 122       mTitleHorizGap( 4  ),
 123       mImageTextGap ( 2  ),
 124       mFirstTitleGap( 11 ),
 125
 126       mBorderOnlyWidth( 8 ),
 127
 128       mWhitePen( wxColour(255,255,255), 1, wxSOLID ),
 129       mGrayPen ( wxColour(192,192,192), 1, wxSOLID ),
 130       mDarkPen ( wxColour(128,128,128), 1, wxSOLID ),
 131       mBlackPen( wxColour(  0,  0,  0), 1, wxSOLID ),
 132
 133       // state variables
 134
 135       mActiveTab  ( 0 ),
 136       mTitleHeight( 0 ),
 137       mLayoutType( wxTITLE_IMG_AND_TEXT )
 138 {}
 139 //---------------------------------------------------------------------------
 140 wxTabbedWindow::~wxTabbedWindow()
 141 {
 142   wxNode* pTab = mTabs.First();
 143
 144   while( pTab )
 145     {
 146       delete ((twTabInfo*)pTab->Data());
 147       pTab = pTab->Next();
 148     }
 149 }
 150 //---------------------------------------------------------------------------
 151 void wxTabbedWindow::SizeTabs(int x,int y, int width, int height, bool repant)
 152 {
 153   wxNode* pTabNode = mTabs.First();
 154   int n = 0;
 155
 156  while( pTabNode )
 157    {
 158      twTabInfo& info = *((twTabInfo*)pTabNode->Data());
 159
 160      if ( n == mActiveTab )
 161        {
 162          //wxSizeEvent evt;
 163          //info.mpContent->GetEventHandler()->ProcessEvent( evt );
 164
 165          info.mpContent->SetSize( x, y, width, height, 0 );
 166          info.mpContent->Show(TRUE);
 167          info.mpContent->Refresh();
 168
 169        }
 170      else
 171        {
 172          info.mpContent->Show(FALSE);
 173        }
 174
 175      pTabNode = pTabNode->Next();
 176      ++n;
 177    }
 178 }
 179 //---------------------------------------------------------------------------
 180 void wxTabbedWindow::AddTab( wxWindow* pContent,
 181                              wxString  tabText,
 182                              wxString  imageFileName,
 183                              long      imageType )
 184 {
 185   twTabInfo* pTab = new twTabInfo();
 186
 187   pTab->mpContent = pContent;
 188   pTab->mText     = tabText;
 189
 190   if ( wxFileExists( imageFileName ) &&
 191
 192        pTab->mBitMap.LoadFile( imageFileName, imageType ) )
 193     {
 194       pTab->mImageFile = imageFileName;
 195       pTab->mImageType = imageType;
 196     }
 197
 198
 199   if ( pContent->GetParent() == NULL )
 200     pContent->Create( this, -1 );
 201
 202   mTabs.Append( (wxObject*)pTab );
 203
 204   RecalcLayout(TRUE);
 205
 206   OnTabAdded( pTab );
 207 }
 208 //---------------------------------------------------------------------------
 209 void wxTabbedWindow::AddTab( wxWindow* pContent,
 210                              wxString  tabText, wxBitmap* pImage   )
 211 {
 212   twTabInfo* pTab = new twTabInfo();
 213
 214   pTab->mpContent = pContent;
 215   pTab->mText     = tabText;
 216
 217   if ( pImage )
 218     pTab->mBitMap = *pImage;
 219
 220   if ( pContent->GetParent() == NULL )
 221     pContent->Create( this, -1 );
 222
 223   mTabs.Append( (wxObject*)pTab );
 224   RecalcLayout(TRUE);
 225   OnTabAdded( pTab );
 226 }
 227 //---------------------------------------------------------------------------
 228 void wxTabbedWindow::RemoveTab( int tabNo )
 229 {
 230   twTabInfo* pTab = ((twTabInfo*)(mTabs.Nth( tabNo )->Data()));
 231   pTab->mpContent->Destroy();
 232   delete pTab;
 233   mTabs.DeleteNode( mTabs.Nth( tabNo ) );
 234   // if ( mActiveTab >= mTabs.Number() );
 235   if ( mActiveTab >= mTabs.Number() )
 236     mActiveTab = mTabs.Number() - 1;
 237   SetActiveTab( mActiveTab );
 238 }
 239 //---------------------------------------------------------------------------
 240 int wxTabbedWindow::GetTabCount()
 241 {
 242  return mTabs.Number();
 243 }
 244 //---------------------------------------------------------------------------
 245 wxWindow* wxTabbedWindow::GetTab( int tabNo )
 246 {
 247   return ((twTabInfo*)(mTabs.Nth( tabNo )->Data()))->mpContent;
 248 }
 249 //---------------------------------------------------------------------------
 250 wxWindow* wxTabbedWindow::GetActiveTab()
 251 {
 252   // FIMXE:: this is lame
 253   return GetTab( mActiveTab );
 254 }
 255 //---------------------------------------------------------------------------
 256 void wxTabbedWindow::SetActiveTab( int tabNo )
 257 {
 258   mActiveTab = tabNo;
 259   RecalcLayout(TRUE);
 260   Refresh();
 261 }
 262 //---------------------------------------------------------------------------
 263 // width of the decorations border (4 shade-lines), should not be changed
 264 //---------------------------------------------------------------------------
 265 #define BORDER_SZ 4
 266 //---------------------------------------------------------------------------
 267 void wxTabbedWindow::DrawShadedRect( int x, int y, int width, int height,
 268                                      wxPen& upperPen, wxPen& lowerPen, wxDC& dc
 269                                      )
 270 {
 271   // darw the lightened upper-left sides of the rectangle
 272
 273   dc.SetPen( upperPen );
 274   dc.DrawLine( x,y, x, y + height - 1 ); // vert
 275   dc.DrawLine( x,y, x + width - 1,  y ); // horiz
 276
 277   // draw the unenlightened lower-right sides of the rectangle
 278
 279   dc.SetPen( lowerPen );
 280   dc.DrawLine( x + width - 1,  y, x + width - 1, y + height - 1 ); // vert
 281   dc.DrawLine( x, y + height - 1, x + width, y + height - 1 );     // horiz
 282 }
 283 //---------------------------------------------------------------------------
 284 void wxTabbedWindow::DrawDecorations( wxDC& dc )
 285 {
 286   // Protability NOTE::: DrawLine(..) draws a line from the first position,
 287   //                     but not including the point specified by last position.
 288   //                     This way Windows draws lines, not sure how Motif and Gtk
 289   //                     prots behave...
 290
 291   int width, height;
 292   GetClientSize( &width, &height );
 293
 294   // check if there's at least a bit of space to draw things
 295
 296   if ( width  < mHorizGap*2 + BORDER_SZ*2+1 ||
 297        height < mVertGap*2  + BORDER_SZ*2+1 + mTitleHeight
 298        )
 299     return;
 300
 301   // step #1 - draw border around the tab content area
 302
 303   // setup position for kind of "pencil"
 304   int curX = mHorizGap;
 305   int curY = mVertGap;
 306
 307   int xSize = width  - mHorizGap*2;
 308   int ySize = height - mVertGap *2  - mTitleHeight;
 309
 310   // layer 1 (upper white)
 311   DrawShadedRect( curX+0, curY+0, xSize-0, ySize-0,
 312                   mWhitePen, mBlackPen, dc  );
 313
 314   // layer 2 (upper gray)
 315   DrawShadedRect( curX+1, curY+1, xSize-2-1, ySize-2-1,
 316                   mGrayPen, mGrayPen, dc  );
 317
 318   // layer 3 (upper darkGray)
 319   DrawShadedRect( curX+2, curY+2, xSize-3-2, ySize-3-2,
 320                   mDarkPen, mWhitePen, dc  );
 321
 322   // layer 4 (upper black)
 323   DrawShadedRect( curX+3, curY+3, xSize-4-3, ySize-4-3,
 324                   mBlackPen, mGrayPen, dc  );
 325
 326   // add non-siemtric layer from the lower-right side (confroming to MFC-look)
 327
 328   dc.SetPen( mDarkPen );
 329   dc.DrawLine( curX+1, curY + ySize - 2, curX + xSize - 1, curY + ySize - 2 );   // horiz
 330   dc.DrawLine( curX + xSize - 2, curY + 1, curX + xSize - 2, curY + ySize - 2 ); // vert
 331
 332   // step #2 - draw tab title bars
 333
 334   curX = mFirstTitleGap;
 335   curY = height - mVertGap - mTitleHeight;
 336
 337   int tabNo = 0;
 338   wxNode* pNode = mTabs.First();
 339
 340   while( pNode )
 341     {
 342       // "hard-coded metafile" for decorations
 343
 344       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 345
 346       xSize = tab.mDims.x;
 347       ySize = mTitleHeight;
 348
 349       if ( tabNo == mActiveTab )
 350         {
 351           dc.SetPen( mGrayPen );
 352           dc.DrawLine( curX+1, curY-2, curX+xSize-2, curY-2 );
 353           dc.DrawLine( curX+1, curY-1, curX+xSize-2, curY-1 );
 354         }
 355
 356       dc.SetPen( mWhitePen );
 357
 358   if ( tabNo == mActiveTab )
 359     dc.DrawLine( curX, curY-2, curX, curY+ySize-2 );
 360   else
 361     dc.DrawLine( curX, curY, curX, curY+ySize-2 );
 362
 363   dc.SetPen( mDarkPen );
 364   dc.DrawLine( curX+1, curY+ySize-3, curX+1, curY+ySize-1 ); // to pix down
 365   dc.DrawLine( curX+2, curY+ySize-2, curX+xSize-2, curY+ySize-2 );
 366   dc.DrawLine( curX+xSize-3, curY+ySize-3, curX+xSize-2, curY+ySize-3 );
 367   if ( tabNo == mActiveTab )
 368     dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-3 );
 369   else
 370     dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-1 );
 371
 372   dc.SetPen( mBlackPen );
 373   dc.DrawLine( curX+xSize-1, curY, curX+xSize-1, curY+ySize-2 );
 374   dc.DrawLine( curX+xSize-2, curY+ySize-2, curX+xSize-3, curY+ySize-2 );
 375   dc.DrawLine( curX+xSize-3, curY+ySize-1, curX+1, curY+ySize-1 );
 376
 377   pNode = pNode->Next();
 378   ++tabNo;
 379
 380   // darw image and (or without) text centered within the
 381   // title bar rectangle
 382
 383   if ( mLayoutType != wxTITLE_BORDER_ONLY && tab.HasImg() )
 384     {
 385       wxMemoryDC tmpDc;
 386       tmpDc.SelectObject( tab.GetImg() );
 387
 388       dc.Blit( curX + mTitleHorizGap,
 389                curY + ( ySize - tab.ImgHeight() ) / 2,
 390                tab.ImgWidth(),
 391                tab.ImgHeight(),
 392                &tmpDc, 0, 0, wxCOPY
 393                );
 394     }
 395
 396   if ( mLayoutType == wxTITLE_IMG_AND_TEXT && tab.HasText() )
 397     {
 398       long x,w,h;
 399
 400       // set select default font of the window into it's device context
 401       //dc.SetFont( GetLabelingFont() );
 402
 403       dc.SetTextBackground( GetBackgroundColour() );
 404
 405       dc.GetTextExtent(tab.mText, &w, &h );
 406
 407       x = curX + mTitleHorizGap +
 408         tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
 409
 410       dc.DrawText( tab.GetText(), x, curY + ( ySize - h ) / 2 );
 411     }
 412   curX += xSize;
 413
 414     } // end of `while (pNode)'
 415 }
 416 //---------------------------------------------------------------------------
 417 int wxTabbedWindow::HitTest( const wxPoint& pos )
 418 {
 419   int width, height;
 420   GetClientSize( &width, &height );
 421
 422   int curX = mFirstTitleGap;
 423   int curY = height - mVertGap - mTitleHeight;
 424
 425   int     tabNo = 0;
 426   wxNode* pNode = mTabs.First();
 427
 428   while( pNode )
 429     {
 430       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 431
 432       int w,h;
 433       w = tab.mDims.x;
 434       h = tab.mDims.y;
 435       // hit test rectangle of the currnet tab title bar
 436       if ( pos.x >= curX && pos.x < curX + tab.mDims.x  &&
 437            pos.y >= curY && pos.y < curY + tab.mDims.y
 438            )
 439         {
 440           return tabNo;
 441         }
 442
 443       curX += tab.mDims.x;
 444
 445       pNode = pNode->Next();
 446       ++tabNo;
 447     }
 448
 449   return -1;
 450 }
 451 //---------------------------------------------------------------------------
 452 void wxTabbedWindow::HideInactiveTabs( bool andRepaint )
 453 {
 454   if ( !andRepaint )
 455     return;
 456
 457   wxNode* pNode = mTabs.First();
 458   int     tabNo = 0;
 459
 460   while( pNode )
 461     {
 462       if ( tabNo != mActiveTab )
 463   {
 464     twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 465     tab.mpContent->Show(FALSE);
 466   }
 467
 468       pNode = pNode->Next();
 469       ++tabNo;
 470     }
 471 }
 472 //---------------------------------------------------------------------------
 473 wxFont wxTabbedWindow::GetLabelingFont()
 474 {
 475   wxFont font;
 476 #ifdef __WINDOWS__
 477   font.SetFaceName("MS Sans Serif");
 478 #else
 479   font.SetFamily( wxSWISS );
 480 #endif
 481
 482   font.SetStyle(40);
 483   font.SetWeight(40);
 484   font.SetPointSize( 8 );
 485
 486 #ifdef __WINDOWS__
 487   font.RealizeResource();
 488 #endif
 489
 490   return font;
 491 }
 492 //---------------------------------------------------------------------------
 493 void wxTabbedWindow::RecalcLayout(bool andRepaint)
 494 {
 495   HideInactiveTabs(andRepaint);
 496
 497   // resetup position of the active tab
 498
 499   int width, height;
 500   GetClientSize( &width, &height );
 501
 502   int curX = mHorizGap + BORDER_SZ;
 503   int curY = mVertGap  + BORDER_SZ;
 504
 505   int xSize = width  - mHorizGap*2 - BORDER_SZ*2-1;
 506   int ySize = height - mVertGap*2  - BORDER_SZ*2-1 - mTitleHeight;
 507
 508   SizeTabs( curX, curY, xSize, ySize, andRepaint );
 509
 510   // pass #1 - try to layout assuming it's wxTITLE_IMG_AND_TEXT
 511
 512   mLayoutType = wxTITLE_IMG_AND_TEXT;
 513
 514   wxNode* pNode = mTabs.First();
 515
 516   curX = mFirstTitleGap; // the left-side gap
 517   mTitleHeight = 0;
 518
 519   while( pNode )
 520     {
 521       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 522
 523       wxWindowDC dc(this);
 524
 525       long w,h;
 526
 527       // set select default font of the window into it's device context
 528   //dc.SetFont( GetLabelingFont() );
 529
 530   dc.GetTextExtent(tab.mText, &w, &h );
 531
 532   tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
 533     tab.ImgWidth() + mTitleHorizGap*2;
 534
 535   tab.mDims.y  = wxMax( h, tab.ImgHeight() ) + mTitleVertGap*2;
 536   mTitleHeight = wxMax( mTitleHeight, tab.mDims.y );
 537
 538   curX += tab.mDims.x;
 539
 540   pNode = pNode->Next();
 541     }
 542
 543   curX += mHorizGap; // the right-side gap
 544
 545   // make all title bars of equel height
 546
 547   pNode = mTabs.First();
 548
 549   while( pNode )
 550     {
 551       ((twTabInfo*)(pNode->Data()))->mDims.y = mTitleHeight;;
 552       pNode = pNode->Next();
 553     }
 554
 555   // if curX has'nt ran out of bounds, leave TITLE_IMG layout and return
 556   if ( curX < width - mHorizGap )
 557     return;
 558
 559   // pass #2 - try to layout assuming wxTITLE_IMG_ONLY
 560
 561   mLayoutType = wxTITLE_IMG_ONLY;
 562
 563   pNode = mTabs.First();
 564
 565   curX = mFirstTitleGap; // the left-side gap
 566
 567   int denomiator = mTabs.Number();
 568   if ( denomiator == 0 ) ++denomiator;
 569
 570   mBorderOnlyWidth = (width - mFirstTitleGap - mHorizGap) / denomiator;
 571
 572   while( pNode )
 573     {
 574       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 575
 576       if ( tab.HasImg() )
 577         {
 578           tab.mDims.x = tab.ImgWidth()  + mTitleHorizGap*2;
 579           tab.mDims.y = tab.ImgHeight() + mTitleVertGap*2;
 580         }
 581       else
 582         {
 583           tab.mDims.x = mBorderOnlyWidth;
 584           tab.mDims.y = mTitleHeight;
 585         }
 586
 587       curX += tab.mDims.x;
 588
 589       pNode = pNode->Next();
 590     }
 591
 592   curX += mHorizGap; // the right-side gap
 593
 594  // if curX has'nt ran out of bounds, leave IMG_ONLY layout and return
 595   if ( curX < width  - mHorizGap )
 596     return;
 597
 598   // pass #3 - set the narrowest layout wxTITLE_BORDER_ONLY
 599
 600   mLayoutType = wxTITLE_BORDER_ONLY;
 601
 602   pNode = mTabs.First();
 603
 604   while( pNode )
 605     {
 606       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 607
 608       tab.mDims.x = mBorderOnlyWidth;
 609       tab.mDims.y = mTitleHeight;
 610
 611       pNode = pNode->Next();
 612     }
 613 }
 614 //---------------------------------------------------------------------------
 615 // wx event handlers
 616 //---------------------------------------------------------------------------
 617 void wxTabbedWindow::OnPaint( wxPaintEvent& event )
 618 {
 619   wxPaintDC dc(this);
 620   DrawDecorations( dc );
 621 }
 622 //---------------------------------------------------------------------------
 623 void wxTabbedWindow::OnSize ( wxSizeEvent& event )
 624 {
 625   SetBackgroundColour( wxColour( 192,192,192 ) );
 626   RecalcLayout(TRUE);
 627 }
 628 //---------------------------------------------------------------------------
 629 void wxTabbedWindow::OnBkErase( wxEraseEvent& event )
 630 {
 631   // do nothing
 632 }
 633 //---------------------------------------------------------------------------
 634 void wxTabbedWindow::OnLButtonDown( wxMouseEvent& event )
 635 {
 636   // floats, why?
 637   int x = (int)event.m_x;
 638   int y = (int)event.m_y;
 639
 640   int tabNo = HitTest( wxPoint(x,y) );
 641
 642   if ( tabNo != -1 )
 643     {
 644       SetActiveTab( tabNo );
 645     }
 646 }
 647 //---------------------------------------------------------------------------
 648 // Implementation for class wxPaggedWindow
 649 //---------------------------------------------------------------------------
 650 IMPLEMENT_DYNAMIC_CLASS( wxPaggedWindow, wxTabbedWindow )
 651   //---------------------------------------------------------------------------
 652   BEGIN_EVENT_TABLE( wxPaggedWindow, wxTabbedWindow )
 653   EVT_SIZE     ( wxPaggedWindow::OnSize        )
 654   EVT_PAINT    ( wxPaggedWindow::OnPaint       )
 655   EVT_LEFT_DOWN( wxPaggedWindow::OnLButtonDown )
 656   EVT_LEFT_UP  ( wxPaggedWindow::OnLButtonUp   )
 657   EVT_MOTION   ( wxPaggedWindow::OnMouseMove   )
 658   EVT_SCROLL   ( wxPaggedWindow::OnScroll      )
 659   END_EVENT_TABLE()
 660   //---------------------------------------------------------------------------
 661   // border for pagged-window is 2 shaded-lines
 662   //---------------------------------------------------------------------------
 663 #undef  BORDER_SZ
 664 #define BORDER_SZ 2
 665   //---------------------------------------------------------------------------
 666   wxPaggedWindow::wxPaggedWindow()
 667
 668     : mScrollEventInProgress( FALSE ),
 669
 670       mTabTrianGap(4),
 671
 672       mWhiteBrush( wxColour(255,255,255), wxSOLID ),
 673       mGrayBrush ( wxColour(192,192,192), wxSOLID ),
 674
 675       mCurentRowOfs( 0 ),
 676       mAdjustableTitleRowLen( 300 ),
 677
 678       mIsDragged    ( FALSE ),
 679       mDagOrigin    ( 0 ),
 680       mCursorChanged( FALSE ),
 681       mResizeCursor ( wxCURSOR_SIZEWE ),
 682       mNormalCursor ( wxCURSOR_ARROW  )
 683 {
 684   mTitleVertGap = 2;
 685   mTitleHorizGap = 10;
 686  mNoVertScroll = TRUE;       // Horizontale Scroll abschalten
 687 }
 688 //---------------------------------------------------------------------------
 689 wxPaggedWindow::~wxPaggedWindow()
 690 {
 691   // nothing (base class handles destruction)
 692 }
 693 //---------------------------------------------------------------------------
 694 wxFont wxPaggedWindow::GetLabelingFont()
 695 {
 696   wxFont font;
 697
 698 #ifdef __WINDOWS__
 699   font.SetFaceName("Comic Sans MS");
 700 #else
 701   font.SetFamily( wxSWISS );
 702 #endif
 703
 704  font.SetStyle(40);
 705  font.SetWeight(40);
 706  font.SetPointSize( 8 );
 707
 708  return font;
 709 }
 710 //---------------------------------------------------------------------------
 711 void wxPaggedWindow::OnTabAdded( twTabInfo* pInfo )
 712 {
 713   int units = GetWholeTabRowLen() / 20;
 714
 715   mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
 716 }
 717 //---------------------------------------------------------------------------
 718 wxScrollBar& wxPaggedWindow::GetVerticalScrollBar()
 719 {
 720   return *mpVertScroll;
 721 }
 722 //---------------------------------------------------------------------------
 723 wxScrollBar& wxPaggedWindow::GetHorizontalScrollBar()
 724 {
 725   return *mpHorizScroll;
 726 }
 727 //---------------------------------------------------------------------------
 728 int wxPaggedWindow::GetWholeTabRowLen()
 729 {
 730   wxNode* pNode = mTabs.First();
 731
 732   int len = 0;
 733
 734   while( pNode )
 735     {
 736       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 737
 738       len += tab.mDims.x;
 739       pNode = pNode->Next();
 740     }
 741
 742   return len;
 743 }
 744 //---------------------------------------------------------------------------
 745 void wxPaggedWindow::DrawPaperBar( twTabInfo& tab, int x, int y,
 746                                    wxBrush& brush, wxPen& pen, wxDC& dc )
 747 {
 748   wxPoint poly[4];
 749
 750   // draw organizer-style paper outlet
 751
 752   poly[0].x = x - mTabTrianGap;
 753   poly[0].y = y;
 754
 755   poly[1].x = x + mTabTrianGap;
 756   poly[1].y = y + tab.mDims.y-1;
 757
 758   poly[2].x = x + tab.mDims.x - mTabTrianGap;
 759   poly[2].y = y + tab.mDims.y-1;
 760
 761   poly[3].x = x + tab.mDims.x + mTabTrianGap;
 762   poly[3].y = y;
 763
 764   dc.SetPen( pen );
 765   dc.SetBrush( brush );
 766
 767   dc.DrawPolygon( 4, poly );
 768
 769   long w,h;
 770
 771   // set select default font of the window into it's device context
 772   //dc.SetFont( GetLabelingFont() );
 773
 774   dc.SetTextBackground( brush.GetColour() );
 775
 776   dc.GetTextExtent(tab.mText, &w, &h );
 777
 778   if ( tab.HasImg() )
 779     {
 780       wxMemoryDC tmpDc;
 781       tmpDc.SelectObject( tab.GetImg() );
 782
 783       dc.Blit( x + mTitleHorizGap,
 784                y + ( tab.mDims.y - tab.ImgHeight() ) / 2,
 785                tab.ImgWidth(),
 786                tab.ImgHeight(),
 787                &tmpDc, 0, 0, wxCOPY
 788                );
 789     }
 790
 791   if ( tab.HasText() )
 792     {
 793       int tx = x + mTitleHorizGap +
 794         tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
 795
 796       dc.DrawText( tab.GetText(), tx, y + ( tab.mDims.y - h ) / 2 );
 797     }
 798 }
 799 //---------------------------------------------------------------------------
 800 void wxPaggedWindow::DrawDecorations( wxDC& dc )
 801 {
 802   // FIXME:: the is big body have to be split!
 803
 804   int width, height;
 805   GetClientSize( &width, &height );
 806
 807   int curX = mHorizGap;
 808   int curY = mVertGap;
 809
 810   int xSize = width  - mHorizGap*2;
 811   int ySize = height - mVertGap*2;
 812
 813   DrawShadedRect( curX, curY, xSize, ySize,
 814                   mDarkPen, mWhitePen, dc );
 815
 816   DrawShadedRect( curX+1, curY+1, xSize-2, ySize-2,
 817                   mBlackPen, mGrayPen, dc );
 818
 819   // draw inactive tab title bars frist (left-to-right)
 820
 821   wxNode* pNode = mTabs.First();
 822   int     tabNo = 0;
 823
 824   /* OLD STUFF::
 825      curX = mTitleRowStart;
 826      curY = height - mVertGap - BORDER_SZ - mTitleHeight;
 827      */
 828
 829   curX = mTabTrianGap;
 830   curY = 0;
 831
 832   // FOR NOW:: avoid creating bitmap with invalid dimensions
 833
 834   if ( mTitleRowLen < 1 || mTitleHeight < 1 ) return;
 835
 836   wxMemoryDC tmpDc;
 837   wxBitmap   tmpBmp( mTitleRowLen, mTitleHeight );
 838
 839   tmpDc.SelectObject( tmpBmp );
 840   tmpDc.SetPen( mGrayPen );
 841   tmpDc.SetBrush( mGrayBrush );
 842   tmpDc.DrawRectangle( 0,0, mTitleRowLen, mTitleHeight );
 843
 844   tmpDc.SetDeviceOrigin( mCurentRowOfs, 0 );
 845
 846   while( pNode )
 847     {
 848       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 849
 850       if ( tabNo != mActiveTab )
 851
 852         DrawPaperBar( tab, curX, curY, mGrayBrush, mBlackPen, tmpDc );
 853
 854       curX += tab.mDims.x;
 855
 856       pNode = pNode->Next();
 857       ++tabNo;
 858     }
 859
 860   // finally, draw the active tab (white-filled)
 861
 862   pNode = mTabs.First();
 863   tabNo = 0;
 864
 865   curX = mTabTrianGap;
 866
 867   while( pNode )
 868     {
 869       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 870
 871       if ( tabNo == mActiveTab )
 872         {
 873           DrawPaperBar( tab, curX, curY, mWhiteBrush, mBlackPen, tmpDc );
 874
 875           tmpDc.SetPen( mWhitePen );
 876
 877           tmpDc.DrawLine( curX - mTabTrianGap+1, curY,
 878                           curX + tab.mDims.x + mTabTrianGap, curY );
 879           break;
 880         }
 881       curX += tab.mDims.x;
 882
 883       pNode = pNode->Next();
 884       ++tabNo;
 885     }
 886
 887   // back to initial device origin
 888
 889   tmpDc.SetDeviceOrigin( 0, 0 );
 890
 891   // draw resize-hint-stick
 892
 893   curX = mTitleRowLen - 6;
 894
 895   DrawShadedRect( curX+0, 0+0, 6,   mTitleHeight,   mGrayPen,  mBlackPen, tmpDc );
 896   DrawShadedRect( curX+1, 0+1, 6-2, mTitleHeight-2, mWhitePen, mDarkPen,  tmpDc );
 897   DrawShadedRect( curX+2, 0+2, 6-4, mTitleHeight-4, mGrayPen,  mGrayPen,  tmpDc );
 898
 899
 900
 901   dc.Blit( mTitleRowStart,
 902            height - mVertGap - BORDER_SZ - mTitleHeight,
 903            mTitleRowLen, mTitleHeight,
 904            &tmpDc, 0,0, wxCOPY );
 905 }
 906 //---------------------------------------------------------------------------
 907 int wxPaggedWindow::HitTest( const wxPoint& pos )
 908 {
 909   return wxTabbedWindow::HitTest( pos );
 910 }
 911 //---------------------------------------------------------------------------
 912 void wxPaggedWindow::RecalcLayout(bool andRepaint)
 913 {
 914   mTitleRowLen = mAdjustableTitleRowLen;
 915
 916   if ( int(mpTabScroll) == -1 ) return;
 917
 918   // scroll bars should be created after Create() for this window is called
 919   if ( !mpTabScroll )
 920     {
 921       mpTabScroll   =
 922         new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
 923
 924       mpHorizScroll =
 925         new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
 926       if (!mNoVertScroll)       // Vertical Scroll (Original)
 927         mpVertScroll = new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL );
 928     }
 929
 930   {
 931     int units = GetWholeTabRowLen() / 20;
 932
 933     mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
 934   }
 935
 936   // resetup position of the active tab
 937
 938   int thumbLen = 16; // FOR NOW:: hardcoded
 939
 940   int width, height;
 941   GetClientSize( &width, &height );
 942
 943   mTitleHeight = thumbLen;
 944
 945   int curX = mHorizGap + BORDER_SZ;
 946   int curY = mVertGap  + BORDER_SZ;
 947
 948   int xSize;
 949   if (!mNoVertScroll)       // Vertical Scroll (Original)
 950     xSize = width  - mHorizGap*2 - BORDER_SZ*2 - thumbLen;
 951   else
 952     xSize = width  - mHorizGap*2 - BORDER_SZ*2;
 953
 954   int ySize = height - mVertGap*2  - BORDER_SZ*2 - mTitleHeight;
 955
 956   SizeTabs( curX, curY, xSize, ySize, andRepaint );
 957
 958   // setup title bar LINES's horizontal scroll bar
 959
 960   curY = height - mVertGap - BORDER_SZ - thumbLen;
 961
 962   mpTabScroll->SetSize( curX, curY, thumbLen*2, thumbLen );
 963
 964   // setup view's HORIZONTAL scroll bar
 965   curX += thumbLen*2;
 966
 967   mTitleRowStart = curX;
 968   mFirstTitleGap = curX + mCurentRowOfs + mTabTrianGap;
 969
 970   mTitleRowLen = wxMin( mAdjustableTitleRowLen,
 971                     width - mHorizGap - BORDER_SZ - thumbLen*4 - curX );
 972
 973   curX += mTitleRowLen;
 974
 975   if (!mNoVertScroll)       // Vertical Scroll (Original)
 976     mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ - thumbLen, thumbLen );
 977   else
 978     mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ-4, thumbLen );
 979
 980   // setup view's VERTICAL scroll bar
 981   if (!mNoVertScroll)       // Vertical Scroll (Original)
 982     {
 983       curX = width - mHorizGap - BORDER_SZ - thumbLen;
 984       curY = mVertGap  + BORDER_SZ;
 985       mpVertScroll->SetSize( curX, curY, thumbLen,height - curY - mVertGap - BORDER_SZ - thumbLen);
 986     }
 987   // layout tab title bars
 988
 989   mLayoutType = wxTITLE_IMG_AND_TEXT;
 990
 991   wxNode* pNode = mTabs.First();
 992
 993   while( pNode )
 994     {
 995       twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
 996
 997       wxWindowDC dc(this);
 998
 999       long w,h;
1000
1001       // set select default font of the window into it's device context
1002       //dc.SetFont( GetLabelingFont() );
1003       dc.GetTextExtent(tab.mText, &w, &h );
1004
1005       tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
1006         tab.ImgWidth() + mTitleHorizGap*2;
1007
1008       tab.mDims.y  = mTitleHeight;
1009
1010       pNode = pNode->Next();
1011     }
1012
1013   // disable title-bar scroller if there's nowhere to scroll to
1014
1015   mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0  );
1016 }
1017 //---------------------------------------------------------------------------
1018 // event handlers
1019 //---------------------------------------------------------------------------
1020 void wxPaggedWindow::OnPaint( wxPaintEvent& event )
1021 {
1022   wxPaintDC dc(this);
1023   DrawDecorations( dc );
1024 }
1025 //---------------------------------------------------------------------------
1026 void wxPaggedWindow::OnSize ( wxSizeEvent& event )
1027 {
1028   wxTabbedWindow::OnSize(event);
1029 }
1030 //---------------------------------------------------------------------------
1031 void wxPaggedWindow::OnLButtonDown( wxMouseEvent& event )
1032 {
1033   if ( mCursorChanged )
1034     {
1035       mIsDragged = TRUE;
1036       mDagOrigin = event.m_x;
1037
1038       mOriginalTitleRowLen = mAdjustableTitleRowLen;
1039
1040       CaptureMouse();
1041     }
1042   else
1043     {
1044       wxTabbedWindow::OnLButtonDown( event );
1045     }
1046 }
1047 //---------------------------------------------------------------------------
1048 void wxPaggedWindow::OnLButtonUp( wxMouseEvent& event )
1049 {
1050   if ( mIsDragged )
1051     {
1052       mIsDragged     = FALSE;
1053       mCursorChanged = FALSE;
1054       SetCursor( mNormalCursor );
1055
1056       ReleaseMouse();
1057     }
1058 }
1059 //---------------------------------------------------------------------------
1060 void wxPaggedWindow::OnMouseMove( wxMouseEvent& event )
1061 {
1062   int width, height;
1063   GetClientSize( &width, &height );
1064
1065   if ( !mIsDragged )
1066     {
1067       int y = height - mVertGap - BORDER_SZ - mTitleHeight;
1068       int x = mTitleRowStart + mTitleRowLen - 6;
1069
1070       if ( event.m_x >= x && event.m_y >= y &&
1071            event.m_x <  x + 6               &&
1072            event.m_y <  y + mTitleHeight
1073            )
1074         {
1075           if ( !mCursorChanged )
1076             {
1077               SetCursor( mResizeCursor );
1078
1079               mCursorChanged = TRUE;
1080             }
1081         }
1082       else
1083         if ( mCursorChanged )
1084           {
1085             SetCursor( mNormalCursor );
1086
1087             mCursorChanged = FALSE;
1088           }
1089     }
1090   else
1091     if ( mIsDragged )
1092       {
1093         mAdjustableTitleRowLen = mOriginalTitleRowLen + ( event.m_x - mDagOrigin );
1094
1095         // FOR NOW:: fixed
1096         if ( mAdjustableTitleRowLen < 6 ) mAdjustableTitleRowLen = 6;
1097
1098         wxWindowDC dc(this);
1099         DrawDecorations( dc );
1100
1101         RecalcLayout(FALSE);
1102
1103         //Refresh();
1104       }
1105 }
1106 //---------------------------------------------------------------------------
1107 void wxPaggedWindow::OnScroll( wxScrollEvent& event )
1108 {
1109
1110   wxScrollBar* pSender = (wxScrollBar*)event.GetEventObject();
1111   // wxMessageBox("wxPaggedWindow::OnScroll","-I->");
1112   if ( pSender == mpTabScroll )
1113     {
1114
1115       int maxUnits = GetWholeTabRowLen() / 20;
1116
1117       mCurentRowOfs = -event.GetPosition()*maxUnits;
1118
1119       mFirstTitleGap = mTitleRowStart + mCurentRowOfs + mTabTrianGap;
1120
1121       // let' it automatically disable itself if it's time
1122       mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 );
1123
1124       // repaint title bars
1125       wxWindowDC dc(this);
1126       DrawDecorations( dc );
1127     }
1128   else
1129     if ( !mScrollEventInProgress )
1130       {
1131         mScrollEventInProgress = TRUE;
1132
1133         GetActiveTab()->GetEventHandler()->ProcessEvent( event );
1134       }
1135     else
1136       {
1137         // event bounced back to us, from here we
1138         // know that it has traveled the loop - thus it's processed!
1139
1140         mScrollEventInProgress = FALSE;
1141       }
1142 }
1143 //---------------------------------------------------------------------------
1144