]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/toolwnd.cpp
Defaults in wxWinCE documented.
[wxWidgets.git] / 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