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