contrib/src/fl/toolwnd.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        toolwnd.cpp
   3 // Purpose:     wxToolWindow implementation.
   4 // Author:      Aleksandras Gluchovas
   5 // Modified by:
   6 // Created:     06/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Aleksandras Gluchovas
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "toolwnd.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "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/fl/toolwnd.h"
  28
  29 #define _IMG_A  0xAA    // Note: modified from _A to _IMG_A, _A was already defined (cygwin)
  30 #define _IMG_B  0x00    // Note: modified from _B to _IMG_A, _B was already defined (cygwin)
  31 #define _IMG_C  0x55    // Note: modified from _C to _IMG_C, for consistency reasons.
  32 #define _IMG_D  0x00    // Note: modified from _D to _IMG_D, for consistency reasons.
  33
  34 // FOR NOW:: static
  35
  36 static const unsigned char _gCheckerImg[16] = { _IMG_A,_IMG_B,_IMG_C,_IMG_D,
  37                                                 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
  38                                                 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
  39                                                 _IMG_A,_IMG_B,_IMG_C,_IMG_D
  40                                               };
  41
  42 /***** Implementation for class wxToolWindow *****/
  43
  44 IMPLEMENT_DYNAMIC_CLASS( wxToolWindow, wxFrame)
  45
  46 BEGIN_EVENT_TABLE( wxToolWindow, wxFrame )
  47
  48     EVT_PAINT    ( wxToolWindow::OnPaint )
  49     EVT_MOTION   ( wxToolWindow::OnMotion )
  50     EVT_LEFT_DOWN( wxToolWindow::OnLeftDown )
  51     EVT_LEFT_UP  ( wxToolWindow::OnLeftUp )
  52     EVT_SIZE     ( wxToolWindow::OnSize )
  53
  54
  55     EVT_ERASE_BACKGROUND( wxToolWindow::OnEraseBackground )
  56
  57 END_EVENT_TABLE()
  58
  59 enum INTERNAL_HIT_CODES
  60 {
  61     HITS_WND_NOTHING,
  62     HITS_WND_CLIENT,
  63     HITS_WND_TITLE,
  64
  65     HITS_WND_LEFT_EDGE,
  66     HITS_WND_RIGHT_EDGE,
  67     HITS_WND_TOP_EDGE,
  68     HITS_WND_BOTTOM_EDGE,
  69
  70     HITS_WND_TOP_LEFT_CORNER,
  71     HITS_WND_BOTTOM_RIGHT_CORNER,
  72     HITS_WND_TOP_RIGHT_CORNER,
  73     HITS_WND_BOTTOM_LEFT_CORNER
  74 };
  75
  76 wxToolWindow::wxToolWindow()
  77
  78     : mpClientWnd   ( NULL ),
  79
  80 #ifndef __WXMSW__
  81     mTitleFont( 8, wxSWISS,  wxNORMAL, wxNORMAL ),
  82 #else
  83     // just to simulate MS-Dev style
  84     mTitleFont( 8, wxSWISS,  wxNORMAL, wxNORMAL, false, wxT("MS Sans Serif") ),
  85 #endif
  86
  87     mTitleHeight  ( 16 ),
  88     mClntHorizGap ( 2 ),
  89     mClntVertGap  ( 2 ),
  90     mWndVertGap   ( 4 ),
  91     mWndHorizGap  ( 4 ),
  92
  93     mButtonGap    ( 2 ),
  94     mInTitleMargin( 4 ),
  95     mHintBorder   ( 4 ),
  96
  97     mResizeStarted( false ),
  98     mRealTimeUpdatesOn( true ),
  99
 100     mMTolerance   ( 5 ), // mouse-resizing tollerance
 101
 102     mCursorType( HITS_WND_NOTHING ),
 103     mMouseCaptured( false ),
 104
 105     mpScrDc( NULL )
 106
 107 {
 108 }
 109
 110 wxToolWindow::~wxToolWindow()
 111 {
 112     if ( mpScrDc ) delete mpScrDc;
 113
 114     for( size_t i = 0; i != mButtons.Count(); ++i )
 115         delete mButtons[i];
 116 }
 117
 118 void wxToolWindow::LayoutMiniButtons()
 119 {
 120     int w,h;
 121
 122     GetSize( &w, &h );
 123
 124     int x = w - mWndHorizGap - mInTitleMargin - BTN_BOX_WIDTH;
 125     int y = mWndVertGap + 2;
 126
 127     for( size_t i = 0; i != mButtons.Count(); ++i )
 128     {
 129         mButtons[i]->SetPos( wxPoint( x,y ) );
 130         x-= BTN_BOX_WIDTH + mButtonGap;
 131     }
 132 }
 133
 134 void wxToolWindow::SetClient( wxWindow* pWnd )
 135 {
 136     mpClientWnd = pWnd;
 137 }
 138
 139 wxWindow* wxToolWindow::GetClient()
 140 {
 141     return mpClientWnd;
 142 }
 143
 144 void wxToolWindow::SetTitleFont( wxFont& font )
 145 {
 146     mTitleFont = font;
 147 }
 148
 149 void wxToolWindow::AddMiniButton( cbMiniButton* pBtn )
 150 {
 151     pBtn->mpWnd = this;
 152
 153     mButtons.Add( pBtn );
 154
 155     // not necesserely now..
 156     //LayoutMiniButtons();
 157 }
 158
 159 void wxToolWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 160 {
 161     wxPaintDC pdc( this );
 162     wxWindowDC dc( this );
 163
 164     int w,h;
 165     GetSize( &w, &h );
 166
 167     wxBrush backGround( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE), wxSOLID );
 168     //dc.SetBrush( *wxLIGHT_GREY_BRUSH );
 169     dc.SetBrush( backGround );
 170     dc.SetPen( *wxTRANSPARENT_PEN );
 171
 172     int y = mWndVertGap + mTitleHeight + mClntVertGap;
 173
 174     dc.DrawRectangle( 0,0, w, y );                                      // Top grey part.
 175     dc.DrawRectangle( 0,y-1, mWndHorizGap + mClntHorizGap, h - y );     // Left grey part.
 176     dc.DrawRectangle( w - ( mWndHorizGap + mClntHorizGap ), y-1,
 177                       mWndHorizGap + mClntHorizGap, h - y );            // Right grey part.
 178     dc.DrawRectangle( 0, h - mWndVertGap - mClntVertGap, w, mWndVertGap + mClntVertGap ); // Bottom grey part.
 179
 180     // draw shades
 181     dc.SetPen( *wxLIGHT_GREY_PEN );
 182
 183     dc.DrawLine( 0,0, w, 0 );
 184     dc.DrawLine( 0,0, 0, h );
 185
 186     dc.SetPen( *wxWHITE_PEN );
 187
 188     dc.DrawLine( 1,1, w, 1 );
 189     dc.DrawLine( 1,2, 1, h );
 190
 191     dc.SetPen( *wxGREY_PEN );
 192
 193     dc.DrawLine( w - 2, 1, w - 2, h - 1 );
 194     dc.DrawLine( 1, h - 2, w - 2, h - 2 );
 195
 196     dc.SetPen( *wxBLACK_PEN );
 197
 198     dc.DrawLine( 0, h - 1, w, h - 1 );
 199     dc.DrawLine( w-1, 0, w-1, h );
 200
 201     // fill inner area
 202
 203     dc.SetBrush( *wxTheBrushList->FindOrCreateBrush( wxColour( 0,0,128 ), wxSOLID ) );
 204
 205     dc.DrawRectangle( mWndHorizGap, mWndVertGap, w - mWndHorizGap*2, mTitleHeight );
 206
 207     dc.SetFont( mTitleFont );
 208
 209     for( size_t i = 0; i != mButtons.Count(); ++i )
 210         mButtons[i]->Draw( dc );
 211
 212     int x1 = mWndHorizGap + mClntHorizGap;
 213     int x2 = mButtons[ mButtons.GetCount() - 1 ]->mPos.x - mClntHorizGap*2;
 214
 215     dc.SetClippingRegion( x1, mWndVertGap + mClntVertGap, x2 - x1, mTitleHeight );
 216
 217     dc.SetTextForeground( *wxWHITE );
 218     dc.SetBackgroundMode(  wxTRANSPARENT );
 219     dc.DrawText( GetTitle(), mWndHorizGap + 2, mWndVertGap + 1 );
 220 }
 221
 222 void wxToolWindow::GetScrWindowRect( wxRect& r )
 223 {
 224     int x,y;
 225     GetPosition(&x,&y);
 226     int w,h;
 227     GetSize( &w, &h );
 228
 229     r.x = x; r.y = y;
 230     r.width = w; r.height = h;
 231 }
 232
 233 void wxToolWindow::GetScrMousePos( wxMouseEvent& event, wxPoint& pos )
 234 {
 235     int x = event.m_x, y = event.m_y;
 236
 237     ClientToScreen( &x, &y );
 238
 239     pos.x = x; pos.y = y;
 240 }
 241
 242 int wxToolWindow::HitTestWindow( wxMouseEvent& event )
 243 {
 244     wxPoint pos;
 245     wxRect r;
 246
 247     GetScrMousePos( event, pos );
 248     GetScrWindowRect( r );
 249
 250     int k = mMTolerance;
 251
 252     if ( !( pos.x >= r.x && pos.y >= r.y &&
 253             pos.x < r.x + r.width &&
 254             pos.y < r.y + r.height )
 255        )
 256         return HITS_WND_NOTHING;
 257
 258     if ( pos.y <= r.y + k )
 259     {
 260         if ( pos.x < r.x + k*2 )
 261             return HITS_WND_TOP_LEFT_CORNER;
 262         else
 263         {
 264             if ( pos.x >= r.x + r.width - k*2 )
 265                 return HITS_WND_TOP_RIGHT_CORNER;
 266             else
 267                 return HITS_WND_TOP_EDGE;
 268         }
 269     }
 270     else
 271     {
 272         if ( pos.y >= r.y + r.height - k )
 273         {
 274             if ( pos.x < r.x + k*2 )
 275                 return HITS_WND_BOTTOM_LEFT_CORNER;
 276             else
 277             {
 278                 if ( pos.x > r.x + r.width - k*2 )
 279                     return HITS_WND_BOTTOM_RIGHT_CORNER;
 280                 else
 281                     return HITS_WND_BOTTOM_EDGE;
 282             }
 283         }
 284         else
 285         {
 286             if ( pos.x <= r.x + k )
 287                 return HITS_WND_LEFT_EDGE;
 288             else
 289             {
 290                 if ( pos.x >= r.x + r.width - k )
 291                     return HITS_WND_RIGHT_EDGE;
 292                 else
 293                 {
 294                     if ( pos.y <= r.y + mWndVertGap + mTitleHeight + mClntVertGap )
 295                         return HITS_WND_TITLE;
 296                     else
 297                         return HITS_WND_CLIENT;
 298                 }
 299             }
 300         }
 301     }
 302 }
 303
 304 void wxToolWindow::DrawHintRect( const wxRect& r )
 305 {
 306     // BUG BUG BUG (wx):: somehow stippled brush works only
 307     //                    when the bitmap created on stack, not
 308     //                    as a member of the class
 309
 310     int prevLF = mpScrDc->GetLogicalFunction();
 311
 312     mpScrDc->SetLogicalFunction( wxXOR );
 313
 314     wxBitmap checker( (const char*)_gCheckerImg, 8,8 );
 315
 316     wxBrush checkerBrush( checker );
 317
 318     mpScrDc->SetPen( *wxTRANSPARENT_PEN );
 319     mpScrDc->SetBrush( checkerBrush );
 320
 321     int half = mHintBorder / 2;
 322
 323     mpScrDc->DrawRectangle( r.x - half, r.y - half,
 324                             r.width + 2*half, mHintBorder );
 325
 326     mpScrDc->DrawRectangle( r.x - half, r.y + r.height - half,
 327                             r.width + 2*half, mHintBorder );
 328
 329     mpScrDc->DrawRectangle( r.x - half, r.y + half - 1,
 330                             mHintBorder, r.height - 2*half + 2);
 331
 332     mpScrDc->DrawRectangle( r.x + r.width - half,
 333                             r.y + half - 1,
 334                             mHintBorder, r.height - 2*half + 2);
 335
 336     mpScrDc->SetBrush( wxNullBrush );
 337
 338     mpScrDc->SetLogicalFunction( prevLF );
 339 }
 340
 341 void wxToolWindow::SetHintCursor( int type )
 342 {
 343     if ( mResizeStarted )
 344         return;
 345
 346     if ( type == HITS_WND_NOTHING || type == HITS_WND_CLIENT )
 347     {
 348         // the cursor is out of window - reset to arrow
 349
 350         if ( mMouseCaptured )
 351         {
 352             ReleaseMouse();
 353             mMouseCaptured = false;
 354         }
 355
 356         SetCursor( wxCURSOR_ARROW );
 357
 358         mCursorType = type;
 359
 360         return;
 361     }
 362
 363     if ( !mMouseCaptured )
 364     {
 365         mMouseCaptured = true;
 366         CaptureMouse();
 367     }
 368
 369     // did the cursor actually changed?
 370
 371     if ( type != mCursorType )
 372     {
 373         mCursorType = type;
 374
 375         switch ( type )
 376         {
 377             case HITS_WND_LEFT_EDGE   : SetCursor( wxCURSOR_SIZEWE ); break;
 378             case HITS_WND_RIGHT_EDGE  : SetCursor( wxCURSOR_SIZEWE ); break;
 379             case HITS_WND_TOP_EDGE    : SetCursor( wxCURSOR_SIZENS ); break;
 380             case HITS_WND_BOTTOM_EDGE : SetCursor( wxCURSOR_SIZENS ); break;
 381
 382             case HITS_WND_TOP_LEFT_CORNER     : SetCursor( wxCURSOR_SIZENWSE ); break;
 383             case HITS_WND_BOTTOM_RIGHT_CORNER : SetCursor( wxCURSOR_SIZENWSE ); break;
 384             case HITS_WND_TOP_RIGHT_CORNER    : SetCursor( wxCURSOR_SIZENESW ); break;
 385             case HITS_WND_BOTTOM_LEFT_CORNER  : SetCursor( wxCURSOR_SIZENESW ); break;
 386
 387             case HITS_WND_TITLE  : SetCursor( wxCURSOR_ARROW ); break;
 388             case HITS_WND_CLIENT : SetCursor( wxCURSOR_ARROW ); break;
 389
 390             default: break;
 391         }
 392     }
 393 }
 394
 395 #define INFINITY 32768
 396
 397 static inline void clip_to( int& value, long from, long till )
 398 {
 399     if ( value < from )
 400         value = from;
 401
 402     if ( value > till )
 403         value = till;
 404 }
 405
 406 void wxToolWindow::AdjustRectPos( const wxRect& original, const wxSize& newDim, wxRect& newRect )
 407 {
 408     if ( mCursorType == HITS_WND_TOP_EDGE ||
 409          mCursorType == HITS_WND_TOP_LEFT_CORNER )
 410     {
 411         newRect.x = original.x + original.width  - newDim.x;
 412         newRect.y = original.y + original.height - newDim.y;
 413     }
 414     else
 415     if ( mCursorType == HITS_WND_LEFT_EDGE ||
 416          mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
 417     {
 418         newRect.x = original.x + original.width  - newDim.x;
 419         newRect.y = original.y;
 420     }
 421     else
 422     if ( mCursorType == HITS_WND_RIGHT_EDGE ||
 423          mCursorType == HITS_WND_TOP_RIGHT_CORNER )
 424     {
 425         newRect.x = original.x;
 426         newRect.y = original.y + original.height - newDim.y;
 427     }
 428     else
 429     if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
 430          mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
 431     {
 432         newRect.x = original.x;
 433         newRect.y = original.y;
 434     }
 435
 436     newRect.width  = newDim.x;
 437     newRect.height = newDim.y;
 438 }
 439
 440 void wxToolWindow::CalcResizedRect( wxRect& rect, wxPoint& delta, const wxSize& minDim )
 441 {
 442     // Microsoft's rect-coordinates are best suited
 443     // for the case of corner-clipping
 444
 445     int left   = mInitialRect.x;
 446     int top    = mInitialRect.y;
 447     int right  = mInitialRect.x + mInitialRect.width;
 448     int bottom = mInitialRect.y + mInitialRect.height;
 449
 450     // constraint delta edge is dragged
 451
 452     switch ( mCursorType )
 453     {
 454         case HITS_WND_LEFT_EDGE   : delta.y = 0; break;
 455         case HITS_WND_RIGHT_EDGE  : delta.y = 0; break;
 456         case HITS_WND_TOP_EDGE    : delta.x = 0; break;
 457         case HITS_WND_BOTTOM_EDGE : delta.x = 0; break;
 458         default: break;
 459     }
 460
 461     if ( mCursorType == HITS_WND_TOP_EDGE ||
 462          mCursorType == HITS_WND_TOP_LEFT_CORNER )
 463     {
 464         left += delta.x;
 465         top  += delta.y;
 466
 467         clip_to( left, -INFINITY, mInitialRect.x + mInitialRect.width  - minDim.x  );
 468         clip_to( top,  -INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
 469     }
 470     else
 471     if ( mCursorType == HITS_WND_LEFT_EDGE ||
 472          mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
 473     {
 474         left   += delta.x;
 475         bottom += delta.y;
 476
 477         clip_to( left,    -INFINITY, mInitialRect.x + mInitialRect.width  - minDim.x  );
 478         clip_to( bottom,  mInitialRect.y + minDim.y, INFINITY );
 479     }
 480     else
 481     if ( mCursorType == HITS_WND_RIGHT_EDGE ||
 482         mCursorType == HITS_WND_TOP_RIGHT_CORNER )
 483     {
 484         right += delta.x;
 485         top   += delta.y;
 486
 487         clip_to( right, mInitialRect.x + minDim.x, INFINITY );
 488         clip_to( top,   -INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
 489     }
 490     else
 491     if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
 492          mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
 493     {
 494         right  += delta.x;
 495         bottom += delta.y;
 496
 497         clip_to( right,  mInitialRect.x + minDim.x,  INFINITY );
 498         clip_to( bottom, mInitialRect.y + minDim.y, INFINITY );
 499     }
 500     else
 501     {
 502         wxFAIL_MSG( _T("what did the cursor hit?") );
 503     }
 504
 505     rect.x = left;
 506     rect.y = top;
 507     rect.width  = right - left;
 508     rect.height = bottom - top;
 509 }
 510
 511 wxSize wxToolWindow::GetMinimalWndDim()
 512 {
 513     return wxSize( (mWndHorizGap + mClntHorizGap)*2 + BTN_BOX_WIDTH*4,
 514                    (mWndVertGap  + mClntVertGap )*2 + mTitleHeight );
 515 }
 516
 517 void wxToolWindow::OnMotion( wxMouseEvent& event )
 518 {
 519     if ( !mResizeStarted )
 520     {
 521         for( size_t i = 0; i != mButtons.Count(); ++i )
 522             mButtons[i]->OnMotion( wxPoint( event.m_x, event.m_y ) );
 523
 524         SetHintCursor( HitTestWindow( event ) );
 525         return;
 526     }
 527
 528     wxPoint pos;
 529     GetScrMousePos( event, pos );
 530
 531     if ( mCursorType == HITS_WND_TITLE )
 532     {
 533         int w,h;
 534         GetSize( &w, &h );
 535
 536         SetSize( mInitialRect.x + pos.x - mDragOrigin.x,
 537                  mInitialRect.y + pos.y - mDragOrigin.y,
 538                  w,h, 0 );
 539     }
 540
 541     else
 542     {
 543         wxPoint delta( pos.x - mDragOrigin.x, pos.y - mDragOrigin.y );
 544
 545         wxRect newRect;
 546
 547         wxSize minDim = GetMinimalWndDim();
 548
 549         CalcResizedRect( newRect, delta, minDim );
 550
 551         wxSize borderDim( ( mWndHorizGap + mClntHorizGap )*2,
 552                           ( mWndVertGap  + mClntVertGap  )*2 + mTitleHeight );
 553
 554         wxSize preferred = GetPreferredSize( wxSize( newRect.width  - borderDim.x,
 555                                              newRect.height - borderDim.y ) );
 556
 557         preferred.x += borderDim.x;
 558         preferred.y += borderDim.y;
 559
 560         //CalcResizedRect( newRect, delta, preferred );
 561
 562         wxRect finalRect = newRect;
 563
 564         AdjustRectPos( newRect, preferred, finalRect );
 565
 566         if ( mRealTimeUpdatesOn )
 567         {
 568             SetSize( finalRect.x, finalRect.y,
 569                      finalRect.width, finalRect.height, 0 );
 570         }
 571         else
 572         {
 573             DrawHintRect( mPrevHintRect );
 574             DrawHintRect( finalRect );
 575
 576             ::wxLogTrace(wxT("wxToolWindow"),wxT("%d,%d / %d,%d\n"), finalRect.x, finalRect.y, finalRect.width, finalRect.height);
 577         }
 578
 579         mPrevHintRect = finalRect;
 580     }
 581 }
 582
 583 void wxToolWindow::OnLeftDown( wxMouseEvent& event )
 584 {
 585     int result = HitTestWindow( event );
 586
 587     for( size_t i = 0; i != mButtons.Count(); ++i )
 588     {
 589         mButtons[i]->OnLeftDown( wxPoint( event.m_x, event.m_y ) );
 590
 591         if ( mButtons[i]->IsPressed() )
 592             return; // button hitted,
 593     }
 594
 595     if ( result >= HITS_WND_LEFT_EDGE || result == HITS_WND_TITLE )
 596     {
 597         GetScrMousePos( event, mDragOrigin );
 598
 599         /*
 600         if ( mMouseCaptured `)
 601         {
 602             ReleaseMouse();
 603             mMouseCaptured = false;
 604         }*/
 605
 606         if ( result == HITS_WND_TITLE &&
 607              HandleTitleClick( event ) )
 608             return;
 609
 610         mResizeStarted = true;
 611
 612         int x,y;
 613         GetPosition( &x, &y );
 614
 615         mInitialRect.x = x;
 616         mInitialRect.y = y;
 617
 618         GetSize( &x, &y );
 619         mInitialRect.width  = x;
 620         mInitialRect.height = y;
 621
 622         mPrevHintRect = mInitialRect;
 623
 624         if ( mCursorType != HITS_WND_TITLE && !mRealTimeUpdatesOn )
 625         {
 626             mpScrDc = new wxScreenDC();
 627
 628             wxScreenDC::StartDrawingOnTop( (wxRect*)NULL );
 629
 630             DrawHintRect( mInitialRect );
 631         }
 632     }
 633 }
 634
 635 void wxToolWindow::OnLeftUp( wxMouseEvent& event )
 636 {
 637     for( size_t i = 0; i != mButtons.Count(); ++i )
 638     {
 639         mButtons[i]->OnLeftUp( wxPoint( event.m_x, event.m_y ) );
 640
 641         if ( mButtons[i]->WasClicked() )
 642         {
 643             OnMiniButtonClicked( i ); // notify derived classes
 644             mButtons[i]->Reset();
 645         }
 646     }
 647
 648     if ( mResizeStarted )
 649     {
 650         mResizeStarted = false;
 651
 652         if ( mCursorType != HITS_WND_TITLE )
 653         {
 654             if ( !mRealTimeUpdatesOn )
 655             {
 656                 DrawHintRect( mPrevHintRect );
 657
 658                 wxScreenDC::EndDrawingOnTop();
 659
 660                 delete mpScrDc;
 661
 662                 mpScrDc = NULL;
 663
 664                 SetSize( mPrevHintRect.x, mPrevHintRect.y,
 665                          mPrevHintRect.width, mPrevHintRect.height, 0 );
 666             }
 667         }
 668     }
 669 }
 670
 671 void wxToolWindow::OnSize( wxSizeEvent& WXUNUSED(event) )
 672 {
 673     if ( mpClientWnd )
 674     {
 675         int w,h;
 676         GetSize( &w, &h );
 677
 678         int x = mWndHorizGap + mClntHorizGap;
 679         int y = mWndVertGap  + mTitleHeight + mClntVertGap;
 680
 681         mpClientWnd->SetSize( x-1, y-1,
 682                               w - 2*(mWndHorizGap + mClntHorizGap),
 683                               h - y - mClntVertGap - mWndVertGap,
 684                               0
 685                             );
 686     }
 687
 688     LayoutMiniButtons();
 689 }
 690
 691 wxSize wxToolWindow::GetPreferredSize( const wxSize& given )
 692 {
 693     return given;
 694 }
 695
 696 void wxToolWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 697 {
 698     // nothing
 699 }
 700
 701 /***** Implementation for class cbMiniButton *****/
 702
 703 cbMiniButton::cbMiniButton()
 704
 705     : mVisible( true ),
 706       mEnabled( true ),
 707
 708       mpLayout( NULL ),
 709       mpPane  ( NULL ),
 710       mpPlugin( NULL ),
 711       mpWnd   ( NULL ),
 712
 713       mWasClicked( false ),
 714       mDragStarted( false ),
 715       mPressed( false )
 716 {}
 717
 718 void cbMiniButton::SetPos( const wxPoint& pos )
 719 {
 720     mPos = pos;
 721 }
 722
 723 bool cbMiniButton::HitTest( const wxPoint& pos )
 724 {
 725     if ( !mVisible ) return false;
 726
 727     return ( pos.x >= mPos.x && pos.y >= mPos.y &&
 728              pos.x < mPos.x + BTN_BOX_WIDTH     &&
 729              pos.y < mPos.y + BTN_BOX_HEIGHT );
 730 }
 731
 732 void cbMiniButton::OnLeftDown( const wxPoint& pos )
 733 {
 734     if ( !mVisible || mDragStarted ) return;
 735
 736     if ( HitTest( pos ) && mEnabled )
 737     {
 738         if ( mpPlugin )
 739         {
 740             mpLayout->CaptureEventsForPane( mpPane );
 741             mpLayout->CaptureEventsForPlugin( mpPlugin );
 742         }
 743         else
 744             mpWnd->CaptureMouse();
 745
 746         mDragStarted = true;
 747         mPressed     = true;
 748         mWasClicked  = false;
 749
 750         Refresh();
 751     }
 752 }
 753
 754 void cbMiniButton::OnLeftUp( const wxPoint& WXUNUSED(pos) )
 755 {
 756     if ( !mVisible || !mDragStarted ) return;
 757
 758     if ( mpPlugin )
 759     {
 760         mpLayout->ReleaseEventsFromPane( mpPane );
 761         mpLayout->ReleaseEventsFromPlugin( mpPlugin );
 762     }
 763     else
 764         mpWnd->ReleaseMouse();
 765
 766     mWasClicked  = mPressed;
 767     mDragStarted = false;
 768
 769     mPressed = false;
 770     Refresh();
 771 }
 772
 773 void cbMiniButton::OnMotion( const wxPoint& pos )
 774 {
 775     if ( !mVisible ) return;
 776
 777     if ( mDragStarted )
 778     {
 779         mPressed = HitTest( pos );
 780
 781         Refresh();
 782     }
 783 }
 784
 785 void cbMiniButton::Refresh()
 786 {
 787     if ( mpLayout )
 788     {
 789          wxClientDC dc( &mpLayout->GetParentFrame() );
 790
 791          Draw( dc );
 792     }
 793     else
 794     {
 795         wxWindowDC dc( mpWnd );
 796
 797         Draw( dc );
 798     }
 799 }
 800
 801 void cbMiniButton::Draw( wxDC& dc )
 802 {
 803     if ( !mVisible ) return;
 804
 805     dc.SetPen( *wxTRANSPARENT_PEN );
 806
 807     dc.SetBrush( *wxLIGHT_GREY_BRUSH );
 808
 809     dc.DrawRectangle( mPos.x + 1, mPos.y + 1, BTN_BOX_WIDTH - 2, BTN_BOX_HEIGHT - 2 );
 810
 811     // "hard-code" metafile
 812
 813     if ( !mPressed )
 814         dc.SetPen( *wxWHITE_PEN );
 815     else
 816         dc.SetPen( *wxBLACK_PEN );
 817
 818     dc.DrawLine( mPos.x, mPos.y, mPos.x + BTN_BOX_WIDTH, mPos.y );
 819     dc.DrawLine( mPos.x, mPos.y, mPos.x, mPos.y + BTN_BOX_HEIGHT );
 820
 821     dc.SetPen( *wxGREY_PEN );
 822
 823     if ( !mPressed )
 824     {
 825         dc.DrawLine( mPos.x + 1, mPos.y + BTN_BOX_HEIGHT - 2,
 826                      mPos.x + BTN_BOX_WIDTH - 1, mPos.y + BTN_BOX_HEIGHT - 2 );
 827
 828         dc.DrawLine( mPos.x + BTN_BOX_WIDTH - 2, mPos.y + 1,
 829                      mPos.x + BTN_BOX_WIDTH - 2, mPos.y + BTN_BOX_HEIGHT - 1 );
 830     }
 831     else
 832     {
 833         dc.DrawLine( mPos.x + 1, mPos.y + 1,
 834                      mPos.x + BTN_BOX_WIDTH - 2, mPos.y + 1 );
 835
 836         dc.DrawLine( mPos.x + 1, mPos.y + 1,
 837                      mPos.x + 1, mPos.y + BTN_BOX_HEIGHT - 2 );
 838     }
 839
 840     if ( !mPressed )
 841         dc.SetPen( *wxBLACK_PEN );
 842     else
 843         dc.SetPen( *wxWHITE_PEN );
 844
 845     dc.DrawLine( mPos.x, mPos.y + BTN_BOX_HEIGHT - 1,
 846                  mPos.x + BTN_BOX_WIDTH, mPos.y + BTN_BOX_HEIGHT - 1 );
 847
 848     dc.DrawLine( mPos.x + BTN_BOX_WIDTH - 1, mPos.y ,
 849                  mPos.x + BTN_BOX_WIDTH - 1, mPos.y + BTN_BOX_HEIGHT );
 850 }
 851
 852 bool cbMiniButton::WasClicked()
 853 {
 854     return mWasClicked;
 855 }
 856
 857 void cbMiniButton::Reset()
 858 {
 859     mWasClicked = false;
 860 }
 861
 862 /***** Implementation fro class cbCloseBox *****/
 863
 864 void cbCloseBox::Draw( wxDC& dc )
 865 {
 866 #if defined(__WXGTK__) || defined(__WXX11__)
 867
 868     cbMiniButton::Draw( dc );
 869
 870     wxPen pen( wxColour( 64,64,64 ) ,1, wxSOLID );
 871
 872     dc.SetPen( pen );
 873
 874     int width = BTN_BOX_WIDTH - 7;
 875
 876     int xOfs = (mPressed) ? 4 : 3;
 877     int yOfs = (mPressed) ? 4 : 3;
 878
 879     int one = 1;
 880     for( int i = 0; i != BTN_X_WIEGHT; ++i )
 881     {
 882         dc.DrawLine( mPos.x + xOfs + i - one,
 883                      mPos.y + yOfs - one,
 884                      mPos.x + xOfs + i + width,
 885                      mPos.y + yOfs + width  + one);
 886
 887         dc.DrawLine( mPos.x + xOfs + i + width ,
 888                      mPos.y + yOfs - one - one,
 889                      mPos.x + xOfs + i - one,
 890                      mPos.y + yOfs + width );
 891     }
 892
 893 #else
 894
 895     cbMiniButton::Draw( dc );
 896
 897     dc.SetPen( *wxBLACK_PEN );
 898
 899     int width = BTN_BOX_WIDTH - 7;
 900
 901     int xOfs = (mPressed) ? 4 : 3;
 902     int yOfs = (mPressed) ? 4 : 3;
 903
 904     for( int i = 0; i != BTN_X_WIEGHT; ++i )
 905     {
 906         dc.DrawLine( mPos.x + xOfs + i,
 907                      mPos.y + yOfs,
 908                      mPos.x + xOfs + i + width,
 909                      mPos.y + yOfs + width );
 910
 911         dc.DrawLine( mPos.x + xOfs + i + width - 1,
 912                      mPos.y + yOfs,
 913                      mPos.x + xOfs + i - 1,
 914                      mPos.y + yOfs + width );
 915     }
 916
 917 #endif
 918
 919 }
 920
 921 /***** Implementation fro class cbCollapseBox *****/
 922
 923 inline static void my_swap( int& a, int& b )
 924 {
 925     long tmp = a;
 926     a = b;
 927     b = tmp;
 928 }
 929
 930 void cbCollapseBox::Draw( wxDC& dc )
 931 {
 932     cbMiniButton::Draw( dc );
 933
 934     dc.SetPen( *wxTRANSPARENT_PEN );
 935
 936     wxPoint arr[3];
 937
 938     int yOfs  = (mPressed) ? 3 : 2;
 939     int xOfs  = (mPressed) ? 5 : 4;
 940     int width = BTN_BOX_WIDTH - 8;
 941
 942     // rotating/shifting triangle inside collapse box
 943
 944     arr[0].x = xOfs;
 945     arr[0].y = yOfs-1;
 946     arr[2].x = xOfs;
 947     arr[2].y = BTN_BOX_HEIGHT - yOfs - 1;
 948     arr[1].x = xOfs + width;
 949     arr[1].y = (arr[2].y + arr[0].y)/2;
 950
 951     if ( !mIsAtLeft )
 952     {
 953         arr[0].x = BTN_BOX_WIDTH - arr[0].x;
 954         arr[1].x = BTN_BOX_WIDTH - arr[1].x;
 955         arr[2].x = BTN_BOX_WIDTH - arr[2].x;
 956     }
 957
 958     if ( !mpPane->IsHorizontal() )
 959     {
 960         my_swap( arr[0].y, arr[0].x );
 961         my_swap( arr[1].y, arr[1].x );
 962         my_swap( arr[2].y, arr[2].x );
 963
 964         arr[0].x += 1;
 965         arr[1].x += 1;
 966         arr[2].x += 1;
 967
 968         //arr[1].y -= 1;
 969     }
 970
 971     arr[0].x += mPos.x;
 972     arr[0].y += mPos.y;
 973     arr[1].x += mPos.x;
 974     arr[1].y += mPos.y;
 975     arr[2].x += mPos.x;
 976     arr[2].y += mPos.y;
 977
 978     if ( !mEnabled ) dc.SetBrush( *wxGREY_BRUSH );
 979     else dc.SetBrush( *wxBLACK_BRUSH );
 980
 981     dc.DrawPolygon( 3, arr );
 982     dc.SetBrush( wxNullBrush );
 983 }
 984
 985 /***** Implementation for class cbDockBoxBox *****/
 986
 987 void cbDockBox::Draw( wxDC& dc )
 988 {
 989     cbMiniButton::Draw( dc );
 990
 991     int width = BTN_BOX_WIDTH - 7;
 992
 993     int xOfs = (mPressed) ? 4 : 3;
 994     int yOfs = (mPressed) ? 4 : 3;
 995
 996     dc.SetPen( *wxBLACK_PEN );
 997     dc.SetBrush( *wxBLACK_BRUSH );
 998
 999     dc.DrawRectangle( mPos.x + xOfs, mPos.y + yOfs, width, width );
1000
1001     xOfs += 1;
1002     yOfs += 1;
1003
1004     dc.SetBrush( *wxWHITE_BRUSH );
1005
1006     dc.DrawRectangle( mPos.x + xOfs, mPos.y + yOfs, width-2, width-2 );
1007 }
1008
1009 /***** Implementation for class wxToolWindow *****/
1010
1011 IMPLEMENT_DYNAMIC_CLASS( cbFloatedBarWindow, wxToolWindow )
1012
1013 BEGIN_EVENT_TABLE( cbFloatedBarWindow, wxToolWindow )
1014
1015     EVT_LEFT_DCLICK( cbFloatedBarWindow::OnDblClick )
1016
1017 END_EVENT_TABLE()
1018
1019 cbFloatedBarWindow::cbFloatedBarWindow()
1020
1021     : mpBar( NULL )
1022 {
1023     AddMiniButton( new cbCloseBox() );
1024     AddMiniButton( new cbDockBox()  );
1025 }
1026
1027 void cbFloatedBarWindow::SetBar( cbBarInfo* pBar )
1028 {
1029     mpBar = pBar;
1030 }
1031
1032 cbBarInfo* cbFloatedBarWindow::GetBar()
1033 {
1034     return mpBar;
1035 }
1036
1037 void cbFloatedBarWindow::SetLayout( wxFrameLayout* pLayout )
1038 {
1039     mpLayout = pLayout;
1040 }
1041
1042 void cbFloatedBarWindow::PositionFloatedWnd( int scrX,  int scrY,
1043                                              int width, int height )
1044 {
1045     wxSize minDim = GetMinimalWndDim();
1046
1047     SetSize( scrX - mWndHorizGap - mClntHorizGap,
1048              scrY - mClntVertGap - mTitleHeight - mWndVertGap,
1049              width + minDim.x, height + minDim.y, 0 );
1050 }
1051
1052 wxSize cbFloatedBarWindow::GetPreferredSize( const wxSize& given )
1053 {
1054     if ( mpBar->mDimInfo.GetDimHandler() )
1055     {
1056         cbBarDimHandlerBase* pHandler = mpBar->mDimInfo.GetDimHandler();
1057
1058         wxSize prefDim;
1059
1060         // int vtad = *((int*)pHandler);
1061
1062         pHandler->OnResizeBar( mpBar, given, prefDim );
1063
1064         return prefDim;
1065     }
1066     else
1067     {
1068         if ( mpBar->IsFixed() )
1069             return mpBar->mDimInfo.mSizes[ wxCBAR_FLOATING ];
1070         else
1071             return given; // not-fixed bars are resized exactly the way user wants
1072     }
1073 }
1074
1075 void cbFloatedBarWindow::OnMiniButtonClicked( int btnIdx )
1076 {
1077     // #1 - close mini-button
1078     // #0 - dock mini-button
1079
1080     if ( btnIdx == 0 )
1081     {
1082         mpBar->mAlignment = -1; // sepcial "marking" for hidden bars out of floated state
1083         mpLayout->SetBarState( mpBar, wxCBAR_HIDDEN, true );
1084     }
1085     else
1086         mpLayout->SetBarState( mpBar, wxCBAR_DOCKED_HORIZONTALLY, true );
1087 }
1088
1089 bool cbFloatedBarWindow::HandleTitleClick( wxMouseEvent& event )
1090 {
1091     ReleaseMouse();
1092     mMouseCaptured = false;
1093
1094     wxPoint scrPos;
1095     GetScrMousePos( event, scrPos );
1096
1097     int msX = scrPos.x,
1098         msY = scrPos.y;
1099
1100     mpLayout->GetParentFrame().ScreenToClient( &msX, &msY );
1101
1102     int x,y;
1103     GetPosition(&x,&y);
1104     int w,h;
1105     GetSize( &w, &h );
1106
1107     wxSize minDim = GetMinimalWndDim();
1108
1109     w -= minDim.x;
1110     h -= minDim.y;
1111
1112     x += mWndHorizGap + mClntHorizGap;
1113     y += mWndVertGap  + mTitleHeight + mClntVertGap;
1114
1115     mpLayout->GetParentFrame().ScreenToClient( &x, &y );
1116
1117     wxRect& bounds = mpBar->mDimInfo.mBounds[ wxCBAR_FLOATING ];
1118
1119     bounds.x = x;
1120     bounds.y = y;
1121     bounds.width  = w;
1122     bounds.height = h;
1123
1124     cbStartBarDraggingEvent dragEvt( mpBar, wxPoint(msX,msY),
1125                                      mpLayout->GetPanesArray()[FL_ALIGN_TOP] );
1126
1127     mpLayout->FirePluginEvent( dragEvt );
1128
1129     return true;
1130 }
1131
1132 void cbFloatedBarWindow::OnDblClick( wxMouseEvent& WXUNUSED(event) )
1133 {
1134     mpLayout->SetBarState( mpBar, wxCBAR_DOCKED_HORIZONTALLY, true );
1135
1136     //wxMessageBox("toolWnd - dblClick!");
1137 }
1138