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::GetColour(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     // did the cursor actually changed?
 364
 365     if ( type != mCursorType )
 366     {
 367         mCursorType = type;
 368
 369         switch ( type )
 370         {
 371             case HITS_WND_LEFT_EDGE   : SetCursor( wxCURSOR_SIZEWE ); break;
 372             case HITS_WND_RIGHT_EDGE  : SetCursor( wxCURSOR_SIZEWE ); break;
 373             case HITS_WND_TOP_EDGE    : SetCursor( wxCURSOR_SIZENS ); break;
 374             case HITS_WND_BOTTOM_EDGE : SetCursor( wxCURSOR_SIZENS ); break;
 375
 376             case HITS_WND_TOP_LEFT_CORNER     : SetCursor( wxCURSOR_SIZENWSE ); break;
 377             case HITS_WND_BOTTOM_RIGHT_CORNER : SetCursor( wxCURSOR_SIZENWSE ); break;
 378             case HITS_WND_TOP_RIGHT_CORNER    : SetCursor( wxCURSOR_SIZENESW ); break;
 379             case HITS_WND_BOTTOM_LEFT_CORNER  : SetCursor( wxCURSOR_SIZENESW ); break;
 380
 381             case HITS_WND_TITLE  : SetCursor( wxCURSOR_ARROW ); break;
 382             case HITS_WND_CLIENT : SetCursor( wxCURSOR_ARROW ); break;
 383
 384             default: break;
 385         }
 386
 387         if (mMouseCaptured)
 388         {
 389             mMouseCaptured = false;
 390             ReleaseMouse();
 391         }
 392     }
 393
 394     if ( !mMouseCaptured )
 395     {
 396         mMouseCaptured = true;
 397         CaptureMouse();
 398     }
 399 }
 400
 401 #define FL_INFINITY 32768
 402
 403 static inline void clip_to( int& value, long from, long till )
 404 {
 405     if ( value < from )
 406         value = from;
 407
 408     if ( value > till )
 409         value = till;
 410 }
 411
 412 void wxToolWindow::AdjustRectPos( const wxRect& original, const wxSize& newDim, wxRect& newRect )
 413 {
 414     if ( mCursorType == HITS_WND_TOP_EDGE ||
 415          mCursorType == HITS_WND_TOP_LEFT_CORNER )
 416     {
 417         newRect.x = original.x + original.width  - newDim.x;
 418         newRect.y = original.y + original.height - newDim.y;
 419     }
 420     else
 421     if ( mCursorType == HITS_WND_LEFT_EDGE ||
 422          mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
 423     {
 424         newRect.x = original.x + original.width  - newDim.x;
 425         newRect.y = original.y;
 426     }
 427     else
 428     if ( mCursorType == HITS_WND_RIGHT_EDGE ||
 429          mCursorType == HITS_WND_TOP_RIGHT_CORNER )
 430     {
 431         newRect.x = original.x;
 432         newRect.y = original.y + original.height - newDim.y;
 433     }
 434     else
 435     if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
 436          mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
 437     {
 438         newRect.x = original.x;
 439         newRect.y = original.y;
 440     }
 441
 442     newRect.width  = newDim.x;
 443     newRect.height = newDim.y;
 444 }
 445
 446 void wxToolWindow::CalcResizedRect( wxRect& rect, wxPoint& delta, const wxSize& minDim )
 447 {
 448     // Microsoft's rect-coordinates are best suited
 449     // for the case of corner-clipping
 450
 451     int left   = mInitialRect.x;
 452     int top    = mInitialRect.y;
 453     int right  = mInitialRect.x + mInitialRect.width;
 454     int bottom = mInitialRect.y + mInitialRect.height;
 455
 456     // constraint delta edge is dragged
 457
 458     switch ( mCursorType )
 459     {
 460         case HITS_WND_LEFT_EDGE   : delta.y = 0; break;
 461         case HITS_WND_RIGHT_EDGE  : delta.y = 0; break;
 462         case HITS_WND_TOP_EDGE    : delta.x = 0; break;
 463         case HITS_WND_BOTTOM_EDGE : delta.x = 0; break;
 464         default: break;
 465     }
 466
 467     if ( mCursorType == HITS_WND_TOP_EDGE ||
 468          mCursorType == HITS_WND_TOP_LEFT_CORNER )
 469     {
 470         left += delta.x;
 471         top  += delta.y;
 472
 473         clip_to( left, -FL_INFINITY, mInitialRect.x + mInitialRect.width  - minDim.x  );
 474         clip_to( top,  -FL_INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
 475     }
 476     else
 477     if ( mCursorType == HITS_WND_LEFT_EDGE ||
 478          mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
 479     {
 480         left   += delta.x;
 481         bottom += delta.y;
 482
 483         clip_to( left,    -FL_INFINITY, mInitialRect.x + mInitialRect.width  - minDim.x  );
 484         clip_to( bottom,  mInitialRect.y + minDim.y, FL_INFINITY );
 485     }
 486     else
 487     if ( mCursorType == HITS_WND_RIGHT_EDGE ||
 488         mCursorType == HITS_WND_TOP_RIGHT_CORNER )
 489     {
 490         right += delta.x;
 491         top   += delta.y;
 492
 493         clip_to( right, mInitialRect.x + minDim.x, FL_INFINITY );
 494         clip_to( top,   -FL_INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
 495     }
 496     else
 497     if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
 498          mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
 499     {
 500         right  += delta.x;
 501         bottom += delta.y;
 502
 503         clip_to( right,  mInitialRect.x + minDim.x,  FL_INFINITY );
 504         clip_to( bottom, mInitialRect.y + minDim.y, FL_INFINITY );
 505     }
 506     else
 507     {
 508         wxFAIL_MSG( _T("what did the cursor hit?") );
 509     }
 510
 511     rect.x = left;
 512     rect.y = top;
 513     rect.width  = right - left;
 514     rect.height = bottom - top;
 515 }
 516
 517 wxSize wxToolWindow::GetMinimalWndDim()
 518 {
 519     return wxSize( (mWndHorizGap + mClntHorizGap)*2 + BTN_BOX_WIDTH*4,
 520                    (mWndVertGap  + mClntVertGap )*2 + mTitleHeight );
 521 }
 522
 523 void wxToolWindow::OnMotion( wxMouseEvent& event )
 524 {
 525     if ( !mResizeStarted )
 526     {
 527         for( size_t i = 0; i != mButtons.Count(); ++i )
 528             mButtons[i]->OnMotion( wxPoint( event.m_x, event.m_y ) );
 529
 530         SetHintCursor( HitTestWindow( event ) );
 531         return;
 532     }
 533
 534     wxPoint pos;
 535     GetScrMousePos( event, pos );
 536
 537     if ( mCursorType == HITS_WND_TITLE )
 538     {
 539         int w,h;
 540         GetSize( &w, &h );
 541
 542         SetSize( mInitialRect.x + pos.x - mDragOrigin.x,
 543                  mInitialRect.y + pos.y - mDragOrigin.y,
 544                  w,h, 0 );
 545     }
 546
 547     else
 548     {
 549         wxPoint delta( pos.x - mDragOrigin.x, pos.y - mDragOrigin.y );
 550
 551         wxRect newRect;
 552
 553         wxSize minDim = GetMinimalWndDim();
 554
 555         CalcResizedRect( newRect, delta, minDim );
 556
 557         wxSize borderDim( ( mWndHorizGap + mClntHorizGap )*2,
 558                           ( mWndVertGap  + mClntVertGap  )*2 + mTitleHeight );
 559
 560         wxSize preferred = GetPreferredSize( wxSize( newRect.width  - borderDim.x,
 561                                              newRect.height - borderDim.y ) );
 562
 563         preferred.x += borderDim.x;
 564         preferred.y += borderDim.y;
 565
 566         //CalcResizedRect( newRect, delta, preferred );
 567
 568         wxRect finalRect = newRect;
 569
 570         AdjustRectPos( newRect, preferred, finalRect );
 571
 572         if ( mRealTimeUpdatesOn )
 573         {
 574             SetSize( finalRect.x, finalRect.y,
 575                      finalRect.width, finalRect.height, 0 );
 576         }
 577         else
 578         {
 579             DrawHintRect( mPrevHintRect );
 580             DrawHintRect( finalRect );
 581
 582             ::wxLogTrace(wxT("wxToolWindow"),wxT("%d,%d / %d,%d\n"), finalRect.x, finalRect.y, finalRect.width, finalRect.height);
 583         }
 584
 585         mPrevHintRect = finalRect;
 586     }
 587 }
 588
 589 void wxToolWindow::OnLeftDown( wxMouseEvent& event )
 590 {
 591     int result = HitTestWindow( event );
 592
 593     for( size_t i = 0; i != mButtons.Count(); ++i )
 594     {
 595         mButtons[i]->OnLeftDown( wxPoint( event.m_x, event.m_y ) );
 596
 597         if ( mButtons[i]->IsPressed() )
 598             return; // button hitted,
 599     }
 600
 601     if ( result >= HITS_WND_LEFT_EDGE || result == HITS_WND_TITLE )
 602     {
 603         GetScrMousePos( event, mDragOrigin );
 604
 605         /*
 606         if ( mMouseCaptured `)
 607         {
 608             ReleaseMouse();
 609             mMouseCaptured = false;
 610         }*/
 611
 612         if ( result == HITS_WND_TITLE &&
 613              HandleTitleClick( event ) )
 614             return;
 615
 616         mResizeStarted = true;
 617
 618         int x,y;
 619         GetPosition( &x, &y );
 620
 621         mInitialRect.x = x;
 622         mInitialRect.y = y;
 623
 624         GetSize( &x, &y );
 625         mInitialRect.width  = x;
 626         mInitialRect.height = y;
 627
 628         mPrevHintRect = mInitialRect;
 629
 630         if ( mCursorType != HITS_WND_TITLE && !mRealTimeUpdatesOn )
 631         {
 632             mpScrDc = new wxScreenDC();
 633
 634             wxScreenDC::StartDrawingOnTop( (wxRect*)NULL );
 635
 636             DrawHintRect( mInitialRect );
 637         }
 638     }
 639 }
 640
 641 void wxToolWindow::OnLeftUp( wxMouseEvent& event )
 642 {
 643     for( size_t i = 0; i != mButtons.Count(); ++i )
 644     {
 645         mButtons[i]->OnLeftUp( wxPoint( event.m_x, event.m_y ) );
 646
 647         if ( mButtons[i]->WasClicked() )
 648         {
 649             OnMiniButtonClicked( i ); // notify derived classes
 650             mButtons[i]->Reset();
 651         }
 652     }
 653
 654     if ( mResizeStarted )
 655     {
 656         mResizeStarted = false;
 657
 658         if ( mCursorType != HITS_WND_TITLE )
 659         {
 660             if ( !mRealTimeUpdatesOn )
 661             {
 662                 DrawHintRect( mPrevHintRect );
 663
 664                 wxScreenDC::EndDrawingOnTop();
 665
 666                 delete mpScrDc;
 667
 668                 mpScrDc = NULL;
 669
 670                 SetSize( mPrevHintRect.x, mPrevHintRect.y,
 671                          mPrevHintRect.width, mPrevHintRect.height, 0 );
 672             }
 673         }
 674     }
 675 }
 676
 677 void wxToolWindow::OnSize( wxSizeEvent& WXUNUSED(event) )
 678 {
 679     if ( mpClientWnd )
 680     {
 681         int w,h;
 682         GetSize( &w, &h );
 683
 684         int x = mWndHorizGap + mClntHorizGap;
 685         int y = mWndVertGap  + mTitleHeight + mClntVertGap;
 686
 687         mpClientWnd->SetSize( x-1, y-1,
 688                               w - 2*(mWndHorizGap + mClntHorizGap),
 689                               h - y - mClntVertGap - mWndVertGap,
 690                               0
 691                             );
 692     }
 693
 694     LayoutMiniButtons();
 695 }
 696
 697 wxSize wxToolWindow::GetPreferredSize( const wxSize& given )
 698 {
 699     return given;
 700 }
 701
 702 void wxToolWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 703 {
 704     // nothing
 705 }
 706
 707 /***** Implementation for class cbMiniButton *****/
 708
 709 cbMiniButton::cbMiniButton()
 710
 711     : mVisible( true ),
 712       mEnabled( true ),
 713
 714       mpLayout( NULL ),
 715       mpPane  ( NULL ),
 716       mpPlugin( NULL ),
 717       mpWnd   ( NULL ),
 718
 719       mWasClicked( false ),
 720       mDragStarted( false ),
 721       mPressed( false )
 722 {}
 723
 724 void cbMiniButton::SetPos( const wxPoint& pos )
 725 {
 726     mPos = pos;
 727 }
 728
 729 bool cbMiniButton::HitTest( const wxPoint& pos )
 730 {
 731     if ( !mVisible ) return false;
 732
 733     return ( pos.x >= mPos.x && pos.y >= mPos.y &&
 734              pos.x < mPos.x + BTN_BOX_WIDTH     &&
 735              pos.y < mPos.y + BTN_BOX_HEIGHT );
 736 }
 737
 738 void cbMiniButton::OnLeftDown( const wxPoint& pos )
 739 {
 740     if ( !mVisible || mDragStarted ) return;
 741
 742     if ( HitTest( pos ) && mEnabled )
 743     {
 744         if ( mpPlugin )
 745         {
 746             mpLayout->CaptureEventsForPane( mpPane );
 747             mpLayout->CaptureEventsForPlugin( mpPlugin );
 748         }
 749         else
 750             mpWnd->CaptureMouse();
 751
 752         mDragStarted = true;
 753         mPressed     = true;
 754         mWasClicked  = false;
 755
 756         Refresh();
 757     }
 758 }
 759
 760 void cbMiniButton::OnLeftUp( const wxPoint& WXUNUSED(pos) )
 761 {
 762     if ( !mVisible || !mDragStarted ) return;
 763
 764     if ( mpPlugin )
 765     {
 766         mpLayout->ReleaseEventsFromPane( mpPane );
 767         mpLayout->ReleaseEventsFromPlugin( mpPlugin );
 768     }
 769     else
 770         mpWnd->ReleaseMouse();
 771
 772     mWasClicked  = mPressed;
 773     mDragStarted = false;
 774
 775     mPressed = false;
 776     Refresh();
 777 }
 778
 779 void cbMiniButton::OnMotion( const wxPoint& pos )
 780 {
 781     if ( !mVisible ) return;
 782
 783     if ( mDragStarted )
 784     {
 785         mPressed = HitTest( pos );
 786
 787         Refresh();
 788     }
 789 }
 790
 791 void cbMiniButton::Refresh()
 792 {
 793     if ( mpLayout )
 794     {
 795          wxClientDC dc( &mpLayout->GetParentFrame() );
 796
 797          Draw( dc );
 798     }
 799     else
 800     {
 801         wxWindowDC dc( mpWnd );
 802
 803         Draw( dc );
 804     }
 805 }
 806
 807 void cbMiniButton::Draw( wxDC& dc )
 808 {
 809     if ( !mVisible ) return;
 810
 811     dc.SetPen( *wxTRANSPARENT_PEN );
 812
 813     dc.SetBrush( *wxLIGHT_GREY_BRUSH );
 814
 815     dc.DrawRectangle( mPos.x + 1, mPos.y + 1, BTN_BOX_WIDTH - 2, BTN_BOX_HEIGHT - 2 );
 816
 817     // "hard-code" metafile
 818
 819     if ( !mPressed )
 820         dc.SetPen( *wxWHITE_PEN );
 821     else
 822         dc.SetPen( *wxBLACK_PEN );
 823
 824     dc.DrawLine( mPos.x, mPos.y, mPos.x + BTN_BOX_WIDTH, mPos.y );
 825     dc.DrawLine( mPos.x, mPos.y, mPos.x, mPos.y + BTN_BOX_HEIGHT );
 826
 827     dc.SetPen( *wxGREY_PEN );
 828
 829     if ( !mPressed )
 830     {
 831         dc.DrawLine( mPos.x + 1, mPos.y + BTN_BOX_HEIGHT - 2,
 832                      mPos.x + BTN_BOX_WIDTH - 1, mPos.y + BTN_BOX_HEIGHT - 2 );
 833
 834         dc.DrawLine( mPos.x + BTN_BOX_WIDTH - 2, mPos.y + 1,
 835                      mPos.x + BTN_BOX_WIDTH - 2, mPos.y + BTN_BOX_HEIGHT - 1 );
 836     }
 837     else
 838     {
 839         dc.DrawLine( mPos.x + 1, mPos.y + 1,
 840                      mPos.x + BTN_BOX_WIDTH - 2, mPos.y + 1 );
 841
 842         dc.DrawLine( mPos.x + 1, mPos.y + 1,
 843                      mPos.x + 1, mPos.y + BTN_BOX_HEIGHT - 2 );
 844     }
 845
 846     if ( !mPressed )
 847         dc.SetPen( *wxBLACK_PEN );
 848     else
 849         dc.SetPen( *wxWHITE_PEN );
 850
 851     dc.DrawLine( mPos.x, mPos.y + BTN_BOX_HEIGHT - 1,
 852                  mPos.x + BTN_BOX_WIDTH, mPos.y + BTN_BOX_HEIGHT - 1 );
 853
 854     dc.DrawLine( mPos.x + BTN_BOX_WIDTH - 1, mPos.y ,
 855                  mPos.x + BTN_BOX_WIDTH - 1, mPos.y + BTN_BOX_HEIGHT );
 856 }
 857
 858 bool cbMiniButton::WasClicked()
 859 {
 860     return mWasClicked;
 861 }
 862
 863 void cbMiniButton::Reset()
 864 {
 865     mWasClicked = false;
 866 }
 867
 868 /***** Implementation fro class cbCloseBox *****/
 869
 870 void cbCloseBox::Draw( wxDC& dc )
 871 {
 872     cbMiniButton::Draw( dc );
 873
 874     dc.SetPen( *wxBLACK_PEN );
 875
 876     int width = BTN_BOX_WIDTH - 7;
 877
 878     int xOfs = (mPressed) ? 4 : 3;
 879     int yOfs = (mPressed) ? 4 : 3;
 880
 881     for( int i = 0; i != BTN_X_WEIGHT; ++i )
 882     {
 883         dc.DrawLine( mPos.x + xOfs + i,
 884                      mPos.y + yOfs,
 885                      mPos.x + xOfs + i + width,
 886                      mPos.y + yOfs + width );
 887
 888         dc.DrawLine( mPos.x + xOfs + i + width - 1,
 889                      mPos.y + yOfs,
 890                      mPos.x + xOfs + i - 1,
 891                      mPos.y + yOfs + width );
 892     }
 893 }
 894
 895 /***** Implementation fro class cbCollapseBox *****/
 896
 897 inline static void my_swap( int& a, int& b )
 898 {
 899     long tmp = a;
 900     a = b;
 901     b = tmp;
 902 }
 903
 904 void cbCollapseBox::Draw( wxDC& dc )
 905 {
 906     cbMiniButton::Draw( dc );
 907
 908     dc.SetPen( *wxTRANSPARENT_PEN );
 909
 910     wxPoint arr[3];
 911
 912     int yOfs  = (mPressed) ? 3 : 2;
 913     int xOfs  = (mPressed) ? 5 : 4;
 914     int width = BTN_BOX_WIDTH - 8;
 915
 916     // rotating/shifting triangle inside collapse box
 917
 918     arr[0].x = xOfs;
 919     arr[0].y = yOfs-1;
 920     arr[2].x = xOfs;
 921     arr[2].y = BTN_BOX_HEIGHT - yOfs - 1;
 922     arr[1].x = xOfs + width;
 923     arr[1].y = (arr[2].y + arr[0].y)/2;
 924
 925     if ( !mIsAtLeft )
 926     {
 927         arr[0].x = BTN_BOX_WIDTH - arr[0].x;
 928         arr[1].x = BTN_BOX_WIDTH - arr[1].x;
 929         arr[2].x = BTN_BOX_WIDTH - arr[2].x;
 930     }
 931
 932     if ( !mpPane->IsHorizontal() )
 933     {
 934         my_swap( arr[0].y, arr[0].x );
 935         my_swap( arr[1].y, arr[1].x );
 936         my_swap( arr[2].y, arr[2].x );
 937
 938         arr[0].x += 1;
 939         arr[1].x += 1;
 940         arr[2].x += 1;
 941
 942         //arr[1].y -= 1;
 943     }
 944
 945     arr[0].x += mPos.x;
 946     arr[0].y += mPos.y;
 947     arr[1].x += mPos.x;
 948     arr[1].y += mPos.y;
 949     arr[2].x += mPos.x;
 950     arr[2].y += mPos.y;
 951
 952     if ( !mEnabled ) dc.SetBrush( *wxGREY_BRUSH );
 953     else dc.SetBrush( *wxBLACK_BRUSH );
 954
 955     dc.DrawPolygon( 3, arr );
 956     dc.SetBrush( wxNullBrush );
 957 }
 958
 959 /***** Implementation for class cbDockBoxBox *****/
 960
 961 void cbDockBox::Draw( wxDC& dc )
 962 {
 963     cbMiniButton::Draw( dc );
 964
 965     int width = BTN_BOX_WIDTH - 7;
 966
 967     int xOfs = (mPressed) ? 4 : 3;
 968     int yOfs = (mPressed) ? 4 : 3;
 969
 970     dc.SetPen( *wxBLACK_PEN );
 971     dc.SetBrush( *wxBLACK_BRUSH );
 972
 973     dc.DrawRectangle( mPos.x + xOfs, mPos.y + yOfs, width, width );
 974
 975     xOfs += 1;
 976     yOfs += 1;
 977
 978     dc.SetBrush( *wxWHITE_BRUSH );
 979
 980     dc.DrawRectangle( mPos.x + xOfs, mPos.y + yOfs, width-2, width-2 );
 981 }
 982
 983 /***** Implementation for class wxToolWindow *****/
 984
 985 IMPLEMENT_DYNAMIC_CLASS( cbFloatedBarWindow, wxToolWindow )
 986
 987 BEGIN_EVENT_TABLE( cbFloatedBarWindow, wxToolWindow )
 988
 989     EVT_LEFT_DCLICK( cbFloatedBarWindow::OnDblClick )
 990
 991 END_EVENT_TABLE()
 992
 993 cbFloatedBarWindow::cbFloatedBarWindow()
 994
 995     : mpBar( NULL )
 996 {
 997     AddMiniButton( new cbCloseBox() );
 998     AddMiniButton( new cbDockBox()  );
 999 }
1000
1001 void cbFloatedBarWindow::SetBar( cbBarInfo* pBar )
1002 {
1003     mpBar = pBar;
1004 }
1005
1006 cbBarInfo* cbFloatedBarWindow::GetBar()
1007 {
1008     return mpBar;
1009 }
1010
1011 void cbFloatedBarWindow::SetLayout( wxFrameLayout* pLayout )
1012 {
1013     mpLayout = pLayout;
1014 }
1015
1016 void cbFloatedBarWindow::PositionFloatedWnd( int scrX,  int scrY,
1017                                              int width, int height )
1018 {
1019     wxSize minDim = GetMinimalWndDim();
1020
1021     SetSize( scrX - mWndHorizGap - mClntHorizGap,
1022              scrY - mClntVertGap - mTitleHeight - mWndVertGap,
1023              width + minDim.x, height + minDim.y, 0 );
1024 }
1025
1026 wxSize cbFloatedBarWindow::GetPreferredSize( const wxSize& given )
1027 {
1028     if ( mpBar->mDimInfo.GetDimHandler() )
1029     {
1030         cbBarDimHandlerBase* pHandler = mpBar->mDimInfo.GetDimHandler();
1031
1032         wxSize prefDim;
1033
1034         // int vtad = *((int*)pHandler);
1035
1036         pHandler->OnResizeBar( mpBar, given, prefDim );
1037
1038         return prefDim;
1039     }
1040     else
1041     {
1042         if ( mpBar->IsFixed() )
1043             return mpBar->mDimInfo.mSizes[ wxCBAR_FLOATING ];
1044         else
1045             return given; // not-fixed bars are resized exactly the way user wants
1046     }
1047 }
1048
1049 void cbFloatedBarWindow::OnMiniButtonClicked( int btnIdx )
1050 {
1051     // #1 - close mini-button
1052     // #0 - dock mini-button
1053
1054     if ( btnIdx == 0 )
1055     {
1056         mpBar->mAlignment = -1; // sepcial "marking" for hidden bars out of floated state
1057         mpLayout->SetBarState( mpBar, wxCBAR_HIDDEN, true );
1058     }
1059     else
1060         mpLayout->SetBarState( mpBar, wxCBAR_DOCKED_HORIZONTALLY, true );
1061 }
1062
1063 bool cbFloatedBarWindow::HandleTitleClick( wxMouseEvent& event )
1064 {
1065     ReleaseMouse();
1066     mMouseCaptured = false;
1067
1068     wxPoint scrPos;
1069     GetScrMousePos( event, scrPos );
1070
1071     int msX = scrPos.x,
1072         msY = scrPos.y;
1073
1074     mpLayout->GetParentFrame().ScreenToClient( &msX, &msY );
1075
1076     int x,y;
1077     GetPosition(&x,&y);
1078     int w,h;
1079     GetSize( &w, &h );
1080
1081     wxSize minDim = GetMinimalWndDim();
1082
1083     w -= minDim.x;
1084     h -= minDim.y;
1085
1086     x += mWndHorizGap + mClntHorizGap;
1087     y += mWndVertGap  + mTitleHeight + mClntVertGap;
1088
1089     mpLayout->GetParentFrame().ScreenToClient( &x, &y );
1090
1091     wxRect& bounds = mpBar->mDimInfo.mBounds[ wxCBAR_FLOATING ];
1092
1093     bounds.x = x;
1094     bounds.y = y;
1095     bounds.width  = w;
1096     bounds.height = h;
1097
1098     cbStartBarDraggingEvent dragEvt( mpBar, wxPoint(msX,msY),
1099                                      mpLayout->GetPanesArray()[FL_ALIGN_TOP] );
1100
1101     mpLayout->FirePluginEvent( dragEvt );
1102
1103     return true;
1104 }
1105
1106 void cbFloatedBarWindow::OnDblClick( wxMouseEvent& WXUNUSED(event) )
1107 {
1108     mpLayout->SetBarState( mpBar, wxCBAR_DOCKED_HORIZONTALLY, true );
1109
1110     //wxMessageBox("toolWnd - dblClick!");
1111 }
1112