]> 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
More build system polishing.. mostly. Some stuff ported over from
[wxWidgets.git] / contrib / src / fl / toolwnd.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: No names yet.
3 // Purpose: Contrib. demo
4 // Author: Aleksandras Gluchovas
5 // Modified by:
6 // Created: 06/09/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Aleksandras Gluchovas
9 // Licence: wxWindows license
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 dc.SetBrush( *wxLIGHT_GREY_BRUSH );
169 dc.SetPen( *wxTRANSPARENT_PEN );
170
171 int y = mWndVertGap + mTitleHeight + mClntVertGap + 1;
172 dc.DrawRectangle( 0,0, w, y );
173 dc.DrawRectangle( 0,y-1, mWndHorizGap + mClntHorizGap + 1, h - y );
174 dc.DrawRectangle( w - ( mWndHorizGap + mClntHorizGap ), y-1,
175 mWndHorizGap + mClntHorizGap, h - y );
176 dc.DrawRectangle( 0, h - mWndVertGap - mClntVertGap, w, mWndVertGap + mClntVertGap );
177
178 // draw shades
179 dc.SetPen( *wxLIGHT_GREY_PEN );
180
181 dc.DrawLine( 0,0, w, 0 );
182 dc.DrawLine( 0,0, 0, h );
183
184 dc.SetPen( *wxWHITE_PEN );
185
186 dc.DrawLine( 1,1, w, 1 );
187 dc.DrawLine( 1,2, 1, h );
188
189 dc.SetPen( *wxGREY_PEN );
190
191 dc.DrawLine( w - 2, 1, w - 2, h - 1 );
192 dc.DrawLine( 1, h - 2, w - 2, h - 2 );
193
194 dc.SetPen( *wxBLACK_PEN );
195
196 dc.DrawLine( 0, h - 1, w, h - 1 );
197 dc.DrawLine( w-1, 0, w-1, h );
198
199 // fill inner area
200
201 dc.SetBrush( *wxTheBrushList->FindOrCreateBrush( wxColour( 0,0,128 ), wxSOLID ) );
202
203 dc.DrawRectangle( mWndHorizGap, mWndVertGap, w - mWndHorizGap*2, mTitleHeight );
204
205 dc.SetFont( mTitleFont );
206
207 for( size_t i = 0; i != mButtons.Count(); ++i )
208
209 mButtons[i]->Draw( dc );
210
211 int x1 = mWndHorizGap + mClntHorizGap;
212 int x2 = mButtons[ mButtons.GetCount() - 1 ]->mPos.x - mClntHorizGap*2;
213
214 dc.SetClippingRegion( x1, mWndVertGap + mClntVertGap, x2 - x1, mTitleHeight );
215
216 dc.SetTextForeground( *wxWHITE );
217 dc.SetBackgroundMode( wxTRANSPARENT );
218 dc.DrawText( GetTitle(), mWndHorizGap + 2, mWndVertGap + 1 );
219 }
220
221 void wxToolWindow::GetScrWindowRect( wxRect& r )
222 {
223 int x,y;
224 GetPosition(&x,&y);
225 int w,h;
226 GetSize( &w, &h );
227
228 r.x = x; r.y = y;
229 r.width = w; r.height = h;
230 }
231
232 void wxToolWindow::GetScrMousePos( wxMouseEvent& event, wxPoint& pos )
233 {
234 int x = event.m_x, y = event.m_y;
235
236 ClientToScreen( &x, &y );
237
238 pos.x = x; pos.y = y;
239 }
240
241 int wxToolWindow::HitTestWindow( wxMouseEvent& event )
242 {
243 wxPoint pos;
244 wxRect r;
245
246 GetScrMousePos( event, pos );
247 GetScrWindowRect( r );
248
249 int k = mMTolerance;
250
251 if ( !( pos.x >= r.x && pos.y >= r.y &&
252 pos.x < r.x + r.width &&
253 pos.y < r.y + r.height )
254 )
255 return HITS_WND_NOTHING;
256
257 if ( pos.y <= r.y + k )
258 {
259 if ( pos.x < r.x + k*2 )
260
261 return HITS_WND_TOP_LEFT_CORNER;
262 else
263 if ( pos.x >= r.x + r.width - k*2 )
264
265 return HITS_WND_TOP_RIGHT_CORNER;
266 else
267 return HITS_WND_TOP_EDGE;
268 }
269 else
270 if ( pos.y >= r.y + r.height - k )
271 {
272 if ( pos.x < r.x + k*2 )
273
274 return HITS_WND_BOTTOM_LEFT_CORNER;
275 else
276 if ( pos.x > r.x + r.width - k*2 )
277
278 return HITS_WND_BOTTOM_RIGHT_CORNER;
279 else
280 return HITS_WND_BOTTOM_EDGE;
281 }
282 else
283 if ( pos.x <= r.x + k )
284
285 return HITS_WND_LEFT_EDGE;
286 else
287 if ( pos.x >= r.x + r.width - k )
288
289 return HITS_WND_RIGHT_EDGE;
290 else
291 {
292 if ( pos.y <= r.y + mWndVertGap + mTitleHeight + mClntVertGap )
293
294 return HITS_WND_TITLE;
295 else
296 return HITS_WND_CLIENT;
297 }
298 }
299
300 void wxToolWindow::DrawHintRect( const wxRect& r )
301 {
302 // BUG BUG BUG (wx):: somehow stippled brush works only
303 // when the bitmap created on stack, not
304 // as a member of the class
305
306 int prevLF = mpScrDc->GetLogicalFunction();
307
308 mpScrDc->SetLogicalFunction( wxXOR );
309
310 wxBitmap checker( (const char*)_gCheckerImg, 8,8 );
311
312 wxBrush checkerBrush( checker );
313
314 mpScrDc->SetPen( *wxTRANSPARENT_PEN );
315 mpScrDc->SetBrush( checkerBrush );
316
317 int half = mHintBorder / 2;
318
319 mpScrDc->DrawRectangle( r.x - half, r.y - half,
320 r.width + 2*half, mHintBorder );
321
322 mpScrDc->DrawRectangle( r.x - half, r.y + r.height - half,
323 r.width + 2*half, mHintBorder );
324
325 mpScrDc->DrawRectangle( r.x - half, r.y + half - 1,
326 mHintBorder, r.height - 2*half + 2);
327
328 mpScrDc->DrawRectangle( r.x + r.width - half,
329 r.y + half - 1,
330 mHintBorder, r.height - 2*half + 2);
331
332 mpScrDc->SetBrush( wxNullBrush );
333
334 mpScrDc->SetLogicalFunction( prevLF );
335 }
336
337 void wxToolWindow::SetHintCursor( int type )
338 {
339 if ( mResizeStarted ) return;
340
341 if ( type == HITS_WND_NOTHING || type == HITS_WND_CLIENT )
342 {
343 // the cursor is out of window - reset to arrow
344
345 if ( mMouseCaptured && !mResizeStarted )
346 {
347 ReleaseMouse();
348 mMouseCaptured = FALSE;
349 }
350
351 if ( mCursorType == HITS_WND_NOTHING && !mResizeStarted )
352
353 SetCursor( wxCURSOR_ARROW );
354
355 mCursorType = type;
356
357 return;
358 }
359
360 if ( !mMouseCaptured )
361 {
362 mMouseCaptured = TRUE;
363 CaptureMouse();
364 }
365
366 // did the cursor actually changed?
367
368 if ( type != mCursorType )
369 {
370 mCursorType = type;
371
372 switch ( type )
373 {
374 case HITS_WND_LEFT_EDGE : SetCursor( wxCURSOR_SIZEWE ); break;
375 case HITS_WND_RIGHT_EDGE : SetCursor( wxCURSOR_SIZEWE ); break;
376 case HITS_WND_TOP_EDGE : SetCursor( wxCURSOR_SIZENS ); break;
377 case HITS_WND_BOTTOM_EDGE : SetCursor( wxCURSOR_SIZENS ); break;
378
379 case HITS_WND_TOP_LEFT_CORNER : SetCursor( wxCURSOR_SIZENWSE ); break;
380 case HITS_WND_BOTTOM_RIGHT_CORNER : SetCursor( wxCURSOR_SIZENWSE ); break;
381 case HITS_WND_TOP_RIGHT_CORNER : SetCursor( wxCURSOR_SIZENESW ); break;
382 case HITS_WND_BOTTOM_LEFT_CORNER : SetCursor( wxCURSOR_SIZENESW ); break;
383
384 case HITS_WND_TITLE : SetCursor( wxCURSOR_ARROW ); break;
385 case HITS_WND_CLIENT : SetCursor( wxCURSOR_ARROW ); break;
386
387 default: break;
388 }
389 }
390 }
391
392 #define INFINITY 32768
393
394 static inline void clip_to( int& value, long from, long till )
395 {
396 if ( value < from )
397 value = from;
398
399 if ( value > till )
400 value = till;
401 }
402
403 void wxToolWindow::AdjustRectPos( const wxRect& original, const wxSize& newDim, wxRect& newRect )
404 {
405 if ( mCursorType == HITS_WND_TOP_EDGE ||
406 mCursorType == HITS_WND_TOP_LEFT_CORNER )
407 {
408 newRect.x = original.x + original.width - newDim.x;
409 newRect.y = original.y + original.height - newDim.y;
410 }
411 else
412 if ( mCursorType == HITS_WND_LEFT_EDGE ||
413 mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
414 {
415 newRect.x = original.x + original.width - newDim.x;
416 newRect.y = original.y;
417 }
418 else
419 if ( mCursorType == HITS_WND_RIGHT_EDGE ||
420 mCursorType == HITS_WND_TOP_RIGHT_CORNER )
421 {
422 newRect.x = original.x;
423 newRect.y = original.y + original.height - newDim.y;
424 }
425 else
426 if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
427 mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
428 {
429 newRect.x = original.x;
430 newRect.y = original.y;
431 }
432
433 newRect.width = newDim.x;
434 newRect.height = newDim.y;
435 }
436
437 void wxToolWindow::CalcResizedRect( wxRect& rect, wxPoint& delta, const wxSize& minDim )
438 {
439 // Microsoft's rect-coordinates are best suited
440 // for the case of corner-clipping
441
442 int left = mInitialRect.x;
443 int top = mInitialRect.y;
444 int right = mInitialRect.x + mInitialRect.width;
445 int bottom = mInitialRect.y + mInitialRect.height;
446
447 // constraint delta edge is dragged
448
449 switch ( mCursorType )
450 {
451 case HITS_WND_LEFT_EDGE : delta.y = 0; break;
452 case HITS_WND_RIGHT_EDGE : delta.y = 0; break;
453 case HITS_WND_TOP_EDGE : delta.x = 0; break;
454 case HITS_WND_BOTTOM_EDGE : delta.x = 0; break;
455 default: break;
456 }
457
458 if ( mCursorType == HITS_WND_TOP_EDGE ||
459 mCursorType == HITS_WND_TOP_LEFT_CORNER )
460 {
461 left += delta.x;
462 top += delta.y;
463
464 clip_to( left, -INFINITY, mInitialRect.x + mInitialRect.width - minDim.x );
465 clip_to( top, -INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
466 }
467 else
468 if ( mCursorType == HITS_WND_LEFT_EDGE ||
469 mCursorType == HITS_WND_BOTTOM_LEFT_CORNER )
470 {
471 left += delta.x;
472 bottom += delta.y;
473
474 clip_to( left, -INFINITY, mInitialRect.x + mInitialRect.width - minDim.x );
475 clip_to( bottom, mInitialRect.y + minDim.y, INFINITY );
476 }
477 else
478 if ( mCursorType == HITS_WND_RIGHT_EDGE ||
479 mCursorType == HITS_WND_TOP_RIGHT_CORNER )
480 {
481 right += delta.x;
482 top += delta.y;
483
484 clip_to( right, mInitialRect.x + minDim.x, INFINITY );
485 clip_to( top, -INFINITY, mInitialRect.y + mInitialRect.height - minDim.y );
486 }
487 else
488 if ( mCursorType == HITS_WND_BOTTOM_EDGE ||
489 mCursorType == HITS_WND_BOTTOM_RIGHT_CORNER )
490 {
491 right += delta.x;
492 bottom += delta.y;
493
494 clip_to( right, mInitialRect.x + minDim.x, INFINITY );
495 clip_to( bottom, mInitialRect.y + minDim.y, INFINITY );
496 }
497 else
498 {
499 int avoidCompilerWarning = 0;
500 wxASSERT(avoidCompilerWarning); // DBG::
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
576 mPrevHintRect = finalRect;
577 }
578 }
579
580 void wxToolWindow::OnLeftDown( wxMouseEvent& event )
581 {
582 int result = HitTestWindow( event );
583
584 for( size_t i = 0; i != mButtons.Count(); ++i )
585 {
586 mButtons[i]->OnLeftDown( wxPoint( event.m_x, event.m_y ) );
587
588 if ( mButtons[i]->IsPressed() )
589
590 return; // button hitted,
591 }
592
593 if ( result >= HITS_WND_LEFT_EDGE || result == HITS_WND_TITLE )
594 {
595 GetScrMousePos( event, mDragOrigin );
596
597 /*
598 if ( mMouseCaptured `)
599 {
600 ReleaseMouse();
601 mMouseCaptured = FALSE;
602 }*/
603
604 if ( result == HITS_WND_TITLE &&
605 HandleTitleClick( event )
606 )
607 {
608
609 return;
610 }
611
612 mResizeStarted = TRUE;
613
614 int x,y;
615 GetPosition( &x, &y );
616
617 mInitialRect.x = x;
618 mInitialRect.y = y;
619
620 GetSize( &x, &y );
621 mInitialRect.width = x;
622 mInitialRect.height = y;
623
624 mPrevHintRect = mInitialRect;
625
626 if ( mCursorType != HITS_WND_TITLE && !mRealTimeUpdatesOn )
627 {
628 mpScrDc = new wxScreenDC();
629
630 wxScreenDC::StartDrawingOnTop( (wxRect*)NULL );
631
632 DrawHintRect( mInitialRect );
633 }
634 }
635 }
636
637 void wxToolWindow::OnLeftUp( wxMouseEvent& event )
638 {
639 for( size_t i = 0; i != mButtons.Count(); ++i )
640 {
641 mButtons[i]->OnLeftUp( wxPoint( event.m_x, event.m_y ) );
642
643 if ( mButtons[i]->WasClicked() )
644 {
645 OnMiniButtonClicked( i ); // notify derived classes
646 mButtons[i]->Reset();
647 }
648 }
649
650 if ( mResizeStarted )
651 {
652 mResizeStarted = FALSE;
653
654 if ( mCursorType != HITS_WND_TITLE )
655 {
656 if ( !mRealTimeUpdatesOn )
657 {
658 DrawHintRect( mPrevHintRect );
659
660 wxScreenDC::EndDrawingOnTop();
661
662 delete mpScrDc;
663
664 mpScrDc = NULL;
665
666 SetSize( mPrevHintRect.x, mPrevHintRect.y,
667 mPrevHintRect.width, mPrevHintRect.height, 0 );
668 }
669 }
670 }
671 }
672
673 void wxToolWindow::OnSize( wxSizeEvent& event )
674 {
675 if ( mpClientWnd )
676 {
677 int w,h;
678 GetSize( &w, &h );
679
680 int x = mWndHorizGap + mClntHorizGap;
681 int y = mWndVertGap + mTitleHeight + mClntVertGap;
682
683 #if 1
684 mpClientWnd->SetSize( x -1, y -1,
685 w - 2*(mWndHorizGap + mClntHorizGap),
686 h - y - mClntVertGap - mWndVertGap,
687 0
688 );
689 #endif
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 #ifdef __WXGTK__
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)