5 typedef struct W_TabView
{
9 struct W_TabViewItem
**items
;
11 int maxItems
; /* size of items array, can be increased */
23 WMTabViewDelegate
*delegate
;
28 WMReliefType relief
:4;
29 WMTitlePosition titlePosition
:4;
34 unsigned dontFitAll
:1;
36 unsigned uniformTabs
:1;
45 #define DEFAULT_WIDTH 40
46 #define DEFAULT_HEIGHT 40
48 #define NORMAL_SIDE_OFFSET 8
49 #define BUTTONED_SIDE_OFFSET 15
52 static void destroyTabView(TabView
*tPtr
);
53 static void paintTabView(TabView
*tPtr
);
56 static void W_SetTabViewItemParent(WMTabViewItem
*item
, WMTabView
*parent
);
58 static void W_DrawLabel(WMTabViewItem
*item
, Drawable d
, WMRect rect
,
61 static void W_UnmapTabViewItem(WMTabViewItem
*item
);
63 static void W_MapTabViewItem(WMTabViewItem
*item
);
65 static WMView
*W_TabViewItemView(WMTabViewItem
*item
);
67 static int W_TabViewItemTabWidth(WMTabViewItem
*item
);
69 static void W_SetTabViewItemTabWidth(WMTabViewItem
*item
, int width
);
72 static void recalcTabWidth(TabView
*tPtr
);
73 static void rearrange(TabView
*tPtr
);
75 static void didResize(struct W_ViewDelegate
*, WMView
*);
77 static W_ViewDelegate delegate
= {
87 positionOfTab(WMTabView
*tabView
, int tab
)
92 if (tab
< tabView
->firstVisible
)
95 if (tab
> tabView
->firstVisible
+ tabView
->visibleTabs
)
98 if (tabView
->flags
.dontFitAll
)
99 offs
= BUTTONED_SIDE_OFFSET
;
101 offs
= NORMAL_SIDE_OFFSET
;
103 for (i
= tabView
->firstVisible
; i
< tab
; i
++)
104 offs
+= W_TabViewItemTabWidth(tabView
->items
[i
]) - 10;
111 countVisibleTabs(TabView
*tPtr
, int first
)
117 width
= W_VIEW_WIDTH(tPtr
->view
) - 2 * NORMAL_SIDE_OFFSET
;
120 width
= W_VIEW_WIDTH(tPtr
->view
) - 2 * BUTTONED_SIDE_OFFSET
;
123 for (i
= first
; i
< tPtr
->itemCount
; i
++) {
124 width
-= W_TabViewItemTabWidth(tPtr
->items
[i
]) - 10;
135 handleEvents(XEvent
*event
, void *data
)
137 TabView
*tPtr
= (TabView
*)data
;
139 CHECK_CLASS(data
, WC_TabView
);
141 switch (event
->type
) {
143 if (event
->xexpose
.count
!=0)
149 if (tPtr
->flags
.enabled
) {
150 WMTabViewItem
*item
= WMTabViewItemAtPoint(tPtr
,
154 WMSelectTabViewItem(tPtr
, item
);
155 } else if (tPtr
->flags
.dontFitAll
) {
157 int lastVisible
= tPtr
->firstVisible
+tPtr
->visibleTabs
-1;
159 if (event
->xbutton
.x
< BUTTONED_SIDE_OFFSET
) {
160 if (tPtr
->firstVisible
> 0) {
162 tPtr
->firstVisible
--;
164 } else if (event
->xbutton
.x
> positionOfTab(tPtr
,lastVisible
)){
166 if (lastVisible
< tPtr
->itemCount
-1) {
168 tPtr
->firstVisible
++;
171 tPtr
->visibleTabs
= countVisibleTabs(tPtr
, tPtr
->firstVisible
);
180 destroyTabView(tPtr
);
188 WMCreateTabView(WMWidget
*parent
)
191 WMScreen
*scr
= WMWidgetScreen(parent
);
193 tPtr
= wmalloc(sizeof(TabView
));
194 memset(tPtr
, 0, sizeof(TabView
));
196 tPtr
->widgetClass
= WC_TabView
;
198 tPtr
->view
= W_CreateView(W_VIEW(parent
));
203 tPtr
->view
->self
= tPtr
;
204 tPtr
->view
->delegate
= &delegate
;
206 tPtr
->lightGray
= WMCreateRGBColor(scr
, 0xd9d9, 0xd9d9, 0xd9d9, False
);
207 tPtr
->tabColor
= WMCreateRGBColor(scr
, 0x8420, 0x8420, 0x8420, False
);
209 tPtr
->font
= WMRetainFont(scr
->normalFont
);
211 tPtr
->flags
.type
= WTTopTabsBevelBorder
;
212 tPtr
->flags
.bordered
= 1;
213 tPtr
->flags
.uniformTabs
= 0;
214 tPtr
->flags
.enabled
= 1;
216 WMCreateEventHandler(tPtr
->view
, ExposureMask
|StructureNotifyMask
217 |ButtonPressMask
, handleEvents
, tPtr
);
219 WMResizeWidget(tPtr
, DEFAULT_WIDTH
, DEFAULT_HEIGHT
);
221 tPtr
->tabHeight
= WMFontHeight(tPtr
->font
) + 3;
228 WMSetTabViewDelegate(WMTabView
*tPtr
, WMTabViewDelegate
*delegate
)
230 tPtr
->delegate
= delegate
;
235 WMAddTabViewItemWithView(WMTabView
*tPtr
, WMView
*view
, int identifier
,
240 item
= WMCreateTabViewItemWithIdentifier(identifier
);
241 WMSetTabViewItemView(item
, view
);
242 WMAddItemInTabView(tPtr
, item
);
243 WMSetTabViewItemLabel(item
, label
);
250 WMAddItemInTabView(WMTabView
*tPtr
, WMTabViewItem
*item
)
252 WMInsertItemInTabView(tPtr
, tPtr
->itemCount
, item
);
257 WMSetTabViewEnabled(WMTabView
*tPtr
, Bool flag
)
259 tPtr
->flags
.enabled
= flag
;
260 if (W_VIEW_REALIZED(tPtr
->view
))
266 WMInsertItemInTabView(WMTabView
*tPtr
, int index
, WMTabViewItem
*item
)
268 wassertr(W_TabViewItemView(item
) != NULL
);
270 if (tPtr
->maxItems
== tPtr
->itemCount
) {
271 WMTabViewItem
**items
;
273 items
= wrealloc(tPtr
->items
,
274 sizeof(WMTabViewItem
*) * (tPtr
->maxItems
+ 10));
275 memset(&items
[tPtr
->maxItems
], 0, sizeof(WMTabViewItem
*) * 10);
277 tPtr
->maxItems
+= 10;
280 if (index
> tPtr
->itemCount
)
281 index
= tPtr
->itemCount
;
283 if (index
== 0 && tPtr
->items
[0]) {
284 W_UnmapTabViewItem(tPtr
->items
[0]);
287 if (index
< tPtr
->itemCount
) {
288 memmove(tPtr
->items
+ index
+ 1, tPtr
->items
+ index
,
289 (tPtr
->itemCount
- index
) * sizeof(WMTabViewItem
*));
292 tPtr
->items
[index
] = item
;
296 recalcTabWidth(tPtr
);
298 W_SetTabViewItemParent(item
, tPtr
);
300 W_UnmapTabViewItem(item
);
302 if (tPtr
->flags
.bordered
) {
303 W_ReparentView(W_TabViewItemView(item
), tPtr
->view
, 1,
304 tPtr
->tabHeight
+ 1);
306 W_ResizeView(W_TabViewItemView(item
), tPtr
->view
->size
.width
- 3,
307 tPtr
->view
->size
.height
- tPtr
->tabHeight
- 3);
309 W_ReparentView(W_TabViewItemView(item
), tPtr
->view
, 0,
312 W_ResizeView(W_TabViewItemView(item
), tPtr
->view
->size
.width
,
313 tPtr
->view
->size
.height
- tPtr
->tabHeight
);
317 W_MapTabViewItem(item
);
319 if (tPtr
->delegate
&& tPtr
->delegate
->didChangeNumberOfItems
)
320 (*tPtr
->delegate
->didChangeNumberOfItems
)(tPtr
->delegate
, tPtr
);
322 if (W_VIEW_REALIZED(tPtr
->view
))
328 WMRemoveTabViewItem(WMTabView
*tPtr
, WMTabViewItem
*item
)
332 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
333 if (tPtr
->items
[i
] == item
) {
334 if (i
< tPtr
->itemCount
- 1)
335 memmove(&tPtr
->items
[i
], &tPtr
->items
[i
+ 1],
336 tPtr
->itemCount
- i
- 1);
338 tPtr
->items
[i
] = NULL
;
340 W_SetTabViewItemParent(item
, NULL
);
346 if (tPtr
->delegate
&& tPtr
->delegate
->didChangeNumberOfItems
)
347 (*tPtr
->delegate
->didChangeNumberOfItems
)(tPtr
->delegate
, tPtr
);
353 isInside(int x
, int y
, int width
, int height
, int px
, int py
)
355 if (py
>= y
+ height
- 3 && py
<= y
+ height
356 && px
>= x
+ py
- (y
+ height
- 3)
357 && px
<= x
+ width
- (py
- (y
+ height
- 3))) {
361 if (py
>= y
+ 3 && py
< y
+ height
- 3
362 && px
>= x
+ 3 + ((y
+ 3) - py
)*3/7
363 && px
<= x
+ width
- 3 - ((y
+ 3) - py
)*3/7) {
367 if (py
>= y
&& py
< y
+ 3
368 && px
>= x
+ 7 + py
- y
369 && px
<= x
+ width
- 7 - (py
- y
)) {
378 WMTabViewItemAtPoint(WMTabView
*tPtr
, int x
, int y
)
381 int count
= tPtr
->visibleTabs
;
382 int first
= tPtr
->firstVisible
;
384 if (tPtr
->flags
.dontFitAll
) {
385 i
= tPtr
->selectedItem
- tPtr
->firstVisible
;
386 if (i
>= 0 && i
< tPtr
->visibleTabs
387 && isInside(positionOfTab(tPtr
, tPtr
->selectedItem
), 0,
388 W_TabViewItemTabWidth(tPtr
->items
[tPtr
->selectedItem
]),
389 tPtr
->tabHeight
, x
, y
)) {
390 return tPtr
->items
[tPtr
->selectedItem
];
393 i
= tPtr
->selectedItem
;
394 if (isInside(positionOfTab(tPtr
, i
), 0,
395 W_TabViewItemTabWidth(tPtr
->items
[i
]),
396 tPtr
->tabHeight
, x
, y
)) {
397 return tPtr
->items
[i
];
401 for (i
= first
; i
< first
+ count
; i
++) {
404 pos
= positionOfTab(tPtr
, i
);
405 if (isInside(pos
, 0, W_TabViewItemTabWidth(tPtr
->items
[i
]),
406 tPtr
->tabHeight
, x
, y
)) {
407 return tPtr
->items
[i
];
415 WMSetTabViewType(WMTabView
*tPtr
, WMTabViewType type
)
417 tPtr
->flags
.type
= type
;
419 if (type
!= WTTopTabsBevelBorder
)
422 tPtr
->tabHeight
= WMFontHeight(tPtr
->font
) + 3;
424 if (type
== WTNoTabsNoBorder
)
425 tPtr
->flags
.bordered
= 0;
427 tPtr
->flags
.bordered
= 1;
433 WMSelectFirstTabViewItem(WMTabView
*tPtr
)
435 WMSelectTabViewItemAtIndex(tPtr
, 0);
440 WMSelectLastTabViewItem(WMTabView
*tPtr
)
442 WMSelectTabViewItemAtIndex(tPtr
, tPtr
->itemCount
);
447 WMSelectNextTabViewItem(WMTabView
*tPtr
)
449 WMSelectTabViewItemAtIndex(tPtr
, tPtr
->selectedItem
+ 1);
454 WMSelectPreviousTabViewItem(WMTabView
*tPtr
)
456 WMSelectTabViewItemAtIndex(tPtr
, tPtr
->selectedItem
- 1);
461 WMGetSelectedTabViewItem(WMTabView
*tPtr
)
463 return tPtr
->items
[tPtr
->selectedItem
];
468 WMSelectTabViewItem(WMTabView
*tPtr
, WMTabViewItem
*item
)
472 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
473 if (tPtr
->items
[i
] == item
) {
474 WMSelectTabViewItemAtIndex(tPtr
, i
);
482 WMSelectTabViewItemAtIndex(WMTabView
*tPtr
, int index
)
486 if (index
== tPtr
->selectedItem
) {
492 else if (index
>= tPtr
->itemCount
)
493 index
= tPtr
->itemCount
- 1;
495 item
= tPtr
->items
[tPtr
->selectedItem
];
497 if (tPtr
->delegate
&& tPtr
->delegate
->shouldSelectItem
)
498 if (!(*tPtr
->delegate
->shouldSelectItem
)(tPtr
->delegate
, tPtr
,
502 if (tPtr
->delegate
&& tPtr
->delegate
->willSelectItem
)
503 (*tPtr
->delegate
->willSelectItem
)(tPtr
->delegate
, tPtr
,
506 W_UnmapTabViewItem(item
);
509 item
= tPtr
->items
[index
];
511 W_MapTabViewItem(item
);
513 tPtr
->selectedItem
= index
;
515 if (tPtr
->delegate
&& tPtr
->delegate
->didSelectItem
)
516 (*tPtr
->delegate
->didSelectItem
)(tPtr
->delegate
, tPtr
,
525 recalcTabWidth(TabView
*tPtr
)
528 /*int twidth = W_VIEW(tPtr)->size.width;*/
531 if (tPtr
->flags
.uniformTabs
) {
536 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
537 char *str
= WMGetTabViewItemLabel(tPtr
->items
[i
]);
540 width
= WMWidthOfString(tPtr
->font
, str
, strlen(str
));
541 if (width
> tabWidth
)
546 tabWidth
= tabWidth
+ 30;
548 for (i
= 0; i
< tPtr
->itemCount
; i
++)
549 W_SetTabViewItemTabWidth(tPtr
->items
[i
], tabWidth
);
551 tPtr
->firstVisible
= 0;
552 tPtr
->visibleTabs
= countVisibleTabs(tPtr
, -1);
553 if (tPtr
->visibleTabs
< tPtr
->itemCount
)
554 tPtr
->flags
.dontFitAll
= 1;
556 tPtr
->flags
.dontFitAll
= 0;
558 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
559 char *str
= WMGetTabViewItemLabel(tPtr
->items
[i
]);
563 width
= WMWidthOfString(tPtr
->font
, str
, strlen(str
)) + 30;
565 W_SetTabViewItemTabWidth(tPtr
->items
[i
], width
);
568 if (countVisibleTabs(tPtr
, -1) < tPtr
->itemCount
) {
569 tPtr
->flags
.dontFitAll
= 1;
570 tPtr
->firstVisible
= 0;
571 tPtr
->visibleTabs
= countVisibleTabs(tPtr
, tPtr
->firstVisible
);
573 tPtr
->flags
.dontFitAll
= 0;
574 tPtr
->firstVisible
= 0;
575 tPtr
->visibleTabs
= tPtr
->itemCount
;
582 drawRelief(W_Screen
*scr
, Drawable d
, int x
, int y
, unsigned int width
,
585 Display
*dpy
= scr
->display
;
586 GC bgc
= WMColorGC(scr
->black
);
587 GC wgc
= WMColorGC(scr
->white
);
588 GC dgc
= WMColorGC(scr
->darkGray
);
590 XDrawLine(dpy
, d
, wgc
, x
, y
, x
, y
+height
-1);
592 XDrawLine(dpy
, d
, bgc
, x
, y
+height
-1, x
+width
-1, y
+height
-1);
593 XDrawLine(dpy
, d
, dgc
, x
+1, y
+height
-2, x
+width
-2, y
+height
-2);
595 XDrawLine(dpy
, d
, bgc
, x
+width
-1, y
, x
+width
-1, y
+height
-1);
596 XDrawLine(dpy
, d
, dgc
, x
+width
-2, y
+1, x
+width
-2, y
+height
-2);
601 drawTab(TabView
*tPtr
, Drawable d
, int x
, int y
,
602 unsigned width
, unsigned height
, Bool selected
)
604 WMScreen
*scr
= W_VIEW(tPtr
)->screen
;
605 Display
*dpy
= scr
->display
;
606 GC white
= WMColorGC(selected
? scr
->white
: tPtr
->lightGray
);
607 GC black
= WMColorGC(scr
->black
);
608 GC dark
= WMColorGC(scr
->darkGray
);
609 GC light
= WMColorGC(scr
->gray
);
612 trap
[0].x
= x
+ (selected
? 0 : 1);
613 trap
[0].y
= y
+ height
- (selected
? 0 : 1);
616 trap
[1].y
= y
+ height
- 3;
618 trap
[2].x
= x
+ 10 - 3;
624 trap
[4].x
= x
+ width
- 10;
627 trap
[5].x
= x
+ width
- 10 + 3;
630 trap
[6].x
= x
+ width
- 3;
631 trap
[6].y
= y
+ height
- 3;
633 trap
[7].x
= x
+ width
- (selected
? 0 : 1);
634 trap
[7].y
= y
+ height
- (selected
? 0 : 1);
636 XFillPolygon(dpy
, d
, selected
? light
: WMColorGC(tPtr
->tabColor
), trap
, 8,
637 Convex
, CoordModeOrigin
);
639 XDrawLine(dpy
, d
, white
, trap
[0].x
, trap
[0].y
, trap
[1].x
, trap
[1].y
);
640 XDrawLine(dpy
, d
, white
, trap
[1].x
, trap
[1].y
, trap
[2].x
, trap
[2].y
);
641 XDrawLine(dpy
, d
, white
, trap
[2].x
, trap
[2].y
, trap
[3].x
, trap
[3].y
);
642 XDrawLine(dpy
, d
, white
, trap
[3].x
, trap
[3].y
, trap
[4].x
, trap
[4].y
);
643 XDrawLine(dpy
, d
, dark
, trap
[4].x
, trap
[4].y
, trap
[5].x
, trap
[5].y
);
644 XDrawLine(dpy
, d
, black
, trap
[5].x
, trap
[5].y
, trap
[6].x
, trap
[6].y
);
645 XDrawLine(dpy
, d
, black
, trap
[6].x
, trap
[6].y
, trap
[7].x
, trap
[7].y
);
647 XDrawLine(dpy
, d
, selected
? light
: WMColorGC(scr
->white
),
648 trap
[0].x
, trap
[0].y
, trap
[7].x
, trap
[7].y
);
653 paintDot(TabView
*tPtr
, Drawable d
, int x
, int y
)
655 WMScreen
*scr
= W_VIEW(tPtr
)->screen
;
656 Display
*dpy
= scr
->display
;
657 GC white
= WMColorGC(scr
->white
);
658 GC black
= WMColorGC(scr
->black
);
660 XFillRectangle(dpy
, d
, black
, x
, y
, 2, 2);
661 XDrawPoint(dpy
, d
, white
, x
, y
);
667 paintTabView(TabView
*tPtr
)
670 WMScreen
*scr
= W_VIEW(tPtr
)->screen
;
671 Display
*dpy
= scr
->display
;
672 GC white
= WMColorGC(scr
->white
);
675 if (tPtr
->flags
.type
== WTTopTabsBevelBorder
) {
676 int count
= tPtr
->visibleTabs
;
677 int first
= tPtr
->firstVisible
;
680 int selectedIsVisible
;
685 theight
= tPtr
->tabHeight
;
687 buffer
= XCreatePixmap(dpy
, W_VIEW(tPtr
)->window
,
688 W_VIEW(tPtr
)->size
.width
, theight
,
689 W_VIEW(tPtr
)->screen
->depth
);
691 XFillRectangle(dpy
, buffer
, WMColorGC(W_VIEW(tPtr
)->backColor
),
692 0, 0, W_VIEW(tPtr
)->size
.width
, tPtr
->tabHeight
);
694 if (tPtr
->flags
.dontFitAll
) {
695 moreAtLeft
= first
> 0;
696 moreAtRight
= (first
+ count
) < tPtr
->itemCount
;
697 if (tPtr
->selectedItem
>= first
698 && tPtr
->selectedItem
< first
+ count
)
699 selectedIsVisible
= 1;
701 selectedIsVisible
= 0;
705 selectedIsVisible
= 1;
709 drawTab(tPtr
, buffer
, positionOfTab(tPtr
, first
+count
), 0,
710 W_VIEW_WIDTH(tPtr
->view
), theight
, False
);
712 for (i
= first
+ count
-1; i
>= first
; i
--) {
713 if (!selectedIsVisible
|| i
!= tPtr
->selectedItem
) {
714 twidth
= W_TabViewItemTabWidth(tPtr
->items
[i
]);
716 drawTab(tPtr
, buffer
, positionOfTab(tPtr
, i
), 0,
717 twidth
, theight
, False
);
721 drawTab(tPtr
, buffer
, positionOfTab(tPtr
, 0)-2*BUTTONED_SIDE_OFFSET
,
722 0, BUTTONED_SIDE_OFFSET
*4, theight
, False
);
725 if (selectedIsVisible
) {
726 int idx
= tPtr
->selectedItem
;
728 drawTab(tPtr
, buffer
, positionOfTab(tPtr
, idx
),
729 0, W_TabViewItemTabWidth(tPtr
->items
[idx
]),
732 XDrawLine(dpy
, buffer
, white
, 0, theight
- 1,
733 positionOfTab(tPtr
, idx
), theight
- 1);
735 XDrawLine(dpy
, buffer
, white
,
736 positionOfTab(tPtr
, idx
) + W_TabViewItemTabWidth(tPtr
->items
[idx
]),
737 tPtr
->tabHeight
- 1, W_VIEW_WIDTH(tPtr
->view
) - 1,
738 tPtr
->tabHeight
- 1);
740 XDrawLine(dpy
, buffer
, white
, 0, theight
- 1,
741 W_VIEW_WIDTH(tPtr
->view
), theight
- 1);
744 for (i
= 0; i
< count
; i
++) {
747 rect
.pos
.x
= 15 + positionOfTab(tPtr
, first
+i
);
749 rect
.size
.width
= W_TabViewItemTabWidth(tPtr
->items
[first
+i
]);
750 rect
.size
.height
= theight
;
751 W_DrawLabel(tPtr
->items
[first
+i
], buffer
, rect
,
752 tPtr
->flags
.enabled
);
756 paintDot(tPtr
, buffer
, 4, 10);
757 paintDot(tPtr
, buffer
, 7, 10);
758 paintDot(tPtr
, buffer
, 10, 10);
763 x
= positionOfTab(tPtr
, tPtr
->firstVisible
+ tPtr
->visibleTabs
);
765 x
= x
+ (W_VIEW_WIDTH(tPtr
->view
) - x
)/2;
766 paintDot(tPtr
, buffer
, x
+ 5, 10);
767 paintDot(tPtr
, buffer
, x
+ 8, 10);
768 paintDot(tPtr
, buffer
, x
+ 11, 10);
771 XCopyArea(dpy
, buffer
, W_VIEW(tPtr
)->window
, scr
->copyGC
, 0, 0,
772 W_VIEW_WIDTH(tPtr
->view
), theight
, 0, 0);
774 XFreePixmap(dpy
, buffer
);
776 switch (tPtr
->flags
.type
) {
777 case WTTopTabsBevelBorder
:
778 drawRelief(scr
, W_VIEW(tPtr
)->window
, 0, tPtr
->tabHeight
- 1,
779 W_VIEW(tPtr
)->size
.width
,
780 W_VIEW(tPtr
)->size
.height
- tPtr
->tabHeight
+ 1);
783 case WTNoTabsBevelBorder
:
784 W_DrawRelief(scr
, W_VIEW(tPtr
)->window
, 0, 0, W_VIEW(tPtr
)->size
.width
,
785 W_VIEW(tPtr
)->size
.height
, WRRaised
);
788 case WTNoTabsLineBorder
:
789 W_DrawRelief(scr
, W_VIEW(tPtr
)->window
, 0, 0, W_VIEW(tPtr
)->size
.width
,
790 W_VIEW(tPtr
)->size
.height
, WRSimple
);
793 case WTNoTabsNoBorder
:
800 rearrange(TabView
*tPtr
)
804 int bordered
= tPtr
->flags
.bordered
;
806 recalcTabWidth(tPtr
);
808 width
= tPtr
->view
->size
.width
- (bordered
? 3 : 0);
809 height
= tPtr
->view
->size
.height
- tPtr
->tabHeight
- (bordered
? 3 : 0);
811 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
812 W_MoveView(W_TabViewItemView(tPtr
->items
[i
]),
813 1*bordered
, tPtr
->tabHeight
+ 1*bordered
);
814 W_ResizeView(W_TabViewItemView(tPtr
->items
[i
]), width
, height
);
816 if (W_VIEW_MAPPED(tPtr
->view
) && W_VIEW_REALIZED(tPtr
->view
))
822 didResize(struct W_ViewDelegate
*deleg
, WMView
*view
)
824 rearrange(view
->self
);
829 destroyTabView(TabView
*tPtr
)
833 for (i
= 0; i
< tPtr
->itemCount
; i
++) {
834 WMSetTabViewItemView(tPtr
->items
[i
], NULL
);
835 WMDestroyTabViewItem(tPtr
->items
[i
]);
839 WMReleaseColor(tPtr
->lightGray
);
840 WMReleaseColor(tPtr
->tabColor
);
841 WMReleaseFont(tPtr
->font
);
846 /******************************************************************/
849 typedef struct W_TabViewItem
{
866 W_SetTabViewItemParent(WMTabViewItem
*item
, WMTabView
*parent
)
868 item
->tabView
= parent
;
873 W_DrawLabel(WMTabViewItem
*item
, Drawable d
, WMRect rect
, Bool enabled
)
875 WMScreen
*scr
= W_VIEW(item
->tabView
)->screen
;
880 WMDrawString(scr
, d
, WMColorGC(enabled
? scr
->black
: scr
->darkGray
),
881 item
->tabView
->font
, rect
.pos
.x
, rect
.pos
.y
,
882 item
->label
, strlen(item
->label
));
887 W_UnmapTabViewItem(WMTabViewItem
*item
)
889 wassertr(item
->view
);
891 W_UnmapView(item
->view
);
893 item
->flags
.visible
= 0;
898 W_MapTabViewItem(WMTabViewItem
*item
)
900 wassertr(item
->view
);
902 W_MapView(item
->view
);
903 W_RaiseView(item
->view
);
905 item
->flags
.visible
= 1;
910 W_TabViewItemView(WMTabViewItem
*item
)
917 W_TabViewItemTabWidth(WMTabViewItem
*item
)
919 return item
->tabWidth
;
924 W_SetTabViewItemTabWidth(WMTabViewItem
*item
, int width
)
926 item
->tabWidth
= width
;
931 WMCreateTabViewItemWithIdentifier(int identifier
)
935 item
= wmalloc(sizeof(WMTabViewItem
));
936 memset(item
, 0, sizeof(WMTabViewItem
));
938 item
->identifier
= identifier
;
945 WMCreateTabViewItem(int identifier
, char *label
)
949 item
= wmalloc(sizeof(WMTabViewItem
));
950 memset(item
, 0, sizeof(WMTabViewItem
));
952 item
->identifier
= identifier
;
953 WMSetTabViewItemLabel(item
, label
);
961 WMGetTabViewItemIdentifier(WMTabViewItem
*item
)
963 return item
->identifier
;
968 WMSetTabViewFont(WMTabView
*tPtr
, WMFont
*font
)
971 WMReleaseFont(tPtr
->font
);
973 tPtr
->font
= WMRetainFont(font
);
974 tPtr
->tabHeight
= WMFontHeight(tPtr
->font
) + 3;
975 recalcTabWidth(tPtr
);
980 WMSetTabViewItemLabel(WMTabViewItem
*item
, char *label
)
986 item
->label
= wstrdup(label
);
991 recalcTabWidth(item
->tabView
);
996 WMGetTabViewItemLabel(WMTabViewItem
*item
)
1003 WMSetTabViewItemView(WMTabViewItem
*item
, WMView
*view
)
1010 WMGetTabViewItemView(WMTabViewItem
*item
)
1017 WMDestroyTabViewItem(WMTabViewItem
*item
)
1023 W_DestroyView(item
->view
);