Commit | Line | Data |
---|---|---|
8e08b761 JS |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: No names yet. | |
3 | // Purpose: Contrib. demo | |
4 | // Author: Aleksandras Gluchovas | |
5 | // Modified by: | |
6 | // Created: 06/10/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Aleksandras Gluchovas | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifdef __GNUG__ | |
13 | #pragma implementation "rowdragpl.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/rowdragpl.h" | |
28 | ||
29 | #define MINIMAL_ROW_DRAG_OFS 5 | |
30 | ||
31 | // parameters for row-hints of NC-look | |
32 | ||
33 | #define TRIANGLE_OFFSET 2 | |
34 | #define TRIANGLE_TO_PAT_GAP 2 | |
35 | #define PAT_OFFSET 2 | |
36 | #define COLLAPSED_ICON_WIDTH 45 | |
37 | #define COLLAPSED_ICON_HEIGHT 9 | |
38 | #define ROW_DRAG_HINT_WIDTH 10 | |
39 | #define ICON_TRIAN_WIDTH 6 | |
40 | #define ICON_TRIAN_HEIGHT 3 | |
41 | ||
42 | /***** Implementation for class cbHiddenBarInfo *****/ | |
43 | ||
44 | IMPLEMENT_DYNAMIC_CLASS( cbHiddenBarInfo, wxObject ) | |
45 | ||
46 | /***** Implementation for class cbRowDragPlugin *****/ | |
47 | ||
48 | IMPLEMENT_DYNAMIC_CLASS( cbRowDragPlugin, cbPluginBase ) | |
49 | ||
50 | BEGIN_EVENT_TABLE( cbRowDragPlugin, cbPluginBase ) | |
51 | ||
52 | EVT_PL_LEFT_DOWN ( cbRowDragPlugin::OnLButtonDown ) | |
53 | EVT_PL_LEFT_UP ( cbRowDragPlugin::OnLButtonUp ) | |
54 | EVT_PL_MOTION ( cbRowDragPlugin::OnMouseMove ) | |
55 | ||
56 | EVT_PL_DRAW_PANE_DECOR ( cbRowDragPlugin::OnDrawPaneBackground ) | |
57 | ||
58 | END_EVENT_TABLE() | |
59 | ||
60 | // FIXME:: how to eliminated these cut&pasted constructors? | |
61 | ||
62 | cbRowDragPlugin::cbRowDragPlugin(void) | |
63 | ||
64 | : mHightColor ( 192, 192, 255 ), | |
65 | mLowColor ( 192, 192, 192 ), | |
66 | mTrianInnerColor ( 0,0,255 ), | |
67 | mTrianInnerPen ( mTrianInnerColor, 1, wxSOLID ), | |
68 | ||
69 | mDragStarted ( FALSE ), | |
70 | mDecisionMode ( FALSE ), | |
71 | mCurDragOfs ( 0 ), | |
72 | mCaptureIsOn ( FALSE ), | |
73 | mSvTopMargin ( -1 ), | |
74 | mSvBottomMargin ( -1 ), | |
75 | mSvLeftMargin ( -1 ), | |
76 | mSvRightMargin ( -1 ), | |
77 | ||
78 | mpPaneImage ( NULL ), | |
79 | mpRowImage ( NULL ), | |
80 | mpCombinedImage ( NULL ), | |
81 | ||
82 | mpRowInFocus ( NULL ), | |
83 | mCollapsedIconInFocus( -1 ), | |
84 | ||
85 | mpPane ( NULL ) | |
86 | { | |
87 | } | |
88 | ||
89 | cbRowDragPlugin::cbRowDragPlugin( wxFrameLayout* pLayout, int paneMask ) | |
90 | ||
91 | : cbPluginBase( pLayout, paneMask ), | |
92 | ||
93 | mHightColor ( 192, 192, 255 ), | |
94 | mLowColor ( 192, 192, 192 ), | |
95 | mTrianInnerColor ( 0,0,255 ), | |
96 | mTrianInnerPen ( mTrianInnerColor, 1, wxSOLID ), | |
97 | ||
98 | mDragStarted ( FALSE ), | |
99 | mDecisionMode ( FALSE ), | |
100 | mCurDragOfs ( 0 ), | |
101 | mCaptureIsOn ( FALSE ), | |
102 | mSvTopMargin ( -1 ), | |
103 | mSvBottomMargin ( -1 ), | |
104 | mSvLeftMargin ( -1 ), | |
105 | mSvRightMargin ( -1 ), | |
106 | ||
107 | mpPaneImage ( NULL ), | |
108 | mpRowImage ( NULL ), | |
109 | mpCombinedImage ( NULL ), | |
110 | ||
111 | mpRowInFocus ( NULL ), | |
112 | mCollapsedIconInFocus( -1 ), | |
113 | ||
114 | mpPane ( NULL ) | |
115 | { | |
116 | } | |
117 | ||
118 | cbRowDragPlugin::~cbRowDragPlugin() | |
119 | { | |
120 | } | |
121 | ||
122 | // handlers for plugin events | |
123 | void cbRowDragPlugin::OnMouseMove( cbMotionEvent& event ) | |
124 | { | |
125 | // short-cuts | |
126 | wxPoint pos = event.mPos; | |
127 | mpPane = event.mpPane; | |
128 | ||
129 | mpPane->PaneToFrame( &pos.x, &pos.y ); | |
130 | ||
131 | if ( !mDragStarted ) | |
132 | { | |
133 | if ( mDecisionMode && mpRowInFocus ) | |
134 | { | |
135 | int ofs; | |
136 | ||
137 | if ( mpPane->IsHorizontal() ) | |
138 | ||
139 | ofs = pos.y - mDragOrigin.y; | |
140 | else | |
141 | ofs = pos.x - mDragOrigin.x; | |
142 | ||
143 | // check if the item was dragged sufficeintly | |
144 | // far, enough to consider that user really intends | |
145 | // to drag it | |
146 | ||
147 | if ( ofs >= MINIMAL_ROW_DRAG_OFS || | |
148 | ofs <= -MINIMAL_ROW_DRAG_OFS ) | |
149 | { | |
150 | // DBG:: | |
151 | //.wxPoint pos = event.mPos; | |
152 | //wxPoint drg = mDragOrigin; | |
153 | //int dif = event.mPos.x - mDragOrigin.x; | |
154 | ||
155 | mDragStarted = TRUE; | |
156 | mDecisionMode = FALSE; | |
157 | mDragOrigin = pos; | |
158 | ||
159 | PrepareForRowDrag(); | |
160 | return; | |
161 | } | |
162 | ||
163 | // this plugin "eats" all mouse input while item is dragged, | |
164 | return; | |
165 | } | |
166 | ||
167 | cbRowInfo* pRow = GetFirstRow(); | |
168 | ||
169 | bool focusFound = FALSE; | |
170 | ||
171 | while( pRow ) | |
172 | { | |
173 | if ( HitTestRowDragHint( pRow, pos ) ) | |
174 | { | |
175 | CheckPrevItemInFocus( pRow, -1 ); | |
176 | SetMouseCapture( TRUE ); | |
177 | ||
178 | focusFound = TRUE; | |
179 | ||
180 | mpRowInFocus = pRow; | |
181 | mCollapsedIconInFocus = -1; | |
182 | break; | |
183 | } | |
184 | ||
185 | pRow = pRow->mpNext; | |
186 | } | |
187 | ||
188 | if ( !focusFound ) | |
189 | { | |
190 | int hrCnt = GetHRowsCountForPane( event.mpPane ); | |
191 | ||
192 | for( int i = 0; i != hrCnt; ++i ) | |
193 | { | |
194 | if ( HitTestCollapsedRowIcon( i, pos ) ) | |
195 | { | |
196 | CheckPrevItemInFocus( NULL, i ); | |
197 | SetMouseCapture( TRUE ); | |
198 | ||
199 | focusFound = TRUE; | |
200 | ||
201 | mCollapsedIconInFocus = i; | |
202 | mpRowInFocus = NULL; | |
203 | break; | |
204 | } | |
205 | } | |
206 | } | |
207 | ||
208 | if ( !focusFound && ItemIsInFocus() ) | |
209 | { | |
210 | // kill focus from item previously been in focus | |
211 | UnhiglightItemInFocus(); | |
212 | ||
213 | mpRowInFocus = NULL; | |
214 | mCollapsedIconInFocus = -1; | |
215 | SetMouseCapture( FALSE ); | |
216 | } | |
217 | ||
218 | if ( !ItemIsInFocus() ) | |
219 | ||
220 | // delegate it to other plugins | |
221 | event.Skip(); | |
222 | } | |
223 | else | |
224 | { | |
225 | // otherwise mouse pointer moves, when dragging is started | |
226 | ||
227 | if ( mpPane->IsHorizontal() ) | |
228 | { | |
229 | // DBG:: | |
230 | wxPoint p = event.mPos; | |
231 | wxPoint d = mDragOrigin; | |
232 | int dif = event.mPos.x - mDragOrigin.x; | |
233 | ||
234 | // row is dragged up or down; | |
235 | ShowDraggedRow( pos.y - mDragOrigin.y ); | |
236 | } | |
237 | else | |
238 | { | |
239 | // DBG:: | |
240 | wxPoint p = event.mPos; | |
241 | wxPoint d = mDragOrigin; | |
242 | int dif = event.mPos.x - mDragOrigin.x; | |
243 | ||
244 | // row is dragged left or right | |
245 | ShowDraggedRow( pos.x - mDragOrigin.x ); | |
246 | } | |
247 | ||
248 | // this plugin "eats" all mouse input while item is dragged, | |
249 | } | |
250 | } | |
251 | ||
252 | void cbRowDragPlugin::OnLButtonDown( cbLeftDownEvent& event ) | |
253 | { | |
254 | mpPane = event.mpPane; | |
255 | ||
256 | // DBG:: | |
257 | wxASSERT( !mDragStarted && !mDecisionMode ); | |
258 | ||
259 | if ( ItemIsInFocus() ) | |
260 | { | |
261 | mDecisionMode = TRUE; | |
262 | ||
263 | wxPoint pos = event.mPos; | |
264 | mpPane->PaneToFrame( &pos.x, &pos.y ); | |
265 | ||
266 | mDragOrigin = pos; | |
267 | ||
268 | SetMouseCapture( TRUE ); | |
269 | } | |
270 | else | |
271 | // propagate event to other plugins | |
272 | event.Skip(); | |
273 | } | |
274 | ||
275 | void cbRowDragPlugin::OnLButtonUp ( cbLeftUpEvent& event ) | |
276 | { | |
277 | if ( !mDragStarted && !mDecisionMode ) | |
278 | { | |
279 | event.Skip(); | |
280 | return; | |
281 | } | |
282 | ||
283 | mpPane = event.mpPane; | |
284 | ||
285 | if ( mDecisionMode ) | |
286 | { | |
287 | cbDockPane* pPane = mpPane; | |
288 | ||
289 | SetMouseCapture( FALSE ); | |
290 | ||
291 | mDecisionMode = FALSE; | |
292 | mDragStarted = FALSE; | |
293 | ||
294 | wxPoint frmPos = event.mPos; | |
295 | pPane->PaneToFrame( &frmPos.x, &frmPos.y ); | |
296 | ||
297 | if ( mpRowInFocus ) | |
298 | { | |
299 | CollapseRow( mpRowInFocus ); | |
300 | mpRowInFocus = 0; | |
301 | } | |
302 | else | |
303 | { | |
304 | ExpandRow( mCollapsedIconInFocus ); | |
305 | mCollapsedIconInFocus = -1; | |
306 | } | |
307 | ||
308 | mpRowInFocus = NULL; | |
309 | mpPane = pPane; | |
310 | ||
311 | pPane->FrameToPane( &frmPos.x, &frmPos.y ); | |
312 | ||
313 | // give it another try after relayouting bars | |
314 | ||
315 | cbMotionEvent moveEvt( frmPos, pPane ); | |
316 | this->OnMouseMove( moveEvt ); | |
317 | ||
318 | // this plugin has "eaten" the mouse-up event | |
319 | ||
320 | return; | |
321 | } | |
322 | else | |
323 | { | |
324 | // otherwise, the dragged row was dropped, determine | |
325 | // where to insert it | |
326 | ||
327 | // restore initial pane appearence | |
328 | ShowPaneImage(); | |
329 | FinishOnScreenDraw(); | |
330 | ||
331 | cbRowInfo* pRow = GetFirstRow(); | |
332 | ||
333 | mpLayout->GetUpdatesManager().OnStartChanges(); | |
334 | ||
335 | pRow->mUMgrData.SetDirty(TRUE); | |
336 | ||
337 | cbBarInfo* pBar = mpRowInFocus->mBars[0]; | |
338 | ||
339 | while ( pBar ) | |
340 | { | |
341 | pBar->mUMgrData.SetDirty(TRUE); | |
342 | ||
343 | if ( pBar->mpBarWnd ) | |
344 | { | |
345 | // do complete refresh | |
346 | pBar->mpBarWnd->Show(FALSE); | |
347 | pBar->mpBarWnd->Show(TRUE); | |
348 | } | |
349 | ||
350 | pBar = pBar->mpNext; | |
351 | } | |
352 | ||
353 | while( pRow ) | |
354 | { | |
355 | if ( mCurDragOfs < pRow->mRowY ) | |
356 | { | |
357 | InsertDraggedRowBefore( pRow ); | |
358 | break; | |
359 | } | |
360 | ||
361 | pRow = pRow->mpNext; | |
362 | } | |
363 | ||
364 | if ( pRow == NULL ) InsertDraggedRowBefore( NULL ); | |
365 | ||
366 | mpRowInFocus = NULL; | |
367 | ||
368 | mpLayout->RecalcLayout(FALSE); | |
369 | ||
370 | // finish change "transaction" | |
371 | mpLayout->GetUpdatesManager().OnFinishChanges(); | |
372 | mpLayout->GetUpdatesManager().UpdateNow(); | |
373 | ||
374 | // finish drag action | |
375 | SetMouseCapture( FALSE ); | |
376 | mDragStarted = FALSE; | |
377 | } | |
378 | } | |
379 | ||
380 | void cbRowDragPlugin::OnDrawPaneBackground ( cbDrawPaneDecorEvent& event ) | |
381 | { | |
382 | mpPane = event.mpPane; | |
383 | ||
384 | // FIXME:: this may harm operation of other plugins | |
385 | ||
386 | if ( GetNextHandler() && mpPane->GetRowList().GetCount() ) | |
387 | { | |
388 | // first, let other plugins add their decorations now | |
389 | ||
390 | GetNextHandler()->ProcessEvent( event ); | |
391 | event.Skip(FALSE); | |
392 | } | |
393 | ||
394 | wxClientDC dc( &mpLayout->GetParentFrame() ); | |
395 | ||
396 | dc.SetClippingRegion( mpPane->mBoundsInParent.x, | |
397 | mpPane->mBoundsInParent.y, | |
398 | mpPane->mBoundsInParent.width, | |
399 | mpPane->mBoundsInParent.height ); | |
400 | ||
401 | int cnt = GetHRowsCountForPane( event.mpPane ); | |
402 | ||
403 | if ( cnt > 0 ) | |
404 | ||
405 | DrawCollapsedRowsBorder( dc ); | |
406 | ||
407 | if ( mpPane->GetRowList().GetCount() ) | |
408 | ||
409 | DrawRowsDragHintsBorder( dc ); | |
410 | ||
411 | cbRowInfo* pRow = GetFirstRow(); | |
412 | ||
413 | while( pRow ) | |
414 | { | |
415 | DrawRowDragHint( pRow, dc, FALSE ); | |
416 | pRow = pRow->mpNext; | |
417 | } | |
418 | ||
419 | for( int i = 0; i != cnt; ++i ) | |
420 | ||
421 | DrawCollapsedRowIcon(i, dc, FALSE ); | |
422 | } | |
423 | ||
424 | int cbRowDragPlugin::GetHRowsCountForPane( cbDockPane* pPane ) | |
425 | { | |
426 | wxNode* pNode = mHiddenBars.First(); | |
427 | ||
428 | int maxIconNo = -1; | |
429 | ||
430 | while( pNode ) | |
431 | { | |
432 | cbHiddenBarInfo* pHBInfo = (cbHiddenBarInfo*)pNode->Data(); | |
433 | ||
434 | if ( pHBInfo->mAlignment == pPane->mAlignment ) | |
435 | ||
436 | maxIconNo = wxMax( maxIconNo, pHBInfo->mIconNo ); | |
437 | ||
438 | pNode = pNode->Next(); | |
439 | } | |
440 | ||
441 | return ( maxIconNo + 1 ); | |
442 | } | |
443 | ||
444 | int cbRowDragPlugin::GetCollapsedRowIconHeight() | |
445 | { | |
446 | return COLLAPSED_ICON_HEIGHT; | |
447 | } | |
448 | ||
449 | int cbRowDragPlugin::GetRowDragHintWidth() | |
450 | { | |
451 | return ROW_DRAG_HINT_WIDTH; | |
452 | } | |
453 | ||
454 | void cbRowDragPlugin::SetPaneMargins() | |
455 | { | |
456 | int hiddenRowsCnt = GetHRowsCountForPane( mpPane ); | |
457 | ||
458 | if ( mSvTopMargin == -1 ) | |
459 | { | |
460 | mSvTopMargin = mpPane->mTopMargin; | |
461 | mSvBottomMargin = mpPane->mBottomMargin; | |
462 | mSvLeftMargin = mpPane->mLeftMargin; | |
463 | mSvRightMargin = mpPane->mRightMargin; | |
464 | } | |
465 | ||
466 | if ( mpPane->IsHorizontal() ) | |
467 | { | |
468 | mpPane->mTopMargin = mSvTopMargin; | |
469 | mpPane->mBottomMargin = ( hiddenRowsCnt == 0 ) | |
470 | ? mSvBottomMargin | |
471 | : mSvBottomMargin + GetCollapsedRowIconHeight(); | |
472 | ||
473 | mpPane->mLeftMargin = mSvLeftMargin + GetRowDragHintWidth(); | |
474 | mpPane->mRightMargin = mSvRightMargin; | |
475 | } | |
476 | else | |
477 | { | |
478 | mpPane->mTopMargin = mSvTopMargin; | |
479 | mpPane->mBottomMargin = mSvBottomMargin + GetRowDragHintWidth(); | |
480 | ||
481 | mpPane->mLeftMargin = mSvLeftMargin; | |
482 | mpPane->mRightMargin = ( hiddenRowsCnt == 0 ) ? | |
483 | mSvRightMargin : mSvRightMargin + GetCollapsedRowIconHeight(); | |
484 | } | |
485 | } | |
486 | ||
487 | void cbRowDragPlugin::OnInitPlugin() | |
488 | { | |
489 | cbDockPane** panes = mpLayout->GetPanesArray(); | |
490 | ||
491 | for( int i = 0; i != MAX_PANES; ++i ) | |
492 | ||
493 | if ( panes[i]->MatchesMask( mPaneMask ) ) | |
494 | { | |
495 | mpPane = panes[i]; | |
496 | ||
497 | SetPaneMargins(); | |
498 | } | |
499 | } | |
500 | ||
501 | /*** helpers for drag&drop ***/ | |
502 | ||
503 | void cbRowDragPlugin::SetMouseCapture( bool captureOn ) | |
504 | { | |
505 | if ( mCaptureIsOn == captureOn ) return; | |
506 | ||
507 | if ( captureOn ) | |
508 | { | |
509 | mpLayout->CaptureEventsForPane( mpPane ); | |
510 | mpLayout->CaptureEventsForPlugin( this ); | |
511 | } | |
512 | else | |
513 | { | |
514 | mpLayout->ReleaseEventsFromPane( mpPane ); | |
515 | mpLayout->ReleaseEventsFromPlugin( this ); | |
516 | } | |
517 | ||
518 | mCaptureIsOn = captureOn; | |
519 | } | |
520 | ||
521 | void cbRowDragPlugin::UnhiglightItemInFocus() | |
522 | { | |
523 | wxClientDC dc( &mpLayout->GetParentFrame() ); | |
524 | ||
525 | if ( mpRowInFocus ) | |
526 | ||
527 | DrawRowDragHint( mpRowInFocus, dc, FALSE ); | |
528 | else | |
529 | if ( mCollapsedIconInFocus != - 1 ) | |
530 | ||
531 | DrawCollapsedRowIcon( mCollapsedIconInFocus, dc, FALSE ); | |
532 | } | |
533 | ||
534 | void cbRowDragPlugin::ShowDraggedRow( int offset ) | |
535 | { | |
536 | // create combined image of pane and dragged | |
537 | // row on it, in the mpCombinedImage bitmap | |
538 | ||
539 | if ( mpPane->IsHorizontal() ) | |
540 | { | |
541 | if ( mInitialRowOfs + offset + mRowImgDim.y > mCombRect.y + mCombRect.height ) | |
542 | ||
543 | offset = mCombRect.y + mCombRect.height - mRowImgDim.y - mInitialRowOfs; | |
544 | ||
545 | if ( mInitialRowOfs + offset < mCombRect.y ) | |
546 | ||
547 | offset = mCombRect.y - mInitialRowOfs; | |
548 | ||
549 | int x, y = mInitialRowOfs + offset; | |
550 | mpPane->FrameToPane( &x, &y ); | |
551 | mCurDragOfs = y; | |
552 | } | |
553 | else | |
554 | { | |
555 | if ( mInitialRowOfs + offset + mRowImgDim.x > mCombRect.x + mCombRect.width ) | |
556 | ||
557 | offset = mCombRect.x + mCombRect.width - mRowImgDim.x - mInitialRowOfs; | |
558 | ||
559 | if ( mInitialRowOfs + offset < mCombRect.x ) | |
560 | ||
561 | offset = mCombRect.x - mInitialRowOfs; | |
562 | ||
563 | int x = mInitialRowOfs + offset, y; | |
564 | mpPane->FrameToPane( &x, &y ); | |
565 | mCurDragOfs = x; | |
566 | } | |
567 | ||
568 | wxMemoryDC rowImgDc; | |
569 | rowImgDc.SelectObject ( *mpRowImage ); | |
570 | ||
571 | wxMemoryDC paneImgDc; | |
572 | paneImgDc.SelectObject( *mpPaneImage ); | |
573 | ||
574 | wxMemoryDC combImgDc; | |
575 | combImgDc.SelectObject( *mpCombinedImage ); | |
576 | ||
577 | combImgDc.Blit( 0,0, mCombRect.width, mCombRect.height, | |
578 | &paneImgDc, 0,0, wxCOPY ); | |
579 | ||
580 | if ( mpPane->IsHorizontal() ) | |
581 | { | |
582 | combImgDc.Blit( 0, mInitialRowOfs + offset - mCombRect.y, | |
583 | mCombRect.width, mRowImgDim.y, | |
584 | &rowImgDc, 0,0, wxCOPY ); | |
585 | } | |
586 | else | |
587 | { | |
588 | combImgDc.Blit( mInitialRowOfs + offset - mCombRect.x, | |
589 | 0, | |
590 | mRowImgDim.x, mCombRect.height, | |
591 | &rowImgDc, 0,0, wxCOPY ); | |
592 | } | |
593 | ||
594 | int scrX = mCombRect.x, | |
595 | scrY = mCombRect.y; | |
596 | ||
597 | mpLayout->GetParentFrame().ClientToScreen( &scrX, &scrY ); | |
598 | ||
599 | mpScrDc->Blit( scrX, scrY, mCombRect.width, mCombRect.height, | |
600 | &combImgDc, 0,0, wxCOPY ); | |
601 | ||
602 | rowImgDc .SelectObject( wxNullBitmap ); | |
603 | paneImgDc.SelectObject( wxNullBitmap ); | |
604 | combImgDc.SelectObject( wxNullBitmap ); | |
605 | } | |
606 | ||
607 | wxBitmap* cbRowDragPlugin::CaptureDCArea( wxDC& dc, wxRect& area ) | |
608 | { | |
609 | wxBitmap* pBmp = new wxBitmap( int(area.width), int(area.height) ); | |
610 | ||
611 | wxMemoryDC mdc; | |
612 | mdc.SelectObject( *pBmp ); | |
613 | ||
614 | mdc.Blit( 0,0, area.width, area.height, &dc, area.x, area.y, wxCOPY ); | |
615 | mdc.SelectObject( wxNullBitmap ); | |
616 | ||
617 | return pBmp; | |
618 | } | |
619 | ||
620 | void cbRowDragPlugin::PrepareForRowDrag() | |
621 | { | |
622 | wxRect rowBounds = mpRowInFocus->mBoundsInParent; | |
623 | ||
624 | if ( mpPane->IsHorizontal() ) | |
625 | { | |
626 | mCombRect = mpPane->mBoundsInParent; | |
627 | ||
628 | mCombRect.x += mpPane->mLeftMargin - ROW_DRAG_HINT_WIDTH - 1; | |
629 | mCombRect.y += mpPane->mTopMargin; | |
630 | ||
631 | mCombRect.width -= mpPane->mLeftMargin + mpPane->mRightMargin - ROW_DRAG_HINT_WIDTH - 1 - 1; | |
632 | mCombRect.height -= mpPane->mTopMargin + mpPane->mBottomMargin; | |
633 | ||
634 | mCombRect.height += 2*rowBounds.height; | |
635 | mCombRect.y -= rowBounds.height; | |
636 | mInitialRowOfs = rowBounds.y; | |
637 | ||
638 | rowBounds.y -= 1; | |
639 | rowBounds.height += 2; | |
640 | rowBounds.x = mCombRect.x; | |
641 | rowBounds.width = mCombRect.width; | |
642 | ||
643 | mRowImgDim.y = rowBounds.height; | |
644 | } | |
645 | else | |
646 | { | |
647 | mCombRect = mpPane->mBoundsInParent; | |
648 | ||
649 | mCombRect.y += mpPane->mTopMargin - 1; | |
650 | mCombRect.x += mpPane->mLeftMargin - 1; | |
651 | ; | |
652 | mCombRect.height -= mpPane->mTopMargin + mpPane->mBottomMargin - ROW_DRAG_HINT_WIDTH - 1 - 1; | |
653 | mCombRect.width -= mpPane->mLeftMargin + mpPane->mRightMargin; | |
654 | ||
655 | mCombRect.width += 2*rowBounds.width; | |
656 | mCombRect.x -= rowBounds.width; | |
657 | mInitialRowOfs = rowBounds.x; | |
658 | ||
659 | rowBounds.x -= 1; | |
660 | rowBounds.width += 2; | |
661 | rowBounds.y = mCombRect.y; | |
662 | rowBounds.height = mCombRect.height; | |
663 | ||
664 | mRowImgDim.x = rowBounds.width; | |
665 | } | |
666 | // output cobination results onto frame's client area | |
667 | wxScreenDC::StartDrawingOnTop(&mpLayout->GetParentFrame()); | |
668 | mpScrDc = new wxScreenDC(); | |
669 | ||
670 | int x = mCombRect.x, y = mCombRect.y; | |
671 | mpLayout->GetParentFrame().ClientToScreen( &x, &y ); | |
672 | ||
673 | wxRect scrRect = mCombRect; | |
674 | scrRect.x = x; | |
675 | scrRect.y = y; | |
676 | ||
677 | mpPaneImage = CaptureDCArea( *mpScrDc, scrRect ); | |
678 | ||
679 | wxMemoryDC mdc; | |
680 | mdc.SelectObject( *mpPaneImage ); | |
681 | mdc.SetDeviceOrigin( -mCombRect.x, -mCombRect.y ); | |
682 | ||
683 | DrawRectShade( rowBounds, mdc, -1, mpLayout->mGrayPen, mpLayout->mDarkPen ); | |
684 | DrawRectShade( rowBounds, mdc, 0, mpLayout->mLightPen, mpLayout->mBlackPen ); | |
685 | ||
686 | mpRowImage = CaptureDCArea( mdc, rowBounds ); | |
687 | ||
688 | // draw dark empty-row placeholder | |
689 | DrawEmptyRow( mdc, rowBounds ); | |
690 | ||
691 | //DrawRectShade( rowBounds, mdc, 0, mpLayout->mGrayPen, mpLayout->mDarkPen ); | |
692 | DrawRectShade( rowBounds, mdc, -1, mpLayout->mGrayPen, mpLayout->mGrayPen ); | |
693 | ||
694 | mdc.SelectObject( wxNullBitmap ); | |
695 | ||
696 | mpCombinedImage = new wxBitmap( int(mCombRect.width), int(mCombRect.height) ); | |
697 | ||
698 | // show it for the first time | |
699 | ShowDraggedRow( 0 ); | |
700 | } | |
701 | ||
702 | void cbRowDragPlugin::DrawEmptyRow( wxDC& dc, wxRect& rowBounds ) | |
703 | { | |
704 | wxBrush bkBrush( mpLayout->mDarkPen.GetColour(), wxSOLID ); | |
705 | ||
706 | // paint the "dark" empty-row placeholder | |
707 | ||
708 | dc.SetBrush( bkBrush ); | |
709 | dc.SetPen ( mpLayout->mNullPen ); | |
710 | ||
711 | dc.DrawRectangle( rowBounds.x, rowBounds.y, | |
712 | rowBounds.width+1, rowBounds.height+1 ); | |
713 | ||
714 | dc.SetBrush( wxNullBrush ); | |
715 | } | |
716 | ||
717 | void cbRowDragPlugin::ShowPaneImage() | |
718 | { | |
719 | int scrX = 0, scrY = 0; | |
720 | ||
721 | mpLayout->GetParentFrame().ClientToScreen( &scrX, &scrY ); | |
722 | ||
723 | wxMemoryDC mdc; | |
724 | mdc.SelectObject( *mpPaneImage ); | |
725 | ||
726 | mpScrDc->Blit( mCombRect.x + scrX, mCombRect.y + scrY, | |
727 | mCombRect.width, mCombRect.height, | |
728 | &mdc, 0,0, wxCOPY ); | |
729 | ||
730 | mdc.SelectObject( wxNullBitmap ); | |
731 | } | |
732 | ||
733 | void cbRowDragPlugin::FinishOnScreenDraw() | |
734 | { | |
735 | wxScreenDC::EndDrawingOnTop(); | |
736 | ||
737 | delete mpScrDc; | |
738 | delete mpCombinedImage; | |
739 | delete mpPaneImage; | |
740 | delete mpRowImage; | |
741 | ||
742 | mpScrDc = NULL; | |
743 | ||
744 | mpCombinedImage = mpPaneImage = mpRowImage = NULL; | |
745 | } | |
746 | ||
747 | void cbRowDragPlugin::CollapseRow( cbRowInfo* pRow ) | |
748 | { | |
749 | int iconCnt = GetHRowsCountForPane( mpPane ); | |
750 | ||
751 | mpLayout->GetUpdatesManager().OnStartChanges(); | |
752 | ||
753 | cbBarInfo* pBar = pRow->mBars[0]; | |
754 | ||
755 | int rowNo = 0; | |
756 | ||
757 | cbRowInfo* pCur = pRow; | |
758 | while( pCur->mpPrev ) { ++rowNo; pCur = pCur->mpPrev; } | |
759 | ||
760 | while( pBar ) | |
761 | { | |
762 | cbHiddenBarInfo* pHBInfo = new cbHiddenBarInfo(); | |
763 | ||
764 | pHBInfo->mpBar = pBar; | |
765 | pHBInfo->mRowNo = rowNo; | |
766 | pHBInfo->mIconNo = iconCnt; | |
767 | pHBInfo->mAlignment = mpPane->mAlignment; | |
768 | ||
769 | mHiddenBars.Append( (wxObject*) pHBInfo ); | |
770 | ||
771 | // hide it | |
772 | if ( pBar->mpBarWnd ) | |
773 | ||
774 | pBar->mpBarWnd->Show( FALSE ); | |
775 | ||
776 | pBar->mState = wxCBAR_HIDDEN; | |
777 | ||
778 | cbBarInfo* pNext = pBar->mpNext; | |
779 | ||
780 | pBar->mpRow = NULL; | |
781 | pBar->mpNext = NULL; | |
782 | pBar->mpPrev = NULL; | |
783 | ||
784 | pBar = pNext; | |
785 | } | |
786 | ||
787 | mpPane->GetRowList().Remove( pRow ); | |
788 | mpPane->InitLinksForRows(); | |
789 | ||
790 | delete pRow; | |
791 | ||
792 | SetPaneMargins(); | |
793 | ||
794 | mpLayout->RecalcLayout(FALSE); | |
795 | ||
796 | mpRowInFocus = NULL; | |
797 | ||
798 | mpLayout->GetUpdatesManager().OnFinishChanges(); | |
799 | mpLayout->GetUpdatesManager().UpdateNow(); | |
800 | } | |
801 | ||
802 | void cbRowDragPlugin::ExpandRow( int collapsedIconIdx ) | |
803 | { | |
804 | mpLayout->GetUpdatesManager().OnStartChanges(); | |
805 | ||
806 | cbRowInfo* pNewRow = new cbRowInfo(); | |
807 | ||
808 | wxNode* pNode = mHiddenBars.First(); | |
809 | ||
810 | int rowNo = 0; | |
811 | ||
812 | // move bars from internal list to the newly expanded row | |
813 | ||
814 | while( pNode ) | |
815 | { | |
816 | cbHiddenBarInfo* pHBInfo = (cbHiddenBarInfo*)pNode->Data(); | |
817 | ||
818 | if ( pHBInfo->mAlignment == mpPane->mAlignment && | |
819 | pHBInfo->mIconNo == collapsedIconIdx ) | |
820 | { | |
821 | rowNo = pHBInfo->mRowNo; | |
822 | ||
823 | if ( pHBInfo->mpBar->mState == wxCBAR_HIDDEN ) | |
824 | { | |
825 | pNewRow->mBars.Add( pHBInfo->mpBar ); | |
826 | ||
827 | pHBInfo->mpBar->mState = ( mpPane->IsHorizontal() ) | |
828 | ? wxCBAR_DOCKED_HORIZONTALLY | |
829 | : wxCBAR_DOCKED_VERTICALLY; | |
830 | } | |
831 | ||
832 | // remove bar info from internal list | |
833 | ||
834 | wxNode* pNext = pNode->Next(); | |
835 | ||
836 | delete pHBInfo; | |
837 | mHiddenBars.DeleteNode( pNode ); | |
838 | ||
839 | pNode = pNext; | |
840 | } | |
841 | else | |
842 | { | |
843 | // decrease incon numbers with higher indicies, since this | |
844 | // row is now removed from the hidden-rows list | |
845 | ||
846 | if ( pHBInfo->mIconNo > collapsedIconIdx && | |
847 | pHBInfo->mAlignment == mpPane->mAlignment ) | |
848 | ||
849 | --pHBInfo->mIconNo; | |
850 | ||
851 | pNode = pNode->Next(); | |
852 | } | |
853 | } | |
854 | ||
855 | mpPane->InitLinksForRow( pNewRow ); | |
856 | ||
857 | // insert row into pane at it's original position | |
858 | ||
859 | if ( pNewRow->mBars.GetCount() ) | |
860 | { | |
861 | cbRowInfo* beforeRowNode = mpPane->GetRow( rowNo ); | |
862 | ||
863 | mpPane->InsertRow( pNewRow, beforeRowNode ); | |
864 | } | |
865 | else | |
866 | delete pNewRow; | |
867 | ||
868 | SetPaneMargins(); | |
869 | ||
870 | mpLayout->RecalcLayout(FALSE); | |
871 | ||
872 | mCollapsedIconInFocus = -1; | |
873 | ||
874 | mpLayout->GetUpdatesManager().OnFinishChanges(); | |
875 | mpLayout->GetUpdatesManager().UpdateNow(); | |
876 | ||
877 | ||
878 | /* | |
879 | wxNode* pRowNode = mHiddenRows.Nth( collapsedIconIdx ); | |
880 | ||
881 | mpLayout->GetUpdatesManager().OnStartChanges(); | |
882 | ||
883 | // insert at the end of rows list | |
884 | mpPane->InsertRow( pRowNode, NULL ); | |
885 | ||
886 | int success = mHiddenRows.DeleteNode( pRowNode ); | |
887 | // DBG:: | |
888 | wxASSERT( success ); | |
889 | ||
890 | SetPaneMargins(); | |
891 | ||
892 | mpLayout->RecalcLayout(FALSE); | |
893 | ||
894 | mCollapsedIconInFocus = -1; | |
895 | ||
896 | mpLayout->GetUpdatesManager().OnFinishChanges(); | |
897 | mpLayout->GetUpdatesManager().UpdateNow(); | |
898 | */ | |
899 | } | |
900 | ||
901 | void cbRowDragPlugin::InsertDraggedRowBefore( cbRowInfo* pBeforeRow ) | |
902 | { | |
903 | if ( mpRowInFocus != pBeforeRow && | |
904 | mpRowInFocus->mpNext != pBeforeRow | |
905 | ) | |
906 | { | |
907 | mpPane->GetRowList().Remove( mpRowInFocus ); | |
908 | ||
909 | mpPane->InsertRow( mpRowInFocus, pBeforeRow ); | |
910 | } | |
911 | else | |
912 | { | |
913 | // otherwise, nothing has happned (row positions do not change) | |
914 | ||
915 | //wxClientDC dc( &mpLayout->GetParentFrame() ); | |
916 | ||
917 | //mpPane->PaintRow( mpRowInFocus, dc ); | |
918 | //DrawRowDragHint( mpRowInFocus, dc, FALSE ); | |
919 | } | |
920 | } | |
921 | ||
922 | bool cbRowDragPlugin::ItemIsInFocus() | |
923 | { | |
924 | return ( mpRowInFocus || mCollapsedIconInFocus != - 1 ); | |
925 | } | |
926 | ||
927 | void cbRowDragPlugin::CheckPrevItemInFocus( cbRowInfo* pRow, int iconIdx ) | |
928 | { | |
929 | wxClientDC dc( &mpLayout->GetParentFrame() ); | |
930 | ||
931 | if ( pRow != NULL && mpRowInFocus == pRow ) return; | |
932 | if ( iconIdx != -1 && mCollapsedIconInFocus == iconIdx ) return; | |
933 | ||
934 | UnhiglightItemInFocus(); | |
935 | ||
936 | if ( iconIdx != - 1 ) | |
937 | ||
938 | DrawCollapsedRowIcon( iconIdx, dc, TRUE ); | |
939 | ||
940 | else | |
941 | if ( pRow != NULL ) | |
942 | ||
943 | DrawRowDragHint( pRow, dc, TRUE ); | |
944 | } | |
945 | ||
946 | cbRowInfo* cbRowDragPlugin::GetFirstRow() | |
947 | { | |
948 | return ( mpPane->GetRowList().GetCount() ) | |
949 | ? mpPane->GetRowList()[0] | |
950 | : NULL; | |
951 | } | |
952 | ||
953 | /*** "hard-coded" metafile for NN-look ***/ | |
954 | ||
955 | void cbRowDragPlugin::DrawTrianUp( wxRect& inRect, wxDC& dc ) | |
956 | { | |
957 | int xOfs = (inRect.width - ICON_TRIAN_WIDTH)/2; | |
958 | ||
959 | wxBrush br( mTrianInnerColor, wxSOLID ); | |
960 | ||
961 | dc.SetBrush( br ); | |
962 | dc.SetPen( mpLayout->mBlackPen ); | |
963 | ||
964 | wxPoint points[3]; | |
965 | points[0].x = inRect.x + xOfs; | |
966 | points[0].y = inRect.y + inRect.height - 1; | |
967 | points[1].x = inRect.x + xOfs + ICON_TRIAN_WIDTH/2 + 1; | |
968 | points[1].y = inRect.y + inRect.height - 2 - ICON_TRIAN_HEIGHT; | |
969 | points[2].x = inRect.x + xOfs + ICON_TRIAN_WIDTH+1; | |
970 | points[2].y = inRect.y + inRect.height - 1; | |
971 | ||
972 | dc.DrawPolygon( 3, points ); | |
973 | ||
974 | // higlight upper-right edge of triangle | |
975 | dc.SetPen( mpLayout->mLightPen ); | |
976 | dc.DrawLine( points[2].x, points[2].y, | |
977 | points[0].x, points[0].y ); | |
978 | ||
979 | dc.SetBrush( wxNullBrush ); | |
980 | } | |
981 | ||
982 | void cbRowDragPlugin::DrawTrianDown( wxRect& inRect, wxDC& dc ) | |
983 | { | |
984 | int xOfs = (inRect.width - ICON_TRIAN_WIDTH)/2; | |
985 | ||
986 | wxBrush br( mTrianInnerColor, wxSOLID ); | |
987 | ||
988 | dc.SetBrush( br ); | |
989 | dc.SetPen( mpLayout->mBlackPen ); | |
990 | ||
991 | wxPoint points[3]; | |
992 | points[0].x = inRect.x + xOfs; | |
993 | points[0].y = inRect.y; | |
994 | points[1].x = inRect.x + xOfs + ICON_TRIAN_WIDTH; | |
995 | points[1].y = inRect.y; | |
996 | points[2].x = inRect.x + xOfs + ICON_TRIAN_WIDTH/2; | |
997 | points[2].y = inRect.y + ICON_TRIAN_HEIGHT; | |
998 | ||
999 | dc.DrawPolygon( 3, points ); | |
1000 | ||
1001 | // higlight upper-right edge of triangle | |
1002 | dc.SetPen( mpLayout->mLightPen ); | |
1003 | dc.DrawLine( points[2].x, points[2].y, | |
1004 | points[1].x, points[1].y ); | |
1005 | ||
1006 | dc.SetBrush( wxNullBrush ); | |
1007 | } | |
1008 | ||
1009 | void cbRowDragPlugin::DrawTrianRight( wxRect& inRect, wxDC& dc ) | |
1010 | { | |
1011 | int yOfs = (inRect.height - ICON_TRIAN_WIDTH)/2; | |
1012 | ||
1013 | wxBrush br( mTrianInnerColor, wxSOLID ); | |
1014 | ||
1015 | dc.SetBrush( br ); | |
1016 | dc.SetPen( mpLayout->mBlackPen ); | |
1017 | ||
1018 | wxPoint points[3]; | |
1019 | points[0].x = inRect.x; | |
1020 | points[0].y = inRect.y + yOfs + ICON_TRIAN_WIDTH; | |
1021 | points[1].x = inRect.x; | |
1022 | points[1].y = inRect.y + yOfs; | |
1023 | points[2].x = inRect.x + ICON_TRIAN_HEIGHT; | |
1024 | points[2].y = inRect.y + yOfs + ICON_TRIAN_WIDTH/2; | |
1025 | ||
1026 | dc.DrawPolygon( 3, points ); | |
1027 | ||
1028 | // higlight upper-right edge of triangle | |
1029 | dc.SetPen( mpLayout->mLightPen ); | |
1030 | dc.DrawLine( points[0].x, points[0].y, | |
1031 | points[2].x, points[2].y ); | |
1032 | ||
1033 | dc.SetBrush( wxNullBrush ); | |
1034 | } | |
1035 | ||
1036 | void cbRowDragPlugin::Draw3DPattern( wxRect& inRect, wxDC& dc ) | |
1037 | { | |
1038 | for( int y = inRect.y; y < inRect.y + inRect.height; y+=3 ) | |
1039 | ||
1040 | for( int x = inRect.x; x < inRect.x + inRect.width; x+=3 ) | |
1041 | { | |
1042 | dc.SetPen( mpLayout->mLightPen ); | |
1043 | dc.DrawPoint( x,y ); | |
1044 | dc.SetPen( mpLayout->mBlackPen ); | |
1045 | dc.DrawPoint( x+1, y+1 ); | |
1046 | } | |
1047 | } | |
1048 | ||
1049 | void cbRowDragPlugin::DrawRombShades( wxPoint& p1, wxPoint& p2, | |
1050 | wxPoint& p3, wxPoint& p4, | |
1051 | wxDC& dc ) | |
1052 | { | |
1053 | dc.SetPen( mpLayout->mLightPen ); | |
1054 | dc.DrawLine( p1.x, p1.y, p2.x, p2.y ); | |
1055 | dc.DrawLine( p2.x, p2.y, p3.x, p3.y ); | |
1056 | dc.SetPen( mpLayout->mDarkPen ); | |
1057 | dc.DrawLine( p3.x, p3.y, p4.x, p4.y ); | |
1058 | dc.DrawLine( p4.x, p4.y, p1.x, p1.y ); | |
1059 | } | |
1060 | ||
1061 | void cbRowDragPlugin::DrawOrtoRomb( wxRect& inRect, wxDC& dc, wxBrush& bkBrush ) | |
1062 | { | |
1063 | dc.SetBrush( bkBrush ); | |
1064 | dc.SetPen( mpLayout->mBlackPen ); | |
1065 | ||
1066 | wxPoint points[4]; | |
1067 | ||
1068 | if ( inRect.width > inRect.height ) | |
1069 | { | |
1070 | // horizontal orienation | |
1071 | points[0].x = inRect.x; | |
1072 | points[0].y = inRect.y + inRect.height; | |
1073 | points[1].x = inRect.x; | |
1074 | points[1].y = inRect.y; | |
1075 | points[2].x = inRect.x + inRect.width; | |
1076 | points[2].y = inRect.y; | |
1077 | points[3].x = inRect.x + inRect.width - COLLAPSED_ICON_HEIGHT; | |
1078 | points[3].y = inRect.y + inRect.height; | |
1079 | ||
1080 | dc.DrawPolygon( 4, points ); | |
1081 | ||
1082 | // squeeze romb's bounds to create an inner-shade shape | |
1083 | ++points[0].x; | |
1084 | --points[0].y; | |
1085 | ++points[1].x; | |
1086 | ++points[1].y; | |
1087 | --points[2].x; --points[2].x; | |
1088 | ++points[2].y; | |
1089 | --points[3].y; | |
1090 | ||
1091 | DrawRombShades( points[0], points[1], points[2], points[3], dc ); | |
1092 | } | |
1093 | else | |
1094 | { | |
1095 | // vertical orientation | |
1096 | points[0].x = inRect.x + inRect.width; | |
1097 | points[0].y = inRect.y + inRect.height; | |
1098 | points[1].x = inRect.x; | |
1099 | points[1].y = inRect.y + inRect.height; | |
1100 | points[2].x = inRect.x; | |
1101 | points[2].y = inRect.y; | |
1102 | points[3].x = inRect.x + inRect.width; | |
1103 | points[3].y = inRect.y + COLLAPSED_ICON_HEIGHT; | |
1104 | ||
1105 | dc.DrawPolygon( 4, points ); | |
1106 | ||
1107 | // squeeze romb's bounds to create an inner-shade shape | |
1108 | --points[0].y ; | |
1109 | --points[0].x; | |
1110 | ++points[1].x; | |
1111 | --points[1].y; | |
1112 | ++points[2].y; ++points[2].y; | |
1113 | ++points[2].x; | |
1114 | --points[3].x; | |
1115 | ||
1116 | DrawRombShades( points[1], points[2], points[3], points[0], dc ); | |
1117 | } | |
1118 | ||
1119 | dc.SetBrush( wxNullBrush ); | |
1120 | } | |
1121 | ||
1122 | void cbRowDragPlugin::DrawRomb( wxRect& inRect, wxDC& dc, wxBrush& bkBrush ) | |
1123 | { | |
1124 | wxPoint points[4]; | |
1125 | ||
1126 | dc.SetBrush( bkBrush ); | |
1127 | dc.SetPen( mpLayout->mBlackPen ); | |
1128 | ||
1129 | if ( inRect.width > inRect.height ) | |
1130 | { | |
1131 | // horizontal orientation | |
1132 | points[0].x = inRect.x; | |
1133 | points[0].y = inRect.y + inRect.height; | |
1134 | points[1].x = inRect.x + COLLAPSED_ICON_HEIGHT; | |
1135 | points[1].y = inRect.y; | |
1136 | points[2].x = inRect.x + inRect.width; | |
1137 | points[2].y = inRect.y; | |
1138 | points[3].x = inRect.x + inRect.width - COLLAPSED_ICON_HEIGHT; | |
1139 | points[3].y = inRect.y + inRect.height; | |
1140 | ||
1141 | dc.DrawPolygon( 4, points ); | |
1142 | ||
1143 | // squeeze romb's bounds to create an inner-shade shape | |
1144 | ++points[0].x ;++points[0].x ; | |
1145 | --points[0].y; | |
1146 | ++points[1].y; | |
1147 | --points[2].x; --points[2].x; | |
1148 | ++points[2].y; | |
1149 | //--points[3].x ; | |
1150 | --points[3].y; | |
1151 | ||
1152 | DrawRombShades( points[0], points[1], points[2], points[3], dc ); | |
1153 | ||
1154 | } | |
1155 | else | |
1156 | { | |
1157 | // vertical orientation | |
1158 | points[0].x = inRect.x + inRect.width; | |
1159 | points[0].y = inRect.y + inRect.height; | |
1160 | points[1].x = inRect.x; | |
1161 | points[1].y = inRect.y + inRect.height - COLLAPSED_ICON_HEIGHT; | |
1162 | points[2].x = inRect.x; | |
1163 | points[2].y = inRect.y; | |
1164 | points[3].x = inRect.x + inRect.width; | |
1165 | points[3].y = inRect.y + COLLAPSED_ICON_HEIGHT; | |
1166 | ||
1167 | dc.DrawPolygon( 4, points ); | |
1168 | ||
1169 | // squeeze romb's bounds to create an inner-shade shape | |
1170 | --points[0].y ;--points[0].y ; | |
1171 | --points[0].x; | |
1172 | ++points[1].x; | |
1173 | ++points[2].y; ++points[2].y; | |
1174 | ++points[2].x; | |
1175 | --points[3].x; | |
1176 | ||
1177 | DrawRombShades( points[1], points[2], points[3], points[0], dc ); | |
1178 | } | |
1179 | ||
1180 | dc.SetBrush( wxNullBrush ); | |
1181 | } | |
1182 | ||
1183 | void cbRowDragPlugin::DrawRectShade( wxRect& inRect, wxDC& dc, | |
1184 | int level, wxPen& upperPen, wxPen& lowerPen ) | |
1185 | { | |
1186 | // upper shade | |
1187 | dc.SetPen( upperPen ); | |
1188 | dc.DrawLine( inRect.x - level, | |
1189 | inRect.y - level, | |
1190 | inRect.x + inRect.width - 1 + level, | |
1191 | inRect.y - level); | |
1192 | dc.DrawLine( inRect.x - level, inRect.y - level, | |
1193 | inRect.x - level, inRect.y + inRect.height - 1 + level ); | |
1194 | ||
1195 | // lower shade | |
1196 | dc.SetPen( lowerPen ); | |
1197 | dc.DrawLine( inRect.x - level, | |
1198 | inRect.y + inRect.height - 1 + level, | |
1199 | inRect.x + inRect.width + level, | |
1200 | inRect.y + inRect.height - 1 + level); | |
1201 | dc.DrawLine( inRect.x + inRect.width - 1 + level, | |
1202 | inRect.y - level, | |
1203 | inRect.x + inRect.width - 1 + level, | |
1204 | inRect.y + inRect.height + level); | |
1205 | ||
1206 | dc.SetBrush( wxNullBrush ); | |
1207 | } | |
1208 | ||
1209 | void cbRowDragPlugin::Draw3DRect( wxRect& inRect, wxDC& dc, wxBrush& bkBrush ) | |
1210 | { | |
1211 | dc.SetPen( mpLayout->mNullPen ); | |
1212 | dc.SetBrush( bkBrush ); | |
1213 | ||
1214 | dc.DrawRectangle( inRect.x, inRect.y, | |
1215 | inRect.width, inRect.height ); | |
1216 | ||
1217 | DrawRectShade( inRect, dc, 0, mpLayout->mLightPen, mpLayout->mDarkPen ); | |
1218 | } | |
1219 | ||
1220 | int cbRowDragPlugin::GetCollapsedIconsPos() | |
1221 | { | |
1222 | RowArrayT& rows = mpPane->GetRowList(); | |
1223 | ||
1224 | if ( rows.GetCount() == 0 ) | |
1225 | { | |
1226 | if ( mpPane->IsHorizontal() ) | |
1227 | ||
1228 | return mpPane->mBoundsInParent.y + mpPane->mTopMargin; | |
1229 | else | |
1230 | return mpPane->mBoundsInParent.x + mpPane->mLeftMargin; | |
1231 | } | |
1232 | ||
1233 | wxRect& bounds = rows[ rows.GetCount() - 1 ]->mBoundsInParent; | |
1234 | ||
1235 | if ( mpPane->IsHorizontal() ) | |
1236 | ||
1237 | return bounds.y + bounds.height + 1; | |
1238 | else | |
1239 | return bounds.x + bounds.width + 1; | |
1240 | ||
1241 | } | |
1242 | ||
1243 | void cbRowDragPlugin::GetRowHintRect( cbRowInfo* pRow, wxRect& rect ) | |
1244 | { | |
1245 | wxRect& bounds = pRow->mBoundsInParent; | |
1246 | ||
1247 | if ( mpPane->IsHorizontal() ) | |
1248 | { | |
1249 | rect.x = bounds.x - ROW_DRAG_HINT_WIDTH - 1; | |
1250 | rect.y = bounds.y; | |
1251 | rect.width = ROW_DRAG_HINT_WIDTH; | |
1252 | rect.height = bounds.height; | |
1253 | } | |
1254 | else | |
1255 | { | |
1256 | rect.x = bounds.x; | |
1257 | rect.y = bounds.y + bounds.height + 1; | |
1258 | rect.width = bounds.width; | |
1259 | rect.height = ROW_DRAG_HINT_WIDTH; | |
1260 | } | |
1261 | } | |
1262 | ||
1263 | void cbRowDragPlugin::GetCollapsedInconRect( int iconIdx, wxRect& rect ) | |
1264 | { | |
1265 | int upper = GetCollapsedIconsPos(); | |
1266 | ||
1267 | int right = (iconIdx == 0 ) | |
1268 | ? 0 : iconIdx * (COLLAPSED_ICON_WIDTH - COLLAPSED_ICON_HEIGHT); | |
1269 | ||
1270 | if ( mpPane->IsHorizontal() ) | |
1271 | { | |
1272 | rect.x = mpPane->mBoundsInParent.x + mpPane->mLeftMargin - ROW_DRAG_HINT_WIDTH - 1 | |
1273 | + right; | |
1274 | ||
1275 | rect.y = upper; | |
1276 | rect.width = COLLAPSED_ICON_WIDTH; | |
1277 | rect.height = COLLAPSED_ICON_HEIGHT; | |
1278 | } | |
1279 | else | |
1280 | { | |
1281 | rect.x = upper; | |
1282 | rect.y = mpPane->mBoundsInParent.y + mpPane->mBoundsInParent.height | |
1283 | - mpPane->mBottomMargin + ROW_DRAG_HINT_WIDTH + 1 | |
1284 | - right - COLLAPSED_ICON_WIDTH; | |
1285 | ||
1286 | rect.height = COLLAPSED_ICON_WIDTH; | |
1287 | rect.width = COLLAPSED_ICON_HEIGHT; | |
1288 | } | |
1289 | } | |
1290 | ||
1291 | /*** overridables ***/ | |
1292 | ||
1293 | void cbRowDragPlugin::DrawCollapsedRowIcon( int index, wxDC& dc, bool isHighlighted ) | |
1294 | { | |
1295 | wxRect rect; | |
1296 | GetCollapsedInconRect( index, rect ); | |
1297 | ||
1298 | wxBrush hiBrush ( mHightColor, wxSOLID ); | |
1299 | wxBrush lowBrush( mLowColor, wxSOLID ); | |
1300 | wxBrush& curBrush = ( isHighlighted ) ? hiBrush : lowBrush; | |
1301 | ||
1302 | if ( mpPane->IsHorizontal() ) | |
1303 | { | |
1304 | if ( index == 0 ) | |
1305 | ||
1306 | DrawOrtoRomb( rect, dc, curBrush ); | |
1307 | else | |
1308 | DrawRomb( rect, dc, curBrush ); | |
1309 | ||
1310 | int triOfs = (index == 0) ? TRIANGLE_OFFSET : TRIANGLE_OFFSET + COLLAPSED_ICON_HEIGHT; | |
1311 | ||
1312 | wxRect triRect; | |
1313 | triRect.x = triOfs + rect.x; | |
1314 | ||
1315 | triRect.width = ICON_TRIAN_HEIGHT; | |
1316 | triRect.y = rect.y; | |
1317 | triRect.height = rect.height; | |
1318 | ||
1319 | DrawTrianRight( triRect, dc ); | |
1320 | ||
1321 | wxRect patRect; | |
1322 | patRect.x = triOfs + ICON_TRIAN_HEIGHT + TRIANGLE_TO_PAT_GAP + rect.x; | |
1323 | patRect.y = rect.y + PAT_OFFSET; | |
1324 | patRect.width = rect.width - (patRect.x - rect.x) - COLLAPSED_ICON_HEIGHT - PAT_OFFSET; | |
1325 | patRect.height = rect.height - PAT_OFFSET*2; | |
1326 | ||
1327 | Draw3DPattern( patRect, dc ); | |
1328 | } | |
1329 | else | |
1330 | { | |
1331 | if ( index == 0 ) | |
1332 | ||
1333 | DrawOrtoRomb( rect, dc, curBrush ); | |
1334 | else | |
1335 | DrawRomb( rect, dc, curBrush ); | |
1336 | ||
1337 | int triOfs = (index == 0) | |
1338 | ? TRIANGLE_OFFSET + ICON_TRIAN_HEIGHT | |
1339 | : TRIANGLE_OFFSET + COLLAPSED_ICON_HEIGHT + ICON_TRIAN_HEIGHT; | |
1340 | ||
1341 | wxRect triRect; | |
1342 | triRect.y = rect.y + rect.height - triOfs; | |
1343 | triRect.x = rect.x; | |
1344 | triRect.width = rect.width; | |
1345 | triRect.height = ICON_TRIAN_HEIGHT; | |
1346 | ||
1347 | DrawTrianUp( triRect, dc ); | |
1348 | ||
1349 | wxRect patRect; | |
1350 | patRect.y = rect.y + COLLAPSED_ICON_HEIGHT + PAT_OFFSET; | |
1351 | patRect.x = rect.x + PAT_OFFSET; | |
1352 | patRect.width = rect.width - 2*PAT_OFFSET ; | |
1353 | patRect.height = rect.height - triOfs - 2*PAT_OFFSET - COLLAPSED_ICON_HEIGHT; | |
1354 | ||
1355 | Draw3DPattern( patRect, dc ); | |
1356 | } | |
1357 | } | |
1358 | ||
1359 | void cbRowDragPlugin::DrawRowDragHint( cbRowInfo* pRow , wxDC& dc, bool isHighlighted ) | |
1360 | { | |
1361 | wxRect rect; | |
1362 | GetRowHintRect( pRow, rect ); | |
1363 | ||
1364 | wxBrush hiBrush ( mHightColor, wxSOLID ); | |
1365 | wxBrush lowBrush( mLowColor, wxSOLID ); | |
1366 | wxBrush& curBrush = ( isHighlighted ) ? hiBrush : lowBrush; | |
1367 | ||
1368 | Draw3DRect( rect, dc, curBrush ); | |
1369 | ||
1370 | if ( mpPane->IsHorizontal() ) | |
1371 | { | |
1372 | wxRect triRect; | |
1373 | triRect.y = rect.y + TRIANGLE_OFFSET; | |
1374 | triRect.x = rect.x; | |
1375 | triRect.width = rect.width; | |
1376 | triRect.height = ICON_TRIAN_HEIGHT; | |
1377 | ||
1378 | DrawTrianDown( triRect, dc ); | |
1379 | ||
1380 | wxRect patRect; | |
1381 | patRect.x = rect.x + PAT_OFFSET; | |
1382 | patRect.y = rect.y + TRIANGLE_OFFSET + ICON_TRIAN_HEIGHT + TRIANGLE_TO_PAT_GAP; | |
1383 | patRect.width = rect.width - 2*PAT_OFFSET; | |
1384 | patRect.height = rect.height - ( patRect.y - rect.y ) - PAT_OFFSET; | |
1385 | Draw3DPattern( patRect, dc ); | |
1386 | ||
1387 | dc.SetPen( mpLayout->mLightPen ); | |
1388 | dc.DrawLine( rect.x, rect.y + rect.height, rect.x + rect.width, rect.y + rect.height ); | |
1389 | } | |
1390 | else | |
1391 | { | |
1392 | wxRect triRect; | |
1393 | triRect.x = rect.x + TRIANGLE_OFFSET; | |
1394 | triRect.y = rect.y; | |
1395 | triRect.height = rect.height; | |
1396 | triRect.width = ICON_TRIAN_HEIGHT; | |
1397 | ||
1398 | DrawTrianRight( triRect, dc ); | |
1399 | ||
1400 | wxRect patRect; | |
1401 | patRect.y = rect.y + PAT_OFFSET; | |
1402 | patRect.x = rect.x + TRIANGLE_OFFSET + ICON_TRIAN_HEIGHT + TRIANGLE_TO_PAT_GAP; | |
1403 | patRect.height = rect.height - 2*PAT_OFFSET; | |
1404 | patRect.width = rect.width - ( patRect.x - rect.x ) - PAT_OFFSET; | |
1405 | Draw3DPattern( patRect, dc ); | |
1406 | ||
1407 | dc.SetPen( mpLayout->mLightPen ); | |
1408 | dc.DrawLine( rect.x + rect.width, rect.y, rect.x + rect.width, rect.y + rect.height ); | |
1409 | } | |
1410 | } | |
1411 | ||
1412 | void cbRowDragPlugin::DrawRowsDragHintsBorder( wxDC& dc ) | |
1413 | { | |
1414 | // FIXME:: what was that? | |
1415 | } | |
1416 | ||
1417 | void cbRowDragPlugin::DrawCollapsedRowsBorder( wxDC& dc ) | |
1418 | { | |
1419 | int colRowOfs = GetCollapsedIconsPos(); | |
1420 | wxRect& bounds = mpPane->mBoundsInParent; | |
1421 | ||
1422 | wxBrush bkBrush( mpLayout->mGrayPen.GetColour(), wxSOLID ); | |
1423 | dc.SetBrush( bkBrush ); | |
1424 | dc.SetPen( mpLayout->mDarkPen ); | |
1425 | ||
1426 | if ( mpPane->IsHorizontal() ) | |
1427 | ||
1428 | dc.DrawRectangle( bounds.x + mpPane->mLeftMargin - ROW_DRAG_HINT_WIDTH - 1, | |
1429 | colRowOfs, | |
1430 | bounds.width - mpPane->mLeftMargin - mpPane->mRightMargin + 2 + ROW_DRAG_HINT_WIDTH, | |
1431 | COLLAPSED_ICON_HEIGHT + 1); | |
1432 | else | |
1433 | dc.DrawRectangle( colRowOfs, | |
1434 | bounds.y + mpPane->mTopMargin - 1, | |
1435 | COLLAPSED_ICON_HEIGHT + 1, | |
1436 | bounds.height - mpPane->mTopMargin - mpPane->mBottomMargin | |
1437 | - ROW_DRAG_HINT_WIDTH - 2 ); | |
1438 | ||
1439 | dc.SetBrush( wxNullBrush ); | |
1440 | } | |
1441 | ||
1442 | static inline bool rect_contains_point( const wxRect& rect, int x, int y ) | |
1443 | { | |
1444 | return ( x >= rect.x && | |
1445 | y >= rect.y && | |
1446 | x < rect.x + rect.width && | |
1447 | y < rect.y + rect.height ); | |
1448 | } | |
1449 | ||
1450 | bool cbRowDragPlugin::HitTestCollapsedRowIcon( int iconIdx, const wxPoint& pos ) | |
1451 | { | |
1452 | wxRect bounds; | |
1453 | GetCollapsedInconRect( iconIdx, bounds ); | |
1454 | ||
1455 | return rect_contains_point( bounds, pos.x, pos.y ); | |
1456 | } | |
1457 | ||
1458 | bool cbRowDragPlugin::HitTestRowDragHint( cbRowInfo* pRow, const wxPoint& pos ) | |
1459 | { | |
1460 | wxRect bounds; | |
1461 | GetRowHintRect( pRow, bounds ); | |
1462 | ||
1463 | return rect_contains_point( bounds, pos.x, pos.y ); | |
1464 | } | |
1465 |