]> git.saurik.com Git - wxWidgets.git/blob - src/generic/tabg.cpp
added possibility to throw different objects and crash directly from the main frame...
[wxWidgets.git] / src / generic / tabg.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: tabg.cpp
3 // Purpose: Generic tabbed dialogs
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
13 #pragma implementation "tabg.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 #if wxUSE_TAB_DIALOG
24
25 #ifndef WX_PRECOMP
26 #include "wx/settings.h"
27 #include "wx/intl.h"
28 #include "wx/dcclient.h"
29 #endif
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <stdarg.h>
34
35 #include "wx/math.h"
36 #include "wx/tab.h"
37 #include "wx/listimpl.cpp"
38
39 WX_DEFINE_LIST(wxTabLayerList);
40
41 // not defined: use old, square tab implementation (fills in tabs)
42 // defined: use new, rounded tab implementation (doesn't colour in tabs)
43 // #define wxUSE_NEW_METHOD
44
45 IMPLEMENT_DYNAMIC_CLASS(wxTabControl, wxObject)
46
47 // IMPLEMENT_DYNAMIC_CLASS(wxTabLayer, wxList)
48
49 wxTabControl::wxTabControl(wxTabView *v)
50 {
51 m_view = v;
52 m_isSelected = false;
53 m_offsetX = 0;
54 m_offsetY = 0;
55 m_width = 0;
56 m_height = 0;
57 m_id = 0;
58 m_rowPosition = 0;
59 m_colPosition = 0;
60 }
61
62 wxTabControl::~wxTabControl(void)
63 {
64 }
65
66 void wxTabControl::OnDraw(wxDC& dc, bool lastInRow)
67 {
68 // Old, but in some ways better (drawing opaque tabs)
69 #ifndef wxUSE_NEW_METHOD
70 if (!m_view)
71 return;
72
73 // Top-left of tab view area
74 int viewX = m_view->GetViewRect().x;
75 int viewY = m_view->GetViewRect().y;
76
77 // Top-left of tab control
78 int tabX = GetX() + viewX;
79 int tabY = GetY() + viewY;
80 int tabHeightInc = 0;
81 if (m_isSelected)
82 {
83 tabHeightInc = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
84 tabY -= tabHeightInc;
85 }
86
87 dc.SetPen(*wxTRANSPARENT_PEN);
88
89 // Draw grey background
90 if (m_view->GetTabStyle() & wxTAB_STYLE_COLOUR_INTERIOR)
91 {
92 dc.SetBrush(*m_view->GetBackgroundBrush());
93
94 // Add 1 because the pen is transparent. Under Motif, may be different.
95 #ifdef __WXMOTIF__
96 dc.DrawRectangle(tabX, tabY, (GetWidth()+1), (GetHeight() + tabHeightInc));
97 #else
98 dc.DrawRectangle(tabX, tabY, (GetWidth()+1), (GetHeight() + 1 + tabHeightInc));
99 #endif
100 }
101
102 // Draw highlight and shadow
103 dc.SetPen(*m_view->GetHighlightPen());
104
105 // Calculate the top of the tab beneath. It's the height of the tab, MINUS
106 // a bit if the tab below happens to be selected. Check.
107 wxTabControl *tabBeneath = NULL;
108 int subtractThis = 0;
109 if (GetColPosition() > 0)
110 tabBeneath = m_view->FindTabControlForPosition(GetColPosition() - 1, GetRowPosition());
111 if (tabBeneath && tabBeneath->IsSelected())
112 subtractThis = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
113
114 // Vertical highlight: if first tab, draw to bottom of view
115 if (tabX == m_view->GetViewRect().x && (m_view->GetTabStyle() & wxTAB_STYLE_DRAW_BOX))
116 dc.DrawLine(tabX, tabY, tabX, (m_view->GetViewRect().y + m_view->GetViewRect().height));
117 else if (tabX == m_view->GetViewRect().x)
118 // Not box drawing, just to top of view.
119 dc.DrawLine(tabX, tabY, tabX, (m_view->GetViewRect().y));
120 else
121 dc.DrawLine(tabX, tabY, tabX, (tabY + GetHeight() + tabHeightInc - subtractThis));
122
123 dc.DrawLine(tabX, tabY, (tabX + GetWidth()), tabY);
124 dc.SetPen(*m_view->GetShadowPen());
125
126 // Test if we're outside the right-hand edge of the view area
127 if (((tabX + GetWidth()) >= m_view->GetViewRect().x + m_view->GetViewRect().width) && (m_view->GetTabStyle() & wxTAB_STYLE_DRAW_BOX))
128 {
129 int bottomY = m_view->GetViewRect().y + m_view->GetViewRect().height + GetY() + m_view->GetTabHeight() + m_view->GetTopMargin();
130 // Add a tab height since we wish to draw to the bottom of the view.
131 dc.DrawLine((tabX + GetWidth()), tabY,
132 (tabX + GetWidth()), bottomY);
133
134 // Calculate the far-right of the view, since we don't wish to
135 // draw inside that
136 int rightOfView = m_view->GetViewRect().x + m_view->GetViewRect().width + 1;
137
138 // Draw the horizontal bit to connect to the view rectangle
139 dc.DrawLine((wxMax((tabX + GetWidth() - m_view->GetHorizontalTabOffset()), rightOfView)), (bottomY-1),
140 (tabX + GetWidth()), (bottomY-1));
141
142 // Draw black line to emphasize shadow
143 dc.SetPen(*wxBLACK_PEN);
144 dc.DrawLine((tabX + GetWidth() + 1), (tabY+1),
145 (tabX + GetWidth() + 1), bottomY);
146
147 // Draw the horizontal bit to connect to the view rectangle
148 dc.DrawLine((wxMax((tabX + GetWidth() - m_view->GetHorizontalTabOffset()), rightOfView)), (bottomY),
149 (tabX + GetWidth() + 1), (bottomY));
150 }
151 else
152 {
153 if (lastInRow)
154 {
155 // 25/5/97 UNLESS it's less than the max number of positions in this row
156
157 int topY = m_view->GetViewRect().y - m_view->GetTopMargin();
158
159 int maxPositions = ((wxTabLayer *)m_view->GetLayers().Item(0)->GetData())->GetCount();
160
161 // Only down to the bottom of the tab, not to the top of the view
162 if ( GetRowPosition() < (maxPositions - 1) )
163 topY = tabY + GetHeight() + tabHeightInc;
164
165 #ifdef __WXMOTIF__
166 topY -= 1;
167 #endif
168
169 // Shadow
170 dc.DrawLine((tabX + GetWidth()), tabY, (tabX + GetWidth()), topY);
171 // Draw black line to emphasize shadow
172 dc.SetPen(*wxBLACK_PEN);
173 dc.DrawLine((tabX + GetWidth() + 1), (tabY+1), (tabX + GetWidth() + 1),
174 topY);
175 }
176 else
177 {
178 // Calculate the top of the tab beneath. It's the height of the tab, MINUS
179 // a bit if the tab below (and next col along) happens to be selected. Check.
180 wxTabControl *tabBeneath = NULL;
181 int subtractThis = 0;
182 if (GetColPosition() > 0)
183 tabBeneath = m_view->FindTabControlForPosition(GetColPosition() - 1, GetRowPosition() + 1);
184 if (tabBeneath && tabBeneath->IsSelected())
185 subtractThis = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
186
187 #ifdef __WXMOTIF__
188 subtractThis += 1;
189 #endif
190
191 // Draw only to next tab down.
192 dc.DrawLine((tabX + GetWidth()), tabY,
193 (tabX + GetWidth()), (tabY + GetHeight() + tabHeightInc - subtractThis));
194
195 // Draw black line to emphasize shadow
196 dc.SetPen(*wxBLACK_PEN);
197 dc.DrawLine((tabX + GetWidth() + 1), (tabY+1), (tabX + GetWidth() + 1),
198 (tabY + GetHeight() + tabHeightInc - subtractThis));
199 }
200 }
201
202 // Draw centered text
203 int textY = tabY + m_view->GetVerticalTabTextSpacing() + tabHeightInc;
204
205 if (m_isSelected)
206 dc.SetFont(* m_view->GetSelectedTabFont());
207 else
208 dc.SetFont(* GetFont());
209
210 wxColour col(m_view->GetTextColour());
211 dc.SetTextForeground(col);
212 dc.SetBackgroundMode(wxTRANSPARENT);
213 long textWidth, textHeight;
214 dc.GetTextExtent(GetLabel(), &textWidth, &textHeight);
215
216 int textX = (int)(tabX + (GetWidth() - textWidth)/2.0);
217 if (textX < (tabX + 2))
218 textX = (tabX + 2);
219
220 dc.SetClippingRegion(tabX, tabY, GetWidth(), GetHeight());
221 dc.DrawText(GetLabel(), textX, textY);
222 dc.DestroyClippingRegion();
223
224 if (m_isSelected)
225 {
226 dc.SetPen(*m_view->GetHighlightPen());
227
228 // Draw white highlight from the tab's left side to the left hand edge of the view
229 dc.DrawLine(m_view->GetViewRect().x, (tabY + GetHeight() + tabHeightInc),
230 tabX, (tabY + GetHeight() + tabHeightInc));
231
232 // Draw white highlight from the tab's right side to the right hand edge of the view
233 dc.DrawLine((tabX + GetWidth()), (tabY + GetHeight() + tabHeightInc),
234 m_view->GetViewRect().x + m_view->GetViewRect().width, (tabY + GetHeight() + tabHeightInc));
235 }
236 #else
237 // New HEL version with rounder tabs
238
239 if (!m_view) return;
240
241 int tabInc = 0;
242 if (m_isSelected)
243 {
244 tabInc = m_view->GetTabSelectionHeight() - m_view->GetTabHeight();
245 }
246 int tabLeft = GetX() + m_view->GetViewRect().x;
247 int tabTop = GetY() + m_view->GetViewRect().y - tabInc;
248 int tabRight = tabLeft + m_view->GetTabWidth();
249 int left = m_view->GetViewRect().x;
250 int top = tabTop + m_view->GetTabHeight() + tabInc;
251 int right = left + m_view->GetViewRect().width;
252 int bottom = top + m_view->GetViewRect().height;
253
254 if (m_isSelected)
255 {
256 // TAB is selected - draw TAB and the View's full outline
257
258 dc.SetPen(*(m_view->GetHighlightPen()));
259 wxPoint pnts[10];
260 int n = 0;
261 pnts[n].x = left; pnts[n++].y = bottom;
262 pnts[n].x = left; pnts[n++].y = top;
263 pnts[n].x = tabLeft; pnts[n++].y = top;
264 pnts[n].x = tabLeft; pnts[n++].y = tabTop + 2;
265 pnts[n].x = tabLeft + 2; pnts[n++].y = tabTop;
266 pnts[n].x = tabRight - 1; pnts[n++].y = tabTop;
267 dc.DrawLines(n, pnts);
268 if (!lastInRow)
269 {
270 dc.DrawLine(
271 (tabRight + 2),
272 top,
273 right,
274 top
275 );
276 }
277
278 dc.SetPen(*(m_view->GetShadowPen()));
279 dc.DrawLine(
280 tabRight,
281 tabTop + 2,
282 tabRight,
283 top
284 );
285 dc.DrawLine(
286 right,
287 top,
288 right,
289 bottom
290 );
291 dc.DrawLine(
292 right,
293 bottom,
294 left,
295 bottom
296 );
297
298 dc.SetPen(*wxBLACK_PEN);
299 dc.DrawPoint(
300 tabRight,
301 tabTop + 1
302 );
303 dc.DrawPoint(
304 tabRight + 1,
305 tabTop + 2
306 );
307 if (lastInRow)
308 {
309 dc.DrawLine(
310 tabRight + 1,
311 bottom,
312 tabRight + 1,
313 tabTop + 1
314 );
315 }
316 else
317 {
318 dc.DrawLine(
319 tabRight + 1,
320 tabTop + 2,
321 tabRight + 1,
322 top
323 );
324 dc.DrawLine(
325 right + 1,
326 top,
327 right + 1,
328 bottom + 1
329 );
330 }
331 dc.DrawLine(
332 right + 1,
333 bottom + 1,
334 left + 1,
335 bottom + 1
336 );
337 }
338 else
339 {
340 // TAB is not selected - just draw TAB outline and RH edge
341 // if the TAB is the last in the row
342
343 int maxPositions = ((wxTabLayer*)m_view->GetLayers().Item(0)->GetData())->GetCount();
344 wxTabControl* tabBelow = 0;
345 wxTabControl* tabBelowRight = 0;
346 if (GetColPosition() > 0)
347 {
348 tabBelow = m_view->FindTabControlForPosition(
349 GetColPosition() - 1,
350 GetRowPosition()
351 );
352 }
353 if (!lastInRow && GetColPosition() > 0)
354 {
355 tabBelowRight = m_view->FindTabControlForPosition(
356 GetColPosition() - 1,
357 GetRowPosition() + 1
358 );
359 }
360
361 float raisedTop = top - m_view->GetTabSelectionHeight() +
362 m_view->GetTabHeight();
363
364 dc.SetPen(*(m_view->GetHighlightPen()));
365 wxPoint pnts[10];
366 int n = 0;
367
368 pnts[n].x = tabLeft;
369
370 if (tabBelow && tabBelow->IsSelected())
371 {
372 pnts[n++].y = (long)raisedTop;
373 }
374 else
375 {
376 pnts[n++].y = top;
377 }
378 pnts[n].x = tabLeft; pnts[n++].y = tabTop + 2;
379 pnts[n].x = tabLeft + 2; pnts[n++].y = tabTop;
380 pnts[n].x = tabRight - 1; pnts[n++].y = tabTop;
381 dc.DrawLines(n, pnts);
382
383 dc.SetPen(*(m_view->GetShadowPen()));
384 if (GetRowPosition() >= maxPositions - 1)
385 {
386 dc.DrawLine(
387 tabRight,
388 (tabTop + 2),
389 tabRight,
390 bottom
391 );
392 dc.DrawLine(
393 tabRight,
394 bottom,
395 (tabRight - m_view->GetHorizontalTabOffset()),
396 bottom
397 );
398 }
399 else
400 {
401 if (tabBelowRight && tabBelowRight->IsSelected())
402 {
403 dc.DrawLine(
404 tabRight,
405 (long)raisedTop,
406 tabRight,
407 tabTop + 1
408 );
409 }
410 else
411 {
412 dc.DrawLine(
413 tabRight,
414 top - 1,
415 tabRight,
416 tabTop + 1
417 );
418 }
419 }
420
421 dc.SetPen(*wxBLACK_PEN);
422 dc.DrawPoint(
423 tabRight,
424 tabTop + 1
425 );
426 dc.DrawPoint(
427 tabRight + 1,
428 tabTop + 2
429 );
430 if (GetRowPosition() >= maxPositions - 1)
431 {
432 // draw right hand edge to bottom of view
433 dc.DrawLine(
434 tabRight + 1,
435 bottom + 1,
436 tabRight + 1,
437 tabTop + 2
438 );
439 dc.DrawLine(
440 tabRight + 1,
441 bottom + 1,
442 (tabRight - m_view->GetHorizontalTabOffset()),
443 bottom + 1
444 );
445 }
446 else
447 {
448 // draw right hand edge of TAB
449 if (tabBelowRight && tabBelowRight->IsSelected())
450 {
451 dc.DrawLine(
452 tabRight + 1,
453 (long)(raisedTop - 1),
454 tabRight + 1,
455 tabTop + 2
456 );
457 }
458 else
459 {
460 dc.DrawLine(
461 tabRight + 1,
462 top - 1,
463 tabRight + 1,
464 tabTop + 2
465 );
466 }
467 }
468 }
469
470 // Draw centered text
471 dc.SetPen(*wxBLACK_PEN);
472 if (m_isSelected)
473 {
474 dc.SetFont(*(m_view->GetSelectedTabFont()));
475 }
476 else
477 {
478 dc.SetFont(*(GetFont()));
479 }
480
481 wxColour col(m_view->GetTextColour());
482 dc.SetTextForeground(col);
483 dc.SetBackgroundMode(wxTRANSPARENT);
484 long textWidth, textHeight;
485 dc.GetTextExtent(GetLabel(), &textWidth, &textHeight);
486
487 float textX = (tabLeft + tabRight - textWidth) / 2;
488 float textY = (tabInc + tabTop + m_view->GetVerticalTabTextSpacing());
489
490 dc.DrawText(GetLabel(), (long)textX, (long)textY);
491 #endif
492 }
493
494 bool wxTabControl::HitTest(int x, int y) const
495 {
496 // Top-left of tab control
497 int tabX1 = GetX() + m_view->GetViewRect().x;
498 int tabY1 = GetY() + m_view->GetViewRect().y;
499
500 // Bottom-right
501 int tabX2 = tabX1 + GetWidth();
502 int tabY2 = tabY1 + GetHeight();
503
504 if (x >= tabX1 && y >= tabY1 && x <= tabX2 && y <= tabY2)
505 return true;
506 else
507 return false;
508 }
509
510 IMPLEMENT_DYNAMIC_CLASS(wxTabView, wxObject)
511
512 wxTabView::wxTabView(long style)
513 {
514 m_noTabs = 0;
515 m_tabStyle = style;
516 m_tabSelection = -1;
517 m_tabHeight = 20;
518 m_tabSelectionHeight = m_tabHeight + 2;
519 m_tabWidth = 80;
520 m_tabHorizontalOffset = 10;
521 m_tabHorizontalSpacing = 2;
522 m_tabVerticalTextSpacing = 3;
523 m_topMargin = 5;
524 m_tabViewRect.x = 20;
525 m_tabViewRect.y = 20;
526 m_tabViewRect.width = 300;
527 m_tabViewRect.x = 300;
528 m_highlightColour = *wxWHITE;
529 m_shadowColour = wxColour(128, 128, 128);
530 m_backgroundColour = *wxLIGHT_GREY;
531 m_textColour = *wxBLACK;
532 m_highlightPen = wxWHITE_PEN;
533 m_shadowPen = wxGREY_PEN;
534 m_backgroundPen = wxLIGHT_GREY_PEN;
535 m_backgroundBrush = wxLIGHT_GREY_BRUSH;
536 m_tabFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
537 m_tabSelectedFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
538 m_window = (wxWindow *) NULL;
539 }
540
541 wxTabView::~wxTabView()
542 {
543 ClearTabs(true);
544 }
545
546 // Automatically positions tabs
547 // TODO: this should just add the tab to a list, and then
548 // a layout function (e.g. Realize) should be called when all tabs have been added.
549 // The view rect could easily change as the view window is resized.
550 wxTabControl *wxTabView::AddTab(int id, const wxString& label, wxTabControl *existingTab)
551 {
552 // First, find which layer we should be adding to.
553 wxTabLayerList::compatibility_iterator node = m_layers.GetLast();
554 if (!node)
555 {
556 wxTabLayer *newLayer = new wxTabLayer;
557 node = m_layers.Append(newLayer);
558 }
559 // Check if adding another tab control would go off the
560 // right-hand edge of the layer.
561 wxTabLayer *tabLayer = (wxTabLayer *)node->GetData();
562 wxList::compatibility_iterator lastTabNode = tabLayer->GetLast();
563 if (lastTabNode)
564 {
565 wxTabControl *lastTab = (wxTabControl *)lastTabNode->GetData();
566 // Start another layer (row).
567 // Tricky choice: can't just check if will be overlapping the edge, because
568 // this happens anyway for 2nd and subsequent rows.
569 // Should check this for 1st row, and then subsequent rows should not exceed 1st
570 // in length.
571 if (((tabLayer == m_layers.GetFirst()->GetData()) && ((lastTab->GetX() + 2*lastTab->GetWidth() + GetHorizontalTabSpacing())
572 > GetViewRect().width)) ||
573 ((tabLayer != m_layers.GetFirst()->GetData()) && (tabLayer->GetCount() == ((wxTabLayer *)m_layers.GetFirst()->GetData())->GetCount())))
574 {
575 tabLayer = new wxTabLayer;
576 m_layers.Append(tabLayer);
577 lastTabNode = wxList::compatibility_iterator();
578 }
579 }
580 int layer = m_layers.GetCount() - 1;
581
582 wxTabControl *tabControl = existingTab;
583 if (!existingTab)
584 tabControl = OnCreateTabControl();
585 tabControl->SetRowPosition(tabLayer->GetCount());
586 tabControl->SetColPosition(layer);
587
588 wxTabControl *lastTab = (wxTabControl *) NULL;
589 if (lastTabNode)
590 lastTab = (wxTabControl *)lastTabNode->GetData();
591
592 // Top of new tab
593 int verticalOffset = (- GetTopMargin()) - ((layer+1)*GetTabHeight());
594 // Offset from view top-left
595 int horizontalOffset = 0;
596 if (!lastTab)
597 horizontalOffset = layer*GetHorizontalTabOffset();
598 else
599 horizontalOffset = lastTab->GetX() + GetTabWidth() + GetHorizontalTabSpacing();
600
601 tabControl->SetPosition(horizontalOffset, verticalOffset);
602 tabControl->SetSize(GetTabWidth(), GetTabHeight());
603 tabControl->SetId(id);
604 tabControl->SetLabel(label);
605 tabControl->SetFont(* GetTabFont());
606
607 tabLayer->Append(tabControl);
608 m_noTabs ++;
609
610 return tabControl;
611 }
612
613 // Remove the tab without deleting the window
614 bool wxTabView::RemoveTab(int id)
615 {
616 wxTabLayerList::compatibility_iterator layerNode = m_layers.GetFirst();
617 while (layerNode)
618 {
619 wxTabLayer *layer = (wxTabLayer *)layerNode->GetData();
620 wxList::compatibility_iterator tabNode = layer->GetFirst();
621 while (tabNode)
622 {
623 wxTabControl *tab = (wxTabControl *)tabNode->GetData();
624 if (tab->GetId() == id)
625 {
626 if (id == m_tabSelection)
627 m_tabSelection = -1;
628 delete tab;
629 layer->Erase(tabNode);
630 m_noTabs --;
631
632 // The layout has changed
633 LayoutTabs();
634 return true;
635 }
636 tabNode = tabNode->GetNext();
637 }
638 layerNode = layerNode->GetNext();
639 }
640 return false;
641 }
642
643 bool wxTabView::SetTabText(int id, const wxString& label)
644 {
645 wxTabControl* control = FindTabControlForId(id);
646 if (!control)
647 return false;
648 control->SetLabel(label);
649 return true;
650 }
651
652 wxString wxTabView::GetTabText(int id) const
653 {
654 wxTabControl* control = FindTabControlForId(id);
655 if (!control)
656 return wxEmptyString;
657 else
658 return control->GetLabel();
659 }
660
661 // Returns the total height of the tabs component -- this may be several
662 // times the height of a tab, if there are several tab layers (rows).
663 int wxTabView::GetTotalTabHeight()
664 {
665 int minY = 0;
666
667 wxTabLayerList::compatibility_iterator layerNode = m_layers.GetFirst();
668 while (layerNode)
669 {
670 wxTabLayer *layer = (wxTabLayer *)layerNode->GetData();
671 wxList::compatibility_iterator tabNode = layer->GetFirst();
672 while (tabNode)
673 {
674 wxTabControl *tab = (wxTabControl *)tabNode->GetData();
675
676 if (tab->GetY() < minY)
677 minY = tab->GetY();
678
679 tabNode = tabNode->GetNext();
680 }
681 layerNode = layerNode->GetNext();
682 }
683
684 return - minY;
685 }
686
687 void wxTabView::ClearTabs(bool deleteTabs)
688 {
689 wxTabLayerList::compatibility_iterator layerNode = m_layers.GetFirst();
690 while (layerNode)
691 {
692 wxTabLayer *layer = (wxTabLayer *)layerNode->GetData();
693 wxList::compatibility_iterator tabNode = layer->GetFirst();
694 while (tabNode)
695 {
696 wxTabControl *tab = (wxTabControl *)tabNode->GetData();
697 if (deleteTabs)
698 delete tab;
699 wxList::compatibility_iterator next = tabNode->GetNext();
700 layer->Erase(tabNode);
701 tabNode = next;
702 }
703 wxTabLayerList::compatibility_iterator nextLayerNode = layerNode->GetNext();
704 delete layer;
705 m_layers.Erase(layerNode);
706 layerNode = nextLayerNode;
707 }
708 m_noTabs = 0;
709 m_tabSelection = -1;
710 }
711
712
713 // Layout tabs (optional, e.g. if resizing window)
714 void wxTabView::LayoutTabs(void)
715 {
716 // Make a list of the tab controls, deleting the wxTabLayers.
717 wxList controls;
718
719 wxTabLayerList::compatibility_iterator layerNode = m_layers.GetFirst();
720 while (layerNode)
721 {
722 wxTabLayer *layer = (wxTabLayer *)layerNode->GetData();
723 wxList::compatibility_iterator tabNode = layer->GetFirst();
724 while (tabNode)
725 {
726 wxTabControl *tab = (wxTabControl *)tabNode->GetData();
727 controls.Append(tab);
728 wxList::compatibility_iterator next = tabNode->GetNext();
729 layer->Erase(tabNode);
730 tabNode = next;
731 }
732 wxTabLayerList::compatibility_iterator nextLayerNode = layerNode->GetNext();
733 delete layer;
734 m_layers.Erase(layerNode);
735 layerNode = nextLayerNode;
736 }
737
738 wxTabControl *lastTab = (wxTabControl *) NULL;
739
740 wxTabLayer *currentLayer = new wxTabLayer;
741 m_layers.Append(currentLayer);
742
743 wxList::compatibility_iterator node = controls.GetFirst();
744 while (node)
745 {
746 wxTabControl *tabControl = (wxTabControl *)node->GetData();
747 if (lastTab)
748 {
749 // Start another layer (row).
750 // Tricky choice: can't just check if will be overlapping the edge, because
751 // this happens anyway for 2nd and subsequent rows.
752 // Should check this for 1st row, and then subsequent rows should not exceed 1st
753 // in length.
754 if (((currentLayer == m_layers.GetFirst()->GetData()) && ((lastTab->GetX() + 2*lastTab->GetWidth() + GetHorizontalTabSpacing())
755 > GetViewRect().width)) ||
756 ((currentLayer != m_layers.GetFirst()->GetData()) && (currentLayer->GetCount() == ((wxTabLayer *)m_layers.GetFirst()->GetData())->GetCount())))
757 {
758 currentLayer = new wxTabLayer;
759 m_layers.Append(currentLayer);
760 lastTab = (wxTabControl *) NULL;
761 }
762 }
763
764 int layer = m_layers.GetCount() - 1;
765
766 tabControl->SetRowPosition(currentLayer->GetCount());
767 tabControl->SetColPosition(layer);
768
769 // Top of new tab
770 int verticalOffset = (- GetTopMargin()) - ((layer+1)*GetTabHeight());
771 // Offset from view top-left
772 int horizontalOffset = 0;
773 if (!lastTab)
774 horizontalOffset = layer*GetHorizontalTabOffset();
775 else
776 horizontalOffset = lastTab->GetX() + GetTabWidth() + GetHorizontalTabSpacing();
777
778 tabControl->SetPosition(horizontalOffset, verticalOffset);
779 tabControl->SetSize(GetTabWidth(), GetTabHeight());
780
781 currentLayer->Append(tabControl);
782 lastTab = tabControl;
783
784 node = node->GetNext();
785 }
786
787 // Move the selected tab to the bottom
788 wxTabControl *control = FindTabControlForId(m_tabSelection);
789 if (control)
790 MoveSelectionTab(control);
791
792 }
793
794 // Draw all tabs
795 void wxTabView::Draw(wxDC& dc)
796 {
797 // Don't draw anything if there are no tabs.
798 if (GetNumberOfTabs() == 0)
799 return;
800
801 // Draw top margin area (beneath tabs and above view area)
802 if (GetTabStyle() & wxTAB_STYLE_COLOUR_INTERIOR)
803 {
804 dc.SetPen(*wxTRANSPARENT_PEN);
805 dc.SetBrush(*GetBackgroundBrush());
806
807 // Add 1 because the pen is transparent. Under Motif, may be different.
808 dc.DrawRectangle(
809 m_tabViewRect.x,
810 (m_tabViewRect.y - m_topMargin),
811 (m_tabViewRect.width + 1),
812 (m_topMargin + 1)
813 );
814 }
815
816 // Draw layers in reverse order
817 wxTabLayerList::compatibility_iterator node = m_layers.GetLast();
818 while (node)
819 {
820 wxTabLayer *layer = (wxTabLayer *)node->GetData();
821 wxList::compatibility_iterator node2 = layer->GetFirst();
822 while (node2)
823 {
824 wxTabControl *control = (wxTabControl *)node2->GetData();
825 control->OnDraw(dc, (!node2->GetNext()));
826 node2 = node2->GetNext();
827 }
828
829 node = node->GetPrevious();
830 }
831
832
833 #ifndef wxUSE_NEW_METHOD
834 if (GetTabStyle() & wxTAB_STYLE_DRAW_BOX)
835 {
836 dc.SetPen(* GetShadowPen());
837
838 // Draw bottom line
839 dc.DrawLine(
840 (GetViewRect().x + 1),
841 (GetViewRect().y + GetViewRect().height),
842 (GetViewRect().x + GetViewRect().width + 1),
843 (GetViewRect().y + GetViewRect().height)
844 );
845
846 // Draw right line
847 dc.DrawLine(
848 (GetViewRect().x + GetViewRect().width),
849 (GetViewRect().y - GetTopMargin() + 1),
850 (GetViewRect().x + GetViewRect().width),
851 (GetViewRect().y + GetViewRect().height)
852 );
853
854 dc.SetPen(* wxBLACK_PEN);
855
856 // Draw bottom line
857 dc.DrawLine(
858 (GetViewRect().x),
859 (GetViewRect().y + GetViewRect().height + 1),
860 #if defined(__WXMOTIF__)
861 (GetViewRect().x + GetViewRect().width + 1),
862 #else
863 (GetViewRect().x + GetViewRect().width + 2),
864 #endif
865
866 (GetViewRect().y + GetViewRect().height + 1)
867 );
868
869 // Draw right line
870 dc.DrawLine(
871 (GetViewRect().x + GetViewRect().width + 1),
872 (GetViewRect().y - GetTopMargin()),
873 (GetViewRect().x + GetViewRect().width + 1),
874 (GetViewRect().y + GetViewRect().height + 1)
875 );
876 }
877 #endif
878 }
879
880 // Process mouse event, return false if we didn't process it
881 bool wxTabView::OnEvent(wxMouseEvent& event)
882 {
883 if (!event.LeftDown())
884 return false;
885
886 wxCoord x, y;
887 event.GetPosition(&x, &y);
888
889 wxTabControl *hitControl = (wxTabControl *) NULL;
890
891 wxTabLayerList::compatibility_iterator node = m_layers.GetFirst();
892 while (node)
893 {
894 wxTabLayer *layer = (wxTabLayer *)node->GetData();
895 wxList::compatibility_iterator node2 = layer->GetFirst();
896 while (node2)
897 {
898 wxTabControl *control = (wxTabControl *)node2->GetData();
899 if (control->HitTest((int)x, (int)y))
900 {
901 hitControl = control;
902 node = wxTabLayerList::compatibility_iterator();
903 node2 = wxList::compatibility_iterator();
904 }
905 else
906 node2 = node2->GetNext();
907 }
908
909 if (node)
910 node = node->GetNext();
911 }
912
913 if (!hitControl)
914 return false;
915
916 wxTabControl *currentTab = FindTabControlForId(m_tabSelection);
917
918 if (hitControl == currentTab)
919 return false;
920
921 ChangeTab(hitControl);
922
923 return true;
924 }
925
926 bool wxTabView::ChangeTab(wxTabControl *control)
927 {
928 wxTabControl *currentTab = FindTabControlForId(m_tabSelection);
929 int oldTab = -1;
930 if (currentTab)
931 oldTab = currentTab->GetId();
932
933 if (control == currentTab)
934 return true;
935
936 if (m_layers.GetCount() == 0)
937 return false;
938
939 if (!OnTabPreActivate(control->GetId(), oldTab))
940 return false;
941
942 // Move the tab to the bottom
943 MoveSelectionTab(control);
944
945 if (currentTab)
946 currentTab->SetSelected(false);
947
948 control->SetSelected(true);
949 m_tabSelection = control->GetId();
950
951 OnTabActivate(control->GetId(), oldTab);
952
953 // Leave window refresh for the implementing window
954
955 return true;
956 }
957
958 // Move the selected tab to the bottom layer, if necessary,
959 // without calling app activation code
960 bool wxTabView::MoveSelectionTab(wxTabControl *control)
961 {
962 if (m_layers.GetCount() == 0)
963 return false;
964
965 wxTabLayer *firstLayer = (wxTabLayer *)m_layers.GetFirst()->GetData();
966
967 // Find what column this tab is at, so we can swap with the one at the bottom.
968 // If we're on the bottom layer, then no need to swap.
969 if (!firstLayer->Member(control))
970 {
971 // Do a swap
972 int col = 0;
973 wxList::compatibility_iterator thisNode = FindTabNodeAndColumn(control, &col);
974 if (!thisNode)
975 return false;
976 wxList::compatibility_iterator otherNode = firstLayer->Item(col);
977 if (!otherNode)
978 return false;
979
980 // If this is already in the bottom layer, return now
981 if (otherNode == thisNode)
982 return true;
983
984 wxTabControl *otherTab = (wxTabControl *)otherNode->GetData();
985
986 // We now have pointers to the tab to be changed to,
987 // and the tab on the first layer. Swap tab structures and
988 // position details.
989
990 int thisX = control->GetX();
991 int thisY = control->GetY();
992 int thisColPos = control->GetColPosition();
993 int otherX = otherTab->GetX();
994 int otherY = otherTab->GetY();
995 int otherColPos = otherTab->GetColPosition();
996
997 control->SetPosition(otherX, otherY);
998 control->SetColPosition(otherColPos);
999 otherTab->SetPosition(thisX, thisY);
1000 otherTab->SetColPosition(thisColPos);
1001
1002 // Swap the data for the nodes
1003 thisNode->SetData(otherTab);
1004 otherNode->SetData(control);
1005 }
1006 return true;
1007 }
1008
1009 // Called when a tab is activated
1010 void wxTabView::OnTabActivate(int /*activateId*/, int /*deactivateId*/)
1011 {
1012 }
1013
1014 void wxTabView::SetHighlightColour(const wxColour& col)
1015 {
1016 m_highlightColour = col;
1017 m_highlightPen = wxThePenList->FindOrCreatePen(col, 1, wxSOLID);
1018 }
1019
1020 void wxTabView::SetShadowColour(const wxColour& col)
1021 {
1022 m_shadowColour = col;
1023 m_shadowPen = wxThePenList->FindOrCreatePen(col, 1, wxSOLID);
1024 }
1025
1026 void wxTabView::SetBackgroundColour(const wxColour& col)
1027 {
1028 m_backgroundColour = col;
1029 m_backgroundPen = wxThePenList->FindOrCreatePen(col, 1, wxSOLID);
1030 m_backgroundBrush = wxTheBrushList->FindOrCreateBrush(col, wxSOLID);
1031 }
1032
1033 void wxTabView::SetTabSelection(int sel, bool activateTool)
1034 {
1035 if ( sel==m_tabSelection )
1036 return;
1037
1038 int oldSel = m_tabSelection;
1039 wxTabControl *control = FindTabControlForId(sel);
1040 wxTabControl *oldControl = FindTabControlForId(m_tabSelection);
1041
1042 if (!OnTabPreActivate(sel, oldSel))
1043 return;
1044
1045 if (control)
1046 control->SetSelected((sel != -1)); // TODO ??
1047 else if (sel != -1)
1048 {
1049 wxFAIL_MSG(_("Could not find tab for id"));
1050 return;
1051 }
1052
1053 if (oldControl)
1054 oldControl->SetSelected(false);
1055
1056 m_tabSelection = sel;
1057
1058 if (control)
1059 MoveSelectionTab(control);
1060
1061 if (activateTool)
1062 OnTabActivate(sel, oldSel);
1063 }
1064
1065 // Find tab control for id
1066 wxTabControl *wxTabView::FindTabControlForId(int id) const
1067 {
1068 wxTabLayerList::compatibility_iterator node1 = m_layers.GetFirst();
1069 while (node1)
1070 {
1071 wxTabLayer *layer = (wxTabLayer *)node1->GetData();
1072 wxList::compatibility_iterator node2 = layer->GetFirst();
1073 while (node2)
1074 {
1075 wxTabControl *control = (wxTabControl *)node2->GetData();
1076 if (control->GetId() == id)
1077 return control;
1078 node2 = node2->GetNext();
1079 }
1080 node1 = node1->GetNext();
1081 }
1082 return (wxTabControl *) NULL;
1083 }
1084
1085 // Find tab control for layer, position (starting from zero)
1086 wxTabControl *wxTabView::FindTabControlForPosition(int layer, int position) const
1087 {
1088 wxTabLayerList::compatibility_iterator node1 = m_layers.Item(layer);
1089 if (!node1)
1090 return (wxTabControl *) NULL;
1091 wxTabLayer *tabLayer = (wxTabLayer *)node1->GetData();
1092 wxList::compatibility_iterator node2 = tabLayer->Item(position);
1093 if (!node2)
1094 return (wxTabControl *) NULL;
1095 return (wxTabControl *)node2->GetData();
1096 }
1097
1098 // Find the node and the column at which this control is positioned.
1099 wxList::compatibility_iterator wxTabView::FindTabNodeAndColumn(wxTabControl *control, int *col) const
1100 {
1101 wxTabLayerList::compatibility_iterator node1 = m_layers.GetFirst();
1102 while (node1)
1103 {
1104 wxTabLayer *layer = (wxTabLayer *)node1->GetData();
1105 int c = 0;
1106 wxList::compatibility_iterator node2 = layer->GetFirst();
1107 while (node2)
1108 {
1109 wxTabControl *cnt = (wxTabControl *)node2->GetData();
1110 if (cnt == control)
1111 {
1112 *col = c;
1113 return node2;
1114 }
1115 node2 = node2->GetNext();
1116 c ++;
1117 }
1118 node1 = node1->GetNext();
1119 }
1120 return wxList::compatibility_iterator();
1121 }
1122
1123 int wxTabView::CalculateTabWidth(int noTabs, bool adjustView)
1124 {
1125 m_tabWidth = (int)((m_tabViewRect.width - ((noTabs - 1)*GetHorizontalTabSpacing()))/noTabs);
1126 if (adjustView)
1127 {
1128 m_tabViewRect.width = noTabs*m_tabWidth + ((noTabs-1)*GetHorizontalTabSpacing());
1129 }
1130 return m_tabWidth;
1131 }
1132
1133 /*
1134 * wxTabbedDialog
1135 */
1136
1137 IMPLEMENT_CLASS(wxTabbedDialog, wxDialog)
1138
1139 BEGIN_EVENT_TABLE(wxTabbedDialog, wxDialog)
1140 EVT_CLOSE(wxTabbedDialog::OnCloseWindow)
1141 EVT_MOUSE_EVENTS(wxTabbedDialog::OnMouseEvent)
1142 EVT_PAINT(wxTabbedDialog::OnPaint)
1143 END_EVENT_TABLE()
1144
1145 wxTabbedDialog::wxTabbedDialog(wxWindow *parent, wxWindowID id,
1146 const wxString& title,
1147 const wxPoint& pos, const wxSize& size,
1148 long windowStyle, const wxString& name):
1149 wxDialog(parent, id, title, pos, size, windowStyle, name)
1150 {
1151 m_tabView = (wxTabView *) NULL;
1152 }
1153
1154 wxTabbedDialog::~wxTabbedDialog(void)
1155 {
1156 if (m_tabView)
1157 delete m_tabView;
1158 }
1159
1160 void wxTabbedDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event) )
1161 {
1162 Destroy();
1163 }
1164
1165 void wxTabbedDialog::OnMouseEvent(wxMouseEvent& event )
1166 {
1167 if (m_tabView)
1168 m_tabView->OnEvent(event);
1169 }
1170
1171 void wxTabbedDialog::OnPaint(wxPaintEvent& WXUNUSED(event) )
1172 {
1173 wxPaintDC dc(this);
1174 if (m_tabView)
1175 m_tabView->Draw(dc);
1176 }
1177
1178 /*
1179 * wxTabbedPanel
1180 */
1181
1182 IMPLEMENT_CLASS(wxTabbedPanel, wxPanel)
1183
1184 BEGIN_EVENT_TABLE(wxTabbedPanel, wxPanel)
1185 EVT_MOUSE_EVENTS(wxTabbedPanel::OnMouseEvent)
1186 EVT_PAINT(wxTabbedPanel::OnPaint)
1187 END_EVENT_TABLE()
1188
1189 wxTabbedPanel::wxTabbedPanel(wxWindow *parent, wxWindowID id, const wxPoint& pos,
1190 const wxSize& size, long windowStyle, const wxString& name):
1191 wxPanel(parent, id, pos, size, windowStyle, name)
1192 {
1193 m_tabView = (wxTabView *) NULL;
1194 }
1195
1196 wxTabbedPanel::~wxTabbedPanel(void)
1197 {
1198 delete m_tabView;
1199 }
1200
1201 void wxTabbedPanel::OnMouseEvent(wxMouseEvent& event)
1202 {
1203 if (m_tabView)
1204 m_tabView->OnEvent(event);
1205 }
1206
1207 void wxTabbedPanel::OnPaint(wxPaintEvent& WXUNUSED(event) )
1208 {
1209 wxPaintDC dc(this);
1210 if (m_tabView)
1211 m_tabView->Draw(dc);
1212 }
1213
1214 /*
1215 * wxPanelTabView
1216 */
1217
1218 IMPLEMENT_CLASS(wxPanelTabView, wxTabView)
1219
1220 wxPanelTabView::wxPanelTabView(wxPanel *pan, long style)
1221 : wxTabView(style)
1222 {
1223 m_panel = pan;
1224 m_currentWindow = (wxWindow *) NULL;
1225
1226 if (m_panel->IsKindOf(CLASSINFO(wxTabbedDialog)))
1227 ((wxTabbedDialog *)m_panel)->SetTabView(this);
1228 else if (m_panel->IsKindOf(CLASSINFO(wxTabbedPanel)))
1229 ((wxTabbedPanel *)m_panel)->SetTabView(this);
1230
1231 SetWindow(m_panel);
1232 }
1233
1234 wxPanelTabView::~wxPanelTabView(void)
1235 {
1236 ClearWindows(true);
1237 }
1238
1239 // Called when a tab is activated
1240 void wxPanelTabView::OnTabActivate(int activateId, int deactivateId)
1241 {
1242 if (!m_panel)
1243 return;
1244
1245 wxWindow *oldWindow = ((deactivateId == -1) ? 0 : GetTabWindow(deactivateId));
1246 wxWindow *newWindow = GetTabWindow(activateId);
1247
1248 if (oldWindow)
1249 oldWindow->Show(false);
1250 if (newWindow)
1251 newWindow->Show(true);
1252
1253 m_panel->Refresh();
1254 }
1255
1256
1257 void wxPanelTabView::AddTabWindow(int id, wxWindow *window)
1258 {
1259 wxASSERT(m_tabWindows.find(id) == m_tabWindows.end());
1260 m_tabWindows[id] = window;
1261 window->Show(false);
1262 }
1263
1264 wxWindow *wxPanelTabView::GetTabWindow(int id) const
1265 {
1266 wxIntToWindowHashMap::const_iterator it = m_tabWindows.find(id);
1267 return it == m_tabWindows.end() ? NULL : it->second;
1268 }
1269
1270 void wxPanelTabView::ClearWindows(bool deleteWindows)
1271 {
1272 if (deleteWindows)
1273 WX_CLEAR_HASH_MAP(wxIntToWindowHashMap, m_tabWindows);
1274 m_tabWindows.clear();
1275 }
1276
1277 void wxPanelTabView::ShowWindowForTab(int id)
1278 {
1279 wxWindow *newWindow = GetTabWindow(id);
1280 if (newWindow == m_currentWindow)
1281 return;
1282 if (m_currentWindow)
1283 m_currentWindow->Show(false);
1284 newWindow->Show(true);
1285 newWindow->Refresh();
1286 }
1287
1288 #endif // wxUSE_TAB_DIALOG