Commit | Line | Data |
---|---|---|
bd9396d5 HH |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: No names yet. | |
3 | // Purpose: Contrib. demo | |
4 | // Author: Aleksandras Gluchovas | |
5 | // Modified by: | |
6 | // Created: 07/09/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Aleksandras Gluchovas | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifdef __GNUG__ | |
13 | #pragma implementation "controlarea.h" | |
14 | // #pragma interface | |
15 | #endif | |
16 | ||
17 | // For compilers that support precompilation, includes "wx.h". | |
18 | #include "wx/wxprec.h" | |
19 | ||
20 | #ifdef __BORLANDC__ | |
21 | #pragma hdrstop | |
22 | #endif | |
23 | ||
24 | #ifndef WX_PRECOMP | |
25 | #include "wx/wx.h" | |
26 | #endif | |
27 | ||
28 | #include <math.h> | |
29 | #include <stdlib.h> | |
30 | ||
31 | #include "wx/string.h" | |
32 | #include "wx/utils.h" // import wxMin/wxMax macros and wxFileExist(..) | |
33 | ||
34 | #include "controlarea.h" | |
35 | ||
36 | ||
37 | /***** Implementation for class twTabInfo *****/ | |
38 | ||
39 | IMPLEMENT_DYNAMIC_CLASS( twTabInfo, wxObject ) | |
40 | ||
41 | twTabInfo::twTabInfo() | |
42 | : mpContent( 0 ) | |
43 | {} | |
44 | ||
45 | twTabInfo::~twTabInfo() | |
46 | { | |
47 | // FOR NOW:: nothing | |
48 | } | |
49 | ||
50 | int twTabInfo::ImgWidth() | |
51 | { | |
52 | if ( mBitMap.Ok() ) return mBitMap.GetWidth(); | |
53 | else return 0; | |
54 | } | |
55 | ||
56 | int twTabInfo::ImgHeight() | |
57 | { | |
58 | if ( mBitMap.Ok() ) return mBitMap.GetHeight(); | |
59 | else return 0; | |
60 | } | |
61 | ||
62 | int twTabInfo::ImageToTxtGap( int prefGap ) | |
63 | { | |
64 | if ( mBitMap.Ok() ) return prefGap; | |
65 | else return 0; | |
66 | } | |
67 | ||
68 | bool twTabInfo::HasImg() | |
69 | { | |
70 | return mBitMap.Ok(); | |
71 | } | |
72 | ||
73 | bool twTabInfo::HasText() | |
74 | { | |
75 | return mText.Length(); | |
76 | } | |
77 | ||
78 | wxBitmap& twTabInfo::GetImg() | |
79 | { | |
80 | return mBitMap; | |
81 | } | |
82 | ||
83 | wxString& twTabInfo::GetText() | |
84 | { | |
85 | return mText; | |
86 | } | |
87 | ||
88 | wxWindow& twTabInfo::GetContent() | |
89 | { | |
90 | return *mpContent; | |
91 | } | |
92 | ||
93 | /***** Implementation for class wxTabbedWindow *****/ | |
94 | ||
95 | IMPLEMENT_DYNAMIC_CLASS( wxTabbedWindow, wxPanel ) | |
96 | ||
97 | BEGIN_EVENT_TABLE( wxTabbedWindow, wxPanel ) | |
98 | ||
99 | EVT_SIZE ( wxTabbedWindow::OnSize ) | |
100 | EVT_PAINT( wxTabbedWindow::OnPaint ) | |
101 | EVT_LEFT_DOWN( wxTabbedWindow::OnLButtonDown ) | |
102 | ||
103 | // TDB:: filciker reduction | |
104 | // EVT_ERASE_BACKGROUND( wxTabbedWindow::OnBkErase ) | |
105 | ||
106 | END_EVENT_TABLE() | |
107 | ||
108 | wxTabbedWindow::wxTabbedWindow() | |
109 | ||
110 | : mpTabScroll ( NULL ), | |
111 | mpHorizScroll( NULL ), | |
112 | mpVertScroll ( NULL ), | |
113 | ||
114 | mVertGap ( 0 ), | |
115 | mHorizGap( 0 ), | |
116 | ||
117 | mTitleVertGap ( 3 ), | |
118 | mTitleHorizGap( 4 ), | |
119 | mImageTextGap ( 2 ), | |
120 | mFirstTitleGap( 11 ), | |
121 | ||
122 | mBorderOnlyWidth( 8 ), | |
123 | ||
124 | mWhitePen( wxColour(255,255,255), 1, wxSOLID ), | |
8a704c2b RS |
125 | mLightPen( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DHIGHLIGHT), 1, wxSOLID), |
126 | mGrayPen ( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ), | |
127 | mDarkPen ( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ), | |
bd9396d5 HH |
128 | mBlackPen( wxColour( 0, 0, 0), 1, wxSOLID ), |
129 | ||
130 | // state variables | |
131 | ||
132 | mActiveTab ( 0 ), | |
133 | mTitleHeight( 0 ), | |
134 | mLayoutType( wxTITLE_IMG_AND_TEXT ) | |
135 | {} | |
136 | ||
137 | wxTabbedWindow::~wxTabbedWindow() | |
138 | { | |
139 | wxNode* pTab = mTabs.First(); | |
140 | ||
141 | while( pTab ) | |
142 | { | |
143 | delete ((twTabInfo*)pTab->Data()); | |
144 | ||
145 | pTab = pTab->Next(); | |
146 | } | |
147 | } | |
148 | ||
149 | void wxTabbedWindow::SizeTabs(int x,int y, int width, int height, bool repant) | |
150 | { | |
151 | wxNode* pTabNode = mTabs.First(); | |
152 | int n = 0; | |
153 | ||
154 | while( pTabNode ) | |
155 | { | |
156 | twTabInfo& info = *((twTabInfo*)pTabNode->Data()); | |
157 | ||
158 | if ( n == mActiveTab ) | |
159 | { | |
160 | //wxSizeEvent evt; | |
161 | //info.mpContent->GetEventHandler()->ProcessEvent( evt ); | |
162 | ||
163 | info.mpContent->SetSize( x, y, width, height, 0 ); | |
164 | info.mpContent->Show(TRUE); | |
165 | info.mpContent->Refresh(); | |
166 | ||
167 | } | |
168 | else | |
169 | { | |
170 | info.mpContent->Show(FALSE); | |
171 | } | |
172 | ||
173 | pTabNode = pTabNode->Next(); | |
174 | ++n; | |
175 | } | |
176 | } | |
177 | ||
178 | void wxTabbedWindow::AddTab( wxWindow* pContent, | |
179 | wxString tabText, | |
180 | wxString imageFileName, | |
181 | long imageType ) | |
182 | { | |
183 | twTabInfo* pTab = new twTabInfo(); | |
184 | ||
185 | pTab->mpContent = pContent; | |
186 | pTab->mText = tabText; | |
187 | ||
188 | if ( wxFileExists( imageFileName ) && | |
189 | ||
190 | pTab->mBitMap.LoadFile( imageFileName, imageType ) ) | |
191 | { | |
192 | pTab->mImageFile = imageFileName; | |
193 | pTab->mImageType = imageType; | |
194 | } | |
195 | ||
196 | bool ok = pTab->mBitMap.Ok(); | |
197 | ||
198 | if ( pContent->GetParent() == NULL ) | |
199 | ||
200 | pContent->Create( this, -1 ); | |
201 | ||
202 | mTabs.Append( (wxObject*)pTab ); | |
203 | ||
204 | RecalcLayout(TRUE); | |
205 | ||
206 | OnTabAdded( pTab ); | |
207 | } | |
208 | ||
209 | void wxTabbedWindow::AddTab( wxWindow* pContent, | |
210 | wxString tabText, | |
211 | wxBitmap* pImage ) | |
212 | { | |
213 | twTabInfo* pTab = new twTabInfo(); | |
214 | ||
215 | pTab->mpContent = pContent; | |
216 | pTab->mText = tabText; | |
217 | ||
218 | if ( pImage ) pTab->mBitMap = *pImage; | |
219 | ||
220 | if ( pContent->GetParent() == NULL ) | |
221 | ||
222 | pContent->Create( this, -1 ); | |
223 | ||
224 | mTabs.Append( (wxObject*)pTab ); | |
225 | ||
226 | RecalcLayout(TRUE); | |
227 | ||
228 | OnTabAdded( pTab ); | |
229 | } | |
230 | ||
231 | ||
232 | ||
233 | void wxTabbedWindow::RemoveTab( int tabNo ) | |
234 | { | |
235 | twTabInfo* pTab = ((twTabInfo*)(mTabs.Nth( tabNo )->Data())); | |
236 | ||
237 | pTab->mpContent->Destroy(); | |
238 | ||
239 | delete pTab; | |
240 | ||
241 | mTabs.DeleteNode( mTabs.Nth( tabNo ) ); | |
242 | ||
243 | if ( mActiveTab >= mTabs.Number() ); | |
244 | ||
245 | mActiveTab = mTabs.Number() - 1; | |
246 | ||
247 | SetActiveTab( mActiveTab ); | |
248 | } | |
249 | ||
250 | int wxTabbedWindow::GetTabCount() | |
251 | { | |
252 | return mTabs.Number(); | |
253 | } | |
254 | ||
255 | wxWindow* wxTabbedWindow::GetTab( int tabNo ) | |
256 | { | |
257 | return ((twTabInfo*)(mTabs.Nth( tabNo )->Data()))->mpContent; | |
258 | } | |
259 | ||
260 | wxWindow* wxTabbedWindow::GetActiveTab() | |
261 | { | |
262 | // FIMXE:: this is lame | |
263 | ||
264 | return GetTab( mActiveTab ); | |
265 | } | |
266 | ||
267 | void wxTabbedWindow::SetActiveTab( int tabNo ) | |
268 | { | |
269 | mActiveTab = tabNo; | |
270 | ||
271 | RecalcLayout(TRUE); | |
272 | ||
273 | Refresh(); | |
274 | } | |
275 | ||
276 | // width of the decorations border (4 shade-lines), should not be changed | |
277 | ||
278 | #define BORDER_SZ 4 | |
279 | ||
280 | void wxTabbedWindow::DrawShadedRect( int x, int y, int width, int height, | |
281 | wxPen& upperPen, wxPen& lowerPen, wxDC& dc | |
282 | ) | |
283 | { | |
284 | // darw the lightened upper-left sides of the rectangle | |
285 | ||
286 | dc.SetPen( upperPen ); | |
287 | dc.DrawLine( x,y, x, y + height - 1 ); // vert | |
288 | dc.DrawLine( x,y, x + width - 1, y ); // horiz | |
289 | ||
290 | // draw the unenlightened lower-right sides of the rectangle | |
291 | ||
292 | dc.SetPen( lowerPen ); | |
293 | dc.DrawLine( x + width - 1, y, x + width - 1, y + height - 1 ); // vert | |
294 | dc.DrawLine( x, y + height - 1, x + width, y + height - 1 ); // horiz | |
295 | } | |
296 | ||
297 | void wxTabbedWindow::DrawDecorations( wxDC& dc ) | |
298 | { | |
299 | // Protability NOTE::: DrawLine(..) draws a line from the first position, | |
300 | // but not including the point specified by last position. | |
301 | // This way Windows draws lines, not sure how Motif and Gtk | |
302 | // prots behave... | |
303 | ||
304 | int width, height; | |
305 | GetClientSize( &width, &height ); | |
306 | ||
307 | // check if there's at least a bit of space to draw things | |
308 | ||
309 | if ( width < mHorizGap*2 + BORDER_SZ*2+1 || | |
310 | height < mVertGap*2 + BORDER_SZ*2+1 + mTitleHeight | |
311 | ) | |
312 | return; | |
313 | ||
314 | // step #1 - draw border around the tab content area | |
315 | ||
316 | // setup position for kind of "pencil" | |
317 | int curX = mHorizGap; | |
318 | int curY = mVertGap; | |
319 | ||
320 | int xSize = width - mHorizGap*2; | |
321 | int ySize = height - mVertGap *2 - mTitleHeight; | |
322 | ||
323 | // layer 1 (upper white) | |
324 | DrawShadedRect( curX+0, curY+0, xSize-0, ySize-0, | |
8a704c2b | 325 | mLightPen, mBlackPen, dc ); |
bd9396d5 HH |
326 | |
327 | // layer 2 (upper gray) | |
328 | DrawShadedRect( curX+1, curY+1, xSize-2-1, ySize-2-1, | |
329 | mGrayPen, mGrayPen, dc ); | |
330 | ||
331 | // layer 3 (upper darkGray) | |
332 | DrawShadedRect( curX+2, curY+2, xSize-3-2, ySize-3-2, | |
8a704c2b | 333 | mDarkPen, mLightPen, dc ); |
bd9396d5 HH |
334 | |
335 | // layer 4 (upper black) | |
336 | DrawShadedRect( curX+3, curY+3, xSize-4-3, ySize-4-3, | |
337 | mBlackPen, mGrayPen, dc ); | |
338 | ||
339 | // add non-siemtric layer from the lower-right side (confroming to MFC-look) | |
340 | ||
341 | dc.SetPen( mDarkPen ); | |
342 | dc.DrawLine( curX+1, curY + ySize - 2, curX + xSize - 1, curY + ySize - 2 ); // horiz | |
343 | dc.DrawLine( curX + xSize - 2, curY + 1, curX + xSize - 2, curY + ySize - 2 ); // vert | |
344 | ||
345 | // step #2 - draw tab title bars | |
346 | ||
347 | curX = mFirstTitleGap; | |
348 | curY = height - mVertGap - mTitleHeight; | |
349 | ||
350 | int tabNo = 0; | |
351 | wxNode* pNode = mTabs.First(); | |
352 | ||
353 | while( pNode ) | |
354 | { | |
355 | // "hard-coded metafile" for decorations | |
356 | ||
357 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
358 | ||
359 | xSize = tab.mDims.x; | |
360 | ySize = mTitleHeight; | |
361 | ||
362 | if ( tabNo == mActiveTab ) | |
363 | { | |
364 | dc.SetPen( mGrayPen ); | |
365 | dc.DrawLine( curX+1, curY-2, curX+xSize-2, curY-2 ); | |
366 | dc.DrawLine( curX+1, curY-1, curX+xSize-2, curY-1 ); | |
367 | } | |
368 | ||
8a704c2b | 369 | dc.SetPen( mLightPen ); |
bd9396d5 HH |
370 | |
371 | if ( tabNo == mActiveTab ) | |
372 | dc.DrawLine( curX, curY-2, curX, curY+ySize-2 ); | |
373 | else | |
374 | dc.DrawLine( curX, curY, curX, curY+ySize-2 ); | |
375 | ||
376 | dc.SetPen( mDarkPen ); | |
377 | dc.DrawLine( curX+1, curY+ySize-3, curX+1, curY+ySize-1 ); // to pix down | |
378 | dc.DrawLine( curX+2, curY+ySize-2, curX+xSize-2, curY+ySize-2 ); | |
379 | dc.DrawLine( curX+xSize-3, curY+ySize-3, curX+xSize-2, curY+ySize-3 ); | |
380 | if ( tabNo == mActiveTab ) | |
381 | dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-3 ); | |
382 | else | |
383 | dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-1 ); | |
384 | ||
385 | dc.SetPen( mBlackPen ); | |
386 | dc.DrawLine( curX+xSize-1, curY, curX+xSize-1, curY+ySize-2 ); | |
387 | dc.DrawLine( curX+xSize-2, curY+ySize-2, curX+xSize-3, curY+ySize-2 ); | |
388 | dc.DrawLine( curX+xSize-3, curY+ySize-1, curX+1, curY+ySize-1 ); | |
389 | ||
390 | pNode = pNode->Next(); | |
391 | ++tabNo; | |
392 | ||
393 | // darw image and (or without) text centered within the | |
394 | // title bar rectangle | |
395 | ||
396 | if ( mLayoutType != wxTITLE_BORDER_ONLY && tab.HasImg() ) | |
397 | { | |
398 | wxMemoryDC tmpDc; | |
399 | tmpDc.SelectObject( tab.GetImg() ); | |
400 | ||
401 | dc.Blit( curX + mTitleHorizGap, | |
402 | curY + ( ySize - tab.ImgHeight() ) / 2, | |
403 | tab.ImgWidth(), | |
404 | tab.ImgHeight(), | |
8a704c2b | 405 | &tmpDc, 0, 0, wxCOPY,true |
bd9396d5 HH |
406 | ); |
407 | } | |
408 | ||
409 | if ( mLayoutType == wxTITLE_IMG_AND_TEXT && tab.HasText() ) | |
410 | { | |
411 | long x,w,h; | |
412 | ||
413 | // set select default font of the window into it's device context | |
414 | dc.SetFont( GetLabelingFont() ); | |
415 | ||
416 | dc.SetTextBackground( GetBackgroundColour() ); | |
417 | ||
418 | dc.GetTextExtent(tab.mText, &w, &h ); | |
419 | ||
420 | x = curX + mTitleHorizGap + | |
421 | tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap); | |
422 | ||
423 | dc.DrawText( tab.GetText(), x, curY + ( ySize - h ) / 2 ); | |
424 | } | |
425 | curX += xSize; | |
426 | ||
427 | } // end of `while (pNode)' | |
428 | } | |
429 | ||
430 | int wxTabbedWindow::HitTest( const wxPoint& pos ) | |
431 | { | |
432 | int width, height; | |
433 | GetClientSize( &width, &height ); | |
434 | ||
435 | int curX = mFirstTitleGap; | |
436 | int curY = height - mVertGap - mTitleHeight; | |
437 | ||
438 | int tabNo = 0; | |
439 | wxNode* pNode = mTabs.First(); | |
440 | ||
441 | int x = pos.x; | |
442 | int y = pos.y; | |
443 | ||
444 | while( pNode ) | |
445 | { | |
446 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
447 | ||
448 | int w,h; | |
449 | w = tab.mDims.x; | |
450 | h = tab.mDims.y; | |
451 | // hit test rectangle of the currnet tab title bar | |
452 | if ( pos.x >= curX && pos.x < curX + tab.mDims.x && | |
453 | pos.y >= curY && pos.y < curY + tab.mDims.y | |
454 | ) | |
455 | { | |
456 | return tabNo; | |
457 | } | |
458 | ||
459 | curX += tab.mDims.x; | |
460 | ||
461 | pNode = pNode->Next(); | |
462 | ++tabNo; | |
463 | } | |
464 | ||
465 | return -1; | |
466 | } | |
467 | ||
468 | void wxTabbedWindow::HideInactiveTabs( bool andRepaint ) | |
469 | { | |
470 | if ( !andRepaint ) | |
471 | return; | |
472 | ||
473 | wxNode* pNode = mTabs.First(); | |
474 | int tabNo = 0; | |
475 | ||
476 | while( pNode ) | |
477 | { | |
478 | if ( tabNo != mActiveTab ) | |
479 | { | |
480 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
481 | tab.mpContent->Show(FALSE); | |
482 | } | |
483 | ||
484 | pNode = pNode->Next(); | |
485 | ++tabNo; | |
486 | } | |
487 | } | |
488 | ||
489 | wxFont wxTabbedWindow::GetLabelingFont() | |
490 | { | |
8a704c2b | 491 | #if 0 |
bd9396d5 HH |
492 | wxFont font; |
493 | #ifdef __WINDOWS__ | |
494 | font.SetFaceName("MS Sans Serif"); | |
495 | #else | |
8a704c2b | 496 | font.SetFamily( wxDEFAULT ); |
bd9396d5 HH |
497 | #endif |
498 | ||
8a704c2b RS |
499 | font.SetStyle(wxNORMAL); |
500 | font.SetWeight(wxNORMAL); | |
bd9396d5 HH |
501 | font.SetPointSize( 8 ); |
502 | ||
503 | #ifdef __WINDOWS__ | |
504 | font.RealizeResource(); | |
505 | #endif | |
506 | ||
507 | return font; | |
8a704c2b | 508 | #endif |
49841b74 | 509 | return wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT); |
bd9396d5 HH |
510 | } |
511 | ||
512 | void wxTabbedWindow::RecalcLayout(bool andRepaint) | |
513 | { | |
514 | HideInactiveTabs(andRepaint); | |
515 | ||
516 | // resetup position of the active tab | |
517 | ||
518 | int width, height; | |
519 | GetClientSize( &width, &height ); | |
520 | ||
521 | int curX = mHorizGap + BORDER_SZ; | |
522 | int curY = mVertGap + BORDER_SZ; | |
523 | ||
524 | int xSize = width - mHorizGap*2 - BORDER_SZ*2-1; | |
525 | int ySize = height - mVertGap*2 - BORDER_SZ*2-1 - mTitleHeight; | |
526 | ||
527 | SizeTabs( curX, curY, xSize, ySize, andRepaint ); | |
528 | ||
529 | // pass #1 - try to layout assuming it's wxTITLE_IMG_AND_TEXT | |
530 | ||
531 | mLayoutType = wxTITLE_IMG_AND_TEXT; | |
532 | ||
533 | wxNode* pNode = mTabs.First(); | |
534 | ||
535 | curX = mFirstTitleGap; // the left-side gap | |
536 | mTitleHeight = 0; | |
537 | ||
538 | while( pNode ) | |
539 | { | |
540 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
541 | ||
542 | wxWindowDC dc(this); | |
543 | ||
544 | long w,h; | |
545 | ||
546 | // set select default font of the window into it's device context | |
547 | dc.SetFont( GetLabelingFont() ); | |
548 | ||
549 | dc.GetTextExtent(tab.mText, &w, &h ); | |
550 | ||
551 | tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) + | |
552 | tab.ImgWidth() + mTitleHorizGap*2; | |
553 | ||
554 | tab.mDims.y = wxMax( h, tab.ImgHeight() ) + mTitleVertGap*2; | |
555 | mTitleHeight = wxMax( mTitleHeight, tab.mDims.y ); | |
556 | ||
557 | curX += tab.mDims.x; | |
558 | ||
559 | pNode = pNode->Next(); | |
560 | } | |
561 | ||
562 | curX += mHorizGap; // the right-side gap | |
563 | ||
564 | // make all title bars of equel height | |
565 | ||
566 | pNode = mTabs.First(); | |
567 | ||
568 | while( pNode ) | |
569 | { | |
570 | ((twTabInfo*)(pNode->Data()))->mDims.y = mTitleHeight;; | |
571 | pNode = pNode->Next(); | |
572 | } | |
573 | ||
574 | // if curX has'nt ran out of bounds, leave TITLE_IMG layout and return | |
575 | if ( curX < width - mHorizGap ) | |
576 | return; | |
577 | ||
578 | // pass #2 - try to layout assuming wxTITLE_IMG_ONLY | |
579 | ||
580 | mLayoutType = wxTITLE_IMG_ONLY; | |
581 | ||
582 | pNode = mTabs.First(); | |
583 | ||
584 | curX = mFirstTitleGap; // the left-side gap | |
585 | ||
586 | int denomiator = mTabs.Number(); | |
587 | if ( denomiator == 0 ) ++denomiator; | |
588 | ||
589 | mBorderOnlyWidth = (width - mFirstTitleGap - mHorizGap) / denomiator; | |
590 | ||
591 | while( pNode ) | |
592 | { | |
593 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
594 | ||
595 | if ( tab.HasImg() ) | |
596 | { | |
597 | tab.mDims.x = tab.ImgWidth() + mTitleHorizGap*2; | |
598 | tab.mDims.y = tab.ImgHeight() + mTitleVertGap*2; | |
599 | } | |
600 | else | |
601 | { | |
602 | tab.mDims.x = mBorderOnlyWidth; | |
603 | tab.mDims.y = mTitleHeight; | |
604 | } | |
605 | ||
606 | curX += tab.mDims.x; | |
607 | ||
608 | pNode = pNode->Next(); | |
609 | } | |
610 | ||
611 | curX += mHorizGap; // the right-side gap | |
612 | ||
613 | // if curX has'nt ran out of bounds, leave IMG_ONLY layout and return | |
614 | if ( curX < width - mHorizGap ) | |
615 | return; | |
616 | ||
617 | // pass #3 - set the narrowest layout wxTITLE_BORDER_ONLY | |
618 | ||
619 | mLayoutType = wxTITLE_BORDER_ONLY; | |
620 | ||
621 | pNode = mTabs.First(); | |
622 | ||
623 | while( pNode ) | |
624 | { | |
625 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
626 | ||
627 | tab.mDims.x = mBorderOnlyWidth; | |
628 | tab.mDims.y = mTitleHeight; | |
629 | ||
630 | pNode = pNode->Next(); | |
631 | } | |
632 | } | |
633 | ||
634 | // wx event handlers | |
635 | ||
636 | void wxTabbedWindow::OnPaint( wxPaintEvent& event ) | |
637 | { | |
638 | wxPaintDC dc(this); | |
639 | DrawDecorations( dc ); | |
640 | } | |
641 | ||
642 | void wxTabbedWindow::OnSize ( wxSizeEvent& event ) | |
643 | { | |
8a704c2b | 644 | SetBackgroundColour( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ); |
bd9396d5 HH |
645 | RecalcLayout(TRUE); |
646 | } | |
647 | ||
648 | void wxTabbedWindow::OnBkErase( wxEraseEvent& event ) | |
649 | { | |
650 | // do nothing | |
651 | } | |
652 | ||
653 | void wxTabbedWindow::OnLButtonDown( wxMouseEvent& event ) | |
654 | { | |
655 | // floats, why? | |
656 | int x = (int)event.m_x; | |
657 | int y = (int)event.m_y; | |
658 | ||
659 | int tabNo = HitTest( wxPoint(x,y) ); | |
660 | ||
661 | if ( tabNo != -1 ) | |
662 | { | |
663 | SetActiveTab( tabNo ); | |
664 | } | |
665 | } | |
666 | ||
667 | /***** Implementation for class wxPaggedWindow *****/ | |
668 | ||
669 | IMPLEMENT_DYNAMIC_CLASS( wxPaggedWindow, wxTabbedWindow ) | |
670 | ||
671 | BEGIN_EVENT_TABLE( wxPaggedWindow, wxTabbedWindow ) | |
672 | EVT_SIZE ( wxPaggedWindow::OnSize ) | |
673 | EVT_PAINT ( wxPaggedWindow::OnPaint ) | |
674 | EVT_LEFT_DOWN( wxPaggedWindow::OnLButtonDown ) | |
675 | EVT_LEFT_UP ( wxPaggedWindow::OnLButtonUp ) | |
676 | EVT_MOTION ( wxPaggedWindow::OnMouseMove ) | |
677 | EVT_SCROLL ( wxPaggedWindow::OnScroll ) | |
678 | END_EVENT_TABLE() | |
679 | ||
680 | // border for pagged-window is 2 shaded-lines | |
681 | ||
682 | #undef BORDER_SZ | |
683 | #define BORDER_SZ 2 | |
684 | ||
685 | wxPaggedWindow::wxPaggedWindow() | |
686 | ||
687 | : mScrollEventInProgress( FALSE ), | |
688 | ||
689 | mTabTrianGap(4), | |
690 | ||
691 | mWhiteBrush( wxColour(255,255,255), wxSOLID ), | |
8a704c2b | 692 | mGrayBrush ( wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE), wxSOLID ), |
bd9396d5 HH |
693 | |
694 | mCurentRowOfs( 0 ), | |
695 | mAdjustableTitleRowLen( 300 ), | |
696 | ||
697 | mIsDragged ( FALSE ), | |
698 | mDagOrigin ( 0 ), | |
699 | mCursorChanged( FALSE ), | |
700 | mResizeCursor ( wxCURSOR_SIZEWE ), | |
701 | mNormalCursor ( wxCURSOR_ARROW ) | |
702 | { | |
703 | mTitleVertGap = 2; | |
704 | mTitleHorizGap = 10; | |
705 | } | |
706 | ||
707 | wxPaggedWindow::~wxPaggedWindow() | |
708 | { | |
709 | // nothing (base class handles destruction) | |
710 | } | |
711 | ||
712 | wxFont wxPaggedWindow::GetLabelingFont() | |
713 | { | |
8a704c2b | 714 | #if 0 |
bd9396d5 HH |
715 | wxFont font; |
716 | ||
717 | #ifdef __WINDOWS__ | |
718 | font.SetFaceName("Arial"); | |
719 | #else | |
8a704c2b | 720 | font.SetFamily( wxDEFAULT ); |
bd9396d5 HH |
721 | #endif |
722 | ||
8a704c2b RS |
723 | font.SetStyle(wxNORMAL); |
724 | font.SetWeight(wxNORMAL); | |
bd9396d5 HH |
725 | font.SetPointSize( 8 ); |
726 | ||
727 | #ifdef __WINDOWS__ | |
728 | bool success = font.RealizeResource(); | |
729 | #endif | |
730 | ||
731 | return font; | |
8a704c2b | 732 | #endif |
49841b74 | 733 | return wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT); |
bd9396d5 HH |
734 | } |
735 | ||
736 | void wxPaggedWindow::OnTabAdded( twTabInfo* pInfo ) | |
737 | { | |
738 | int units = GetWholeTabRowLen() / 20; | |
739 | ||
740 | mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE ); | |
741 | } | |
742 | ||
743 | wxScrollBar& wxPaggedWindow::GetVerticalScrollBar() | |
744 | { | |
745 | return *mpVertScroll; | |
746 | } | |
747 | ||
748 | wxScrollBar& wxPaggedWindow::GetHorizontalScrollBar() | |
749 | { | |
750 | return *mpHorizScroll; | |
751 | } | |
752 | ||
753 | ||
754 | int wxPaggedWindow::GetWholeTabRowLen() | |
755 | { | |
756 | wxNode* pNode = mTabs.First(); | |
757 | ||
758 | int len = 0; | |
759 | ||
760 | while( pNode ) | |
761 | { | |
762 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
763 | ||
764 | len += tab.mDims.x; | |
765 | pNode = pNode->Next(); | |
766 | } | |
767 | ||
768 | return len; | |
769 | } | |
770 | ||
771 | void wxPaggedWindow::DrawPaperBar( twTabInfo& tab, int x, int y, | |
772 | wxBrush& brush, wxPen& pen, wxDC& dc ) | |
773 | { | |
774 | wxPoint poly[4]; | |
775 | ||
776 | // draw organizer-style paper outlet | |
777 | ||
778 | poly[0].x = x - mTabTrianGap; | |
779 | poly[0].y = y; | |
780 | ||
781 | poly[1].x = x + mTabTrianGap; | |
782 | poly[1].y = y + tab.mDims.y-1; | |
783 | ||
784 | poly[2].x = x + tab.mDims.x - mTabTrianGap; | |
785 | poly[2].y = y + tab.mDims.y-1; | |
786 | ||
787 | poly[3].x = x + tab.mDims.x + mTabTrianGap; | |
788 | poly[3].y = y; | |
789 | ||
790 | dc.SetPen( pen ); | |
791 | dc.SetBrush( brush ); | |
792 | ||
793 | dc.DrawPolygon( 4, poly ); | |
794 | ||
795 | long w,h; | |
796 | ||
797 | // set select default font of the window into it's device context | |
798 | dc.SetFont( GetLabelingFont() ); | |
799 | ||
800 | dc.SetTextBackground( brush.GetColour() ); | |
801 | ||
802 | dc.GetTextExtent(tab.mText, &w, &h ); | |
803 | ||
804 | if ( tab.HasImg() ) | |
805 | { | |
806 | wxMemoryDC tmpDc; | |
807 | tmpDc.SelectObject( tab.GetImg() ); | |
808 | ||
809 | dc.Blit( x + mTitleHorizGap, | |
810 | y + ( tab.mDims.y - tab.ImgHeight() ) / 2, | |
811 | tab.ImgWidth(), | |
812 | tab.ImgHeight(), | |
8a704c2b | 813 | &tmpDc, 0, 0, wxCOPY,true |
bd9396d5 HH |
814 | ); |
815 | } | |
816 | ||
817 | if ( tab.HasText() ) | |
818 | { | |
819 | int tx = x + mTitleHorizGap + | |
820 | tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap); | |
821 | ||
822 | dc.DrawText( tab.GetText(), tx, y + ( tab.mDims.y - h ) / 2 ); | |
823 | } | |
824 | } | |
825 | ||
826 | void wxPaggedWindow::DrawDecorations( wxDC& dc ) | |
827 | { | |
828 | // FIXME:: the is big body have to be split! | |
829 | ||
830 | int width, height; | |
831 | GetClientSize( &width, &height ); | |
832 | ||
833 | int curX = mHorizGap; | |
834 | int curY = mVertGap; | |
835 | ||
836 | int xSize = width - mHorizGap*2; | |
837 | int ySize = height - mVertGap*2; | |
838 | ||
839 | DrawShadedRect( curX, curY, xSize, ySize, | |
8a704c2b | 840 | mDarkPen, mLightPen, dc ); |
bd9396d5 HH |
841 | |
842 | DrawShadedRect( curX+1, curY+1, xSize-2, ySize-2, | |
843 | mBlackPen, mGrayPen, dc ); | |
844 | ||
845 | // draw inactive tab title bars frist (left-to-right) | |
846 | ||
847 | wxNode* pNode = mTabs.First(); | |
848 | int tabNo = 0; | |
849 | ||
850 | /* OLD STUFF:: | |
851 | curX = mTitleRowStart; | |
852 | curY = height - mVertGap - BORDER_SZ - mTitleHeight; | |
853 | */ | |
854 | ||
855 | curX = mTabTrianGap; | |
856 | curY = 0; | |
857 | ||
858 | // FOR NOW:: avoid creating bitmap with invalid dimensions | |
859 | ||
860 | if ( mTitleRowLen < 1 || mTitleHeight < 1 ) return; | |
861 | ||
862 | wxMemoryDC tmpDc; | |
863 | wxBitmap tmpBmp( mTitleRowLen, mTitleHeight ); | |
864 | ||
865 | tmpDc.SelectObject( tmpBmp ); | |
866 | tmpDc.SetPen( mGrayPen ); | |
867 | tmpDc.SetBrush( mGrayBrush ); | |
868 | tmpDc.DrawRectangle( 0,0, mTitleRowLen, mTitleHeight ); | |
869 | ||
870 | tmpDc.SetDeviceOrigin( mCurentRowOfs, 0 ); | |
871 | ||
872 | while( pNode ) | |
873 | { | |
874 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
875 | ||
876 | if ( tabNo != mActiveTab ) | |
877 | ||
878 | DrawPaperBar( tab, curX, curY, mGrayBrush, mBlackPen, tmpDc ); | |
879 | ||
880 | curX += tab.mDims.x; | |
881 | ||
882 | pNode = pNode->Next(); | |
883 | ++tabNo; | |
884 | } | |
885 | ||
886 | // finally, draw the active tab (white-filled) | |
887 | ||
888 | pNode = mTabs.First(); | |
889 | tabNo = 0; | |
890 | ||
891 | curX = mTabTrianGap; | |
892 | ||
893 | while( pNode ) | |
894 | { | |
895 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
896 | ||
897 | if ( tabNo == mActiveTab ) | |
898 | { | |
899 | DrawPaperBar( tab, curX, curY, mWhiteBrush, mBlackPen, tmpDc ); | |
900 | ||
8a704c2b | 901 | tmpDc.SetPen( mLightPen ); |
bd9396d5 HH |
902 | |
903 | tmpDc.DrawLine( curX - mTabTrianGap+1, curY, | |
904 | curX + tab.mDims.x + mTabTrianGap, curY ); | |
905 | break; | |
906 | } | |
907 | curX += tab.mDims.x; | |
908 | ||
909 | pNode = pNode->Next(); | |
910 | ++tabNo; | |
911 | } | |
912 | ||
913 | // back to initial device origin | |
914 | ||
915 | tmpDc.SetDeviceOrigin( 0, 0 ); | |
916 | ||
917 | // draw resize-hint-stick | |
918 | ||
919 | curX = mTitleRowLen - 6; | |
920 | ||
921 | DrawShadedRect( curX+0, 0+0, 6, mTitleHeight, mGrayPen, mBlackPen, tmpDc ); | |
8a704c2b | 922 | DrawShadedRect( curX+1, 0+1, 6-2, mTitleHeight-2, mLightPen, mDarkPen, tmpDc ); |
bd9396d5 HH |
923 | DrawShadedRect( curX+2, 0+2, 6-4, mTitleHeight-4, mGrayPen, mGrayPen, tmpDc ); |
924 | ||
925 | ||
926 | ||
927 | dc.Blit( mTitleRowStart, | |
928 | height - mVertGap - BORDER_SZ - mTitleHeight, | |
929 | mTitleRowLen, mTitleHeight, | |
930 | &tmpDc, 0,0, wxCOPY ); | |
931 | } | |
932 | ||
933 | int wxPaggedWindow::HitTest( const wxPoint& pos ) | |
934 | { | |
935 | return wxTabbedWindow::HitTest( pos ); | |
936 | } | |
937 | ||
938 | void wxPaggedWindow::RecalcLayout(bool andRepaint) | |
939 | { | |
940 | mTitleRowLen = mAdjustableTitleRowLen; | |
941 | ||
942 | if ( int(mpTabScroll) == -1 ) return; | |
943 | ||
944 | // scroll bars should be created after Create() for this window is called | |
945 | if ( !mpTabScroll ) | |
946 | { | |
947 | mpTabScroll = | |
948 | new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL ); | |
949 | ||
950 | mpHorizScroll = | |
951 | new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL ); | |
952 | ||
953 | mpVertScroll = | |
954 | new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL ); | |
955 | } | |
956 | ||
957 | { | |
958 | int units = GetWholeTabRowLen() / 20; | |
959 | ||
960 | mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE ); | |
961 | } | |
962 | ||
963 | // resetup position of the active tab | |
964 | ||
965 | int thumbLen = 16; // FOR NOW:: hardcoded | |
966 | ||
967 | int width, height; | |
968 | GetClientSize( &width, &height ); | |
969 | ||
970 | mTitleHeight = thumbLen; | |
971 | ||
972 | int curX = mHorizGap + BORDER_SZ; | |
973 | int curY = mVertGap + BORDER_SZ; | |
974 | ||
975 | int xSize = width - mHorizGap*2 - BORDER_SZ*2 - thumbLen; | |
976 | ||
977 | int ySize = height - mVertGap*2 - BORDER_SZ*2 - mTitleHeight; | |
978 | ||
979 | SizeTabs( curX, curY, xSize, ySize, andRepaint ); | |
980 | ||
981 | // setup title bar LINES's horizontal scroll bar | |
982 | ||
983 | curY = height - mVertGap - BORDER_SZ - thumbLen; | |
984 | ||
985 | mpTabScroll->SetSize( curX, curY, thumbLen*2, thumbLen ); | |
986 | ||
987 | // setup view's HORIZONTAL scroll bar | |
988 | ||
989 | curX += thumbLen*2; | |
990 | ||
991 | mTitleRowStart = curX; | |
992 | mFirstTitleGap = curX + mCurentRowOfs + mTabTrianGap; | |
993 | ||
994 | mTitleRowLen = wxMin( mAdjustableTitleRowLen, | |
995 | width - mHorizGap - BORDER_SZ - thumbLen*4 - curX ); | |
996 | ||
997 | curX += mTitleRowLen; | |
998 | ||
999 | mpHorizScroll->SetSize( curX, curY, | |
1000 | width - curX - mHorizGap - BORDER_SZ - thumbLen, | |
1001 | thumbLen | |
1002 | ); | |
1003 | ||
1004 | // setup view's VERTICAL scroll bar | |
1005 | ||
1006 | curX = width - mHorizGap - BORDER_SZ - thumbLen; | |
1007 | ||
1008 | curY = mVertGap + BORDER_SZ; | |
1009 | ||
1010 | mpVertScroll->SetSize( curX, curY, thumbLen, | |
1011 | height - curY - mVertGap - BORDER_SZ - thumbLen | |
1012 | ); | |
1013 | ||
1014 | // layout tab title bars | |
1015 | ||
1016 | mLayoutType = wxTITLE_IMG_AND_TEXT; | |
1017 | ||
1018 | wxNode* pNode = mTabs.First(); | |
1019 | ||
1020 | while( pNode ) | |
1021 | { | |
1022 | twTabInfo& tab = *((twTabInfo*)(pNode->Data())); | |
1023 | ||
1024 | wxWindowDC dc(this); | |
1025 | ||
1026 | long w,h; | |
1027 | ||
1028 | // set select default font of the window into it's device context | |
1029 | dc.SetFont( GetLabelingFont() ); | |
1030 | dc.GetTextExtent(tab.mText, &w, &h ); | |
1031 | ||
1032 | tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) + | |
1033 | tab.ImgWidth() + mTitleHorizGap*2; | |
1034 | ||
1035 | tab.mDims.y = mTitleHeight; | |
1036 | ||
1037 | pNode = pNode->Next(); | |
1038 | } | |
1039 | ||
1040 | // disable title-bar scroller if there's nowhere to scroll to | |
1041 | ||
1042 | mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 ); | |
1043 | } | |
1044 | ||
1045 | // event handlers | |
1046 | ||
1047 | void wxPaggedWindow::OnPaint( wxPaintEvent& event ) | |
1048 | { | |
1049 | wxPaintDC dc(this); | |
1050 | DrawDecorations( dc ); | |
1051 | } | |
1052 | ||
1053 | void wxPaggedWindow::OnSize ( wxSizeEvent& event ) | |
1054 | { | |
1055 | wxTabbedWindow::OnSize(event); | |
1056 | } | |
1057 | ||
1058 | void wxPaggedWindow::OnLButtonDown( wxMouseEvent& event ) | |
1059 | { | |
1060 | if ( mCursorChanged ) | |
1061 | { | |
1062 | mIsDragged = TRUE; | |
1063 | mDagOrigin = event.m_x; | |
1064 | ||
1065 | mOriginalTitleRowLen = mAdjustableTitleRowLen; | |
1066 | ||
1067 | CaptureMouse(); | |
1068 | } | |
1069 | else | |
1070 | { | |
1071 | wxTabbedWindow::OnLButtonDown( event ); | |
1072 | } | |
1073 | } | |
1074 | ||
1075 | void wxPaggedWindow::OnLButtonUp( wxMouseEvent& event ) | |
1076 | { | |
1077 | if ( mIsDragged ) | |
1078 | { | |
1079 | mIsDragged = FALSE; | |
1080 | mCursorChanged = FALSE; | |
1081 | SetCursor( mNormalCursor ); | |
1082 | ||
1083 | ReleaseMouse(); | |
1084 | } | |
1085 | } | |
1086 | ||
1087 | void wxPaggedWindow::OnMouseMove( wxMouseEvent& event ) | |
1088 | { | |
1089 | int width, height; | |
1090 | GetClientSize( &width, &height ); | |
1091 | ||
1092 | if ( !mIsDragged ) | |
1093 | { | |
1094 | int y = height - mVertGap - BORDER_SZ - mTitleHeight; | |
1095 | int x = mTitleRowStart + mTitleRowLen - 6; | |
1096 | ||
1097 | if ( event.m_x >= x && event.m_y >= y && | |
1098 | event.m_x < x + 6 && | |
1099 | event.m_y < y + mTitleHeight | |
1100 | ) | |
1101 | { | |
1102 | if ( !mCursorChanged ) | |
1103 | { | |
1104 | SetCursor( mResizeCursor ); | |
1105 | ||
1106 | mCursorChanged = TRUE; | |
1107 | } | |
1108 | } | |
1109 | else | |
1110 | if ( mCursorChanged ) | |
1111 | { | |
1112 | SetCursor( mNormalCursor ); | |
1113 | ||
1114 | mCursorChanged = FALSE; | |
1115 | } | |
1116 | } | |
1117 | else | |
1118 | if ( mIsDragged ) | |
1119 | { | |
1120 | mAdjustableTitleRowLen = mOriginalTitleRowLen + ( event.m_x - mDagOrigin ); | |
1121 | ||
1122 | // FOR NOW:: fixed | |
1123 | if ( mAdjustableTitleRowLen < 6 ) mAdjustableTitleRowLen = 6; | |
1124 | ||
1125 | wxWindowDC dc(this); | |
1126 | DrawDecorations( dc ); | |
1127 | ||
1128 | RecalcLayout(FALSE); | |
1129 | ||
1130 | //Refresh(); | |
1131 | } | |
1132 | } | |
1133 | ||
1134 | void wxPaggedWindow::OnScroll( wxScrollEvent& event ) | |
1135 | { | |
1136 | int cmd = event.m_commandInt; | |
1137 | ||
1138 | wxScrollBar* pSender = (wxScrollBar*)event.GetEventObject(); | |
1139 | ||
1140 | if ( pSender == mpTabScroll ) | |
1141 | { | |
1142 | int maxLen = GetWholeTabRowLen(); | |
1143 | ||
1144 | int maxUnits = GetWholeTabRowLen() / 20; | |
1145 | ||
1146 | mCurentRowOfs = -event.GetPosition()*maxUnits; | |
1147 | ||
1148 | mFirstTitleGap = mTitleRowStart + mCurentRowOfs + mTabTrianGap; | |
1149 | ||
1150 | // let' it automatically disable itself if it's time | |
1151 | mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 ); | |
1152 | ||
1153 | // repaint title bars | |
1154 | wxWindowDC dc(this); | |
1155 | DrawDecorations( dc ); | |
1156 | } | |
1157 | else | |
1158 | if ( !mScrollEventInProgress ) | |
1159 | { | |
1160 | mScrollEventInProgress = TRUE; | |
1161 | ||
1162 | GetActiveTab()->GetEventHandler()->ProcessEvent( event ); | |
1163 | } | |
1164 | else | |
1165 | { | |
1166 | // event bounced back to us, from here we | |
1167 | // know that it has traveled the loop - thus it's processed! | |
1168 | ||
1169 | mScrollEventInProgress = FALSE; | |
1170 | } | |
1171 | } |