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