]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/toolwnd.cpp
projects / wxWidgets.git / blob
? search:


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