WINGs/wtabview.c

   1
   2 #include "WINGsP.h"
   3
   4
   5 typedef struct W_TabView {
   6     W_Class widgetClass;
   7     W_View *view;
   8
   9     struct W_TabViewItem **items;
  10     int itemCount;
  11     int maxItems;              /* size of items array, can be increased */
  12
  13     int selectedItem;
  14     int firstVisible;
  15
  16     int visibleTabs;
  17
  18     WMFont *font;
  19
  20     WMColor *lightGray;
  21     WMColor *tabColor;
  22
  23     WMTabViewDelegate *delegate;
  24
  25     short tabWidth;
  26     short tabHeight;
  27
  28     struct {
  29         WMReliefType relief:4;
  30         WMTitlePosition titlePosition:4;
  31         WMTabViewType type:2;
  32
  33         unsigned tabbed:1;
  34         unsigned dontFitAll:1;
  35     } flags;
  36 } TabView;
  37
  38
  39
  40
  41
  42
  43 #define DEFAULT_WIDTH   40
  44 #define DEFAULT_HEIGHT  40
  45
  46 #define NORMAL_SIDE_OFFSET 8
  47 #define BUTTONED_SIDE_OFFSET 20
  48
  49
  50 static void destroyTabView(TabView *tPtr);
  51 static void paintTabView(TabView *tPtr);
  52
  53
  54 static void W_SetTabViewItemParent(WMTabViewItem *item, WMTabView *parent);
  55
  56 static void W_DrawLabel(WMTabViewItem *item, Drawable d, WMRect rect);
  57
  58 static void W_UnmapTabViewItem(WMTabViewItem *item);
  59
  60 static void W_MapTabViewItem(WMTabViewItem *item);
  61
  62 static WMView *W_TabViewItemView(WMTabViewItem *item);
  63
  64 static void recalcTabWidth(TabView *tPtr);
  65
  66
  67 static void didResize(struct W_ViewDelegate*, WMView*);
  68
  69 static W_ViewDelegate delegate = {
  70     NULL,
  71         NULL,
  72         didResize,
  73         NULL,
  74         NULL
  75 };
  76
  77
  78
  79
  80 static void
  81 handleEvents(XEvent *event, void *data)
  82 {
  83     TabView *tPtr = (TabView*)data;
  84
  85     CHECK_CLASS(data, WC_TabView);
  86
  87     switch (event->type) {
  88      case Expose:
  89         if (event->xexpose.count!=0)
  90             break;
  91         paintTabView(tPtr);
  92         break;
  93
  94      case ButtonPress:
  95         {
  96             WMTabViewItem *item = WMTabViewItemAtPoint(tPtr,
  97                                                        event->xbutton.x,
  98                                                        event->xbutton.y);
  99             if (item) {
 100                 WMSelectTabViewItem(tPtr, item);
 101             } else if (tPtr->flags.dontFitAll) {
 102                 int redraw;
 103                 if (event->xbutton.x < BUTTONED_SIDE_OFFSET) {
 104                     if (tPtr->firstVisible > 0) {
 105                         redraw = 1;
 106                         tPtr->firstVisible--;
 107                     }
 108                 } else if (event->xbutton.x - BUTTONED_SIDE_OFFSET
 109                            > tPtr->visibleTabs*(tPtr->tabWidth-10)) {
 110
 111                     if (tPtr->firstVisible + tPtr->visibleTabs
 112                         < tPtr->itemCount) {
 113                         redraw = 1;
 114                         tPtr->firstVisible++;
 115                     }
 116                 }
 117
 118                 if (redraw) {
 119                     paintTabView(tPtr);
 120                 }
 121             }
 122         }
 123         break;
 124
 125      case DestroyNotify:
 126         destroyTabView(tPtr);
 127         break;
 128     }
 129 }
 130
 131
 132
 133 WMTabView*
 134 WMCreateTabView(WMWidget *parent)
 135 {
 136     TabView *tPtr;
 137     WMScreen *scr = WMWidgetScreen(parent);
 138
 139     tPtr = wmalloc(sizeof(TabView));
 140     memset(tPtr, 0, sizeof(TabView));
 141
 142     tPtr->widgetClass = WC_TabView;
 143
 144     tPtr->view = W_CreateView(W_VIEW(parent));
 145     if (!tPtr->view) {
 146         wfree(tPtr);
 147         return NULL;
 148     }
 149     tPtr->view->self = tPtr;
 150     tPtr->view->delegate = &delegate;
 151
 152     tPtr->lightGray = WMCreateRGBColor(scr, 0xd9d9, 0xd9d9, 0xd9d9, False);
 153     tPtr->tabColor = WMCreateRGBColor(scr, 0x8420, 0x8420, 0x8420, False);
 154
 155     tPtr->font = WMRetainFont(scr->normalFont);
 156
 157     WMCreateEventHandler(tPtr->view, ExposureMask|StructureNotifyMask
 158                          |ButtonPressMask, handleEvents, tPtr);
 159
 160     WMResizeWidget(tPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 161
 162     tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;
 163
 164     return tPtr;
 165 }
 166
 167
 168 void
 169 WMSetTabViewDelegate(WMTabView *tPtr, WMTabViewDelegate *delegate)
 170 {
 171     tPtr->delegate = delegate;
 172 }
 173
 174
 175 WMTabViewItem*
 176 WMAddTabViewItemWithView(WMTabView *tPtr, WMView *view, int identifier,
 177                          char *label)
 178 {
 179     WMTabViewItem *item;
 180
 181     item = WMCreateTabViewItemWithIdentifier(identifier);
 182     WMSetTabViewItemView(item, view);
 183     WMAddItemInTabView(tPtr, item);
 184     WMSetTabViewItemLabel(item, label);
 185
 186     return item;
 187 }
 188
 189
 190 void
 191 WMAddItemInTabView(WMTabView *tPtr, WMTabViewItem *item)
 192 {
 193     WMInsertItemInTabView(tPtr, tPtr->itemCount, item);
 194 }
 195
 196
 197 void
 198 WMInsertItemInTabView(WMTabView *tPtr, int index, WMTabViewItem *item)
 199 {
 200     wassertr(W_TabViewItemView(item) != NULL);
 201
 202     if (tPtr->maxItems == tPtr->itemCount) {
 203         WMTabViewItem **items;
 204
 205         items = wrealloc(tPtr->items,
 206                          sizeof(WMTabViewItem*) * (tPtr->maxItems + 10));
 207         memset(&items[tPtr->maxItems], 0, sizeof(WMTabViewItem*) * 10);
 208         tPtr->items = items;
 209         tPtr->maxItems += 10;
 210     }
 211
 212     if (index > tPtr->itemCount)
 213         index = tPtr->itemCount;
 214
 215     if (index == 0 && tPtr->items[0]) {
 216         W_UnmapTabViewItem(tPtr->items[0]);
 217     }
 218
 219     if (index < tPtr->itemCount) {
 220         memmove(&tPtr->items[index + 1], &tPtr->items[index],
 221                 tPtr->itemCount - index);
 222     }
 223
 224     tPtr->items[index] = item;
 225
 226     tPtr->itemCount++;
 227
 228     recalcTabWidth(tPtr);
 229
 230     W_SetTabViewItemParent(item, tPtr);
 231
 232     W_UnmapTabViewItem(item);
 233
 234     W_ReparentView(W_TabViewItemView(item), tPtr->view, 1,
 235                    tPtr->tabHeight + 1);
 236
 237     W_ResizeView(W_TabViewItemView(item), tPtr->view->size.width - 3,
 238                  tPtr->view->size.height - tPtr->tabHeight - 3);
 239
 240     if (index == 0) {
 241         W_MapTabViewItem(item);
 242     }
 243     if (tPtr->delegate && tPtr->delegate->didChangeNumberOfItems)
 244         (*tPtr->delegate->didChangeNumberOfItems)(tPtr->delegate, tPtr);
 245 }
 246
 247
 248 void
 249 WMRemoveTabViewItem(WMTabView *tPtr, WMTabViewItem *item)
 250 {
 251     int i;
 252
 253     for (i = 0; i < tPtr->itemCount; i++) {
 254         if (tPtr->items[i] == item) {
 255             if (i < tPtr->itemCount - 1)
 256                 memmove(&tPtr->items[i], &tPtr->items[i + 1],
 257                         tPtr->itemCount - i - 1);
 258             else
 259                 tPtr->items[i] = NULL;
 260
 261             W_SetTabViewItemParent(item, NULL);
 262
 263             tPtr->itemCount--;
 264             break;
 265         }
 266     }
 267     if (tPtr->delegate && tPtr->delegate->didChangeNumberOfItems)
 268         (*tPtr->delegate->didChangeNumberOfItems)(tPtr->delegate, tPtr);
 269 }
 270
 271
 272
 273 static Bool
 274 isInside(int x, int y, int width, int height, int px, int py)
 275 {
 276     if (py >= y + height - 3 && py <= y + height
 277         && px >= x + py - (y + height - 3)
 278         && px <= x + width - (py - (y + height - 3))) {
 279
 280         return True;
 281     }
 282     if (py >= y + 3 && py < y + height - 3
 283         && px >= x + 3 + ((y + 3) - py)*3/7
 284         && px <= x + width - 3 - ((y + 3) - py)*3/7) {
 285
 286         return True;
 287     }
 288     if (py >= y && py < y + 3
 289         && px >= x + 7 + py - y
 290         && px <= x + width - 7 - (py - y)) {
 291
 292         return True;
 293     }
 294     return False;
 295 }
 296
 297
 298 WMTabViewItem*
 299 WMTabViewItemAtPoint(WMTabView *tPtr, int x, int y)
 300 {
 301     int i;
 302     int offset;
 303     int count = tPtr->visibleTabs;
 304     int first = tPtr->firstVisible;
 305
 306     if (tPtr->flags.dontFitAll) {
 307         offset = BUTTONED_SIDE_OFFSET;
 308
 309         i = tPtr->selectedItem - tPtr->firstVisible;
 310         if (i >= 0 && i < tPtr->visibleTabs
 311             && isInside(offset + (tPtr->tabWidth-10)*i, 0, tPtr->tabWidth,
 312                         tPtr->tabHeight, x, y)) {
 313             return tPtr->items[tPtr->selectedItem];
 314         }
 315     } else {
 316         offset = NORMAL_SIDE_OFFSET;
 317
 318         i = tPtr->selectedItem;
 319         if (isInside(offset + (tPtr->tabWidth-10)*i, 0, tPtr->tabWidth,
 320                      tPtr->tabHeight, x, y)) {
 321             return tPtr->items[i];
 322         }
 323     }
 324
 325     for (i = 0; i < count; i++) {
 326         if (isInside(offset + (tPtr->tabWidth-10)*i, 0, tPtr->tabWidth,
 327                      tPtr->tabHeight, x, y)) {
 328             return tPtr->items[i+first];
 329         }
 330     }
 331     return NULL;
 332 }
 333
 334
 335 void
 336 WMSetTabViewType(WMTabView *tPtr, WMTabViewType type)
 337 {
 338     tPtr->flags.type = type;
 339 }
 340
 341 void
 342 WMSelectFirstTabViewItem(WMTabView *tPtr)
 343 {
 344     WMSelectTabViewItemAtIndex(tPtr, 0);
 345 }
 346
 347
 348 void
 349 WMSelectLastTabViewItem(WMTabView *tPtr)
 350 {
 351     WMSelectTabViewItemAtIndex(tPtr, tPtr->itemCount);
 352 }
 353
 354
 355 void
 356 WMSelectNextTabViewItem(WMTabView *tPtr)
 357 {
 358     WMSelectTabViewItemAtIndex(tPtr, tPtr->selectedItem + 1);
 359 }
 360
 361
 362 void
 363 WMSelectPreviousTabViewItem(WMTabView *tPtr)
 364 {
 365     WMSelectTabViewItemAtIndex(tPtr, tPtr->selectedItem - 1);
 366 }
 367
 368
 369 WMTabViewItem*
 370 WMGetSelectedTabViewItem(WMTabView *tPtr)
 371 {
 372     return tPtr->items[tPtr->selectedItem];
 373 }
 374
 375
 376 void
 377 WMSelectTabViewItem(WMTabView *tPtr, WMTabViewItem *item)
 378 {
 379     int i;
 380
 381     for (i = 0; i < tPtr->itemCount; i++) {
 382         if (tPtr->items[i] == item) {
 383             WMSelectTabViewItemAtIndex(tPtr, i);
 384             break;
 385         }
 386     }
 387 }
 388
 389
 390 void
 391 WMSelectTabViewItemAtIndex(WMTabView *tPtr, int index)
 392 {
 393     WMTabViewItem *item;
 394
 395     if (index == tPtr->selectedItem) {
 396         return;
 397     }
 398
 399     if (index < 0)
 400         index = 0;
 401     else if (index >= tPtr->itemCount)
 402         index = tPtr->itemCount - 1;
 403
 404     item = tPtr->items[tPtr->selectedItem];
 405
 406     if (tPtr->delegate && tPtr->delegate->shouldSelectItem)
 407         if (!(*tPtr->delegate->shouldSelectItem)(tPtr->delegate, tPtr,
 408                                                  tPtr->items[index]))
 409             return;
 410
 411     if (tPtr->delegate && tPtr->delegate->willSelectItem)
 412         (*tPtr->delegate->willSelectItem)(tPtr->delegate, tPtr,
 413                                           tPtr->items[index]);
 414
 415     W_UnmapTabViewItem(item);
 416
 417
 418     item = tPtr->items[index];
 419
 420     W_MapTabViewItem(item);
 421
 422     tPtr->selectedItem = index;
 423
 424     if (tPtr->delegate && tPtr->delegate->didSelectItem)
 425         (*tPtr->delegate->didSelectItem)(tPtr->delegate, tPtr,
 426                                          tPtr->items[index]);
 427
 428     paintTabView(tPtr);
 429 }
 430
 431
 432 static void
 433 recalcTabWidth(TabView *tPtr)
 434 {
 435     int i;
 436     int twidth = W_VIEW(tPtr)->size.width;
 437     int width;
 438
 439     tPtr->tabWidth = 0;
 440     for (i = 0; i < tPtr->itemCount; i++) {
 441         char *str = WMGetTabViewItemLabel(tPtr->items[i]);
 442
 443         if (str) {
 444             width = WMWidthOfString(tPtr->font, str, strlen(str));
 445             if (width > tPtr->tabWidth)
 446                 tPtr->tabWidth = width;
 447         }
 448     }
 449     tPtr->tabWidth += 30;
 450     if ((tPtr->tabWidth + 2) * tPtr->itemCount > twidth - 2*NORMAL_SIDE_OFFSET) {
 451         tPtr->flags.dontFitAll = 1;
 452         tPtr->firstVisible = 0;
 453         tPtr->visibleTabs = (twidth - 2*BUTTONED_SIDE_OFFSET) / (tPtr->tabWidth-10);
 454     } else {
 455         tPtr->flags.dontFitAll = 0;
 456         tPtr->firstVisible = 0;
 457         tPtr->visibleTabs = tPtr->itemCount;
 458     }
 459 }
 460
 461
 462 static void
 463 drawRelief(W_Screen *scr, Drawable d, int x, int y, unsigned int width,
 464            unsigned int height)
 465 {
 466     Display *dpy = scr->display;
 467     GC bgc = WMColorGC(scr->black);
 468     GC wgc = WMColorGC(scr->white);
 469     GC dgc = WMColorGC(scr->darkGray);
 470
 471     XDrawLine(dpy, d, wgc, x, y, x, y+height-1);
 472
 473     XDrawLine(dpy, d, bgc, x, y+height-1, x+width-1, y+height-1);
 474     XDrawLine(dpy, d, dgc, x+1, y+height-2, x+width-2, y+height-2);
 475
 476     XDrawLine(dpy, d, bgc, x+width-1, y, x+width-1, y+height-1);
 477     XDrawLine(dpy, d, dgc, x+width-2, y+1, x+width-2, y+height-2);
 478 }
 479
 480
 481 static void
 482 drawTab(TabView *tPtr, Drawable d, int x, int y,
 483         unsigned width, unsigned height, Bool selected)
 484 {
 485     WMScreen *scr = W_VIEW(tPtr)->screen;
 486     Display *dpy = scr->display;
 487     GC white = WMColorGC(selected ? scr->white : tPtr->lightGray);
 488     GC black = WMColorGC(scr->black);
 489     GC dark = WMColorGC(scr->darkGray);
 490     GC light = WMColorGC(scr->gray);
 491     XPoint trap[8];
 492
 493     trap[0].x = x + (selected ? 0 : 1);
 494     trap[0].y = y + height - (selected ? 0 : 1);
 495
 496     trap[1].x = x + 3;
 497     trap[1].y = y + height - 3;
 498
 499     trap[2].x = x + 10 - 3;
 500     trap[2].y = y + 3;
 501
 502     trap[3].x = x + 10;
 503     trap[3].y = y;
 504
 505     trap[4].x = x + width - 10;
 506     trap[4].y = y;
 507
 508     trap[5].x = x + width - 10 + 3;
 509     trap[5].y = y + 3;
 510
 511     trap[6].x = x + width - 3;
 512     trap[6].y = y + height - 3;
 513
 514     trap[7].x = x + width - (selected ? 0 : 1);
 515     trap[7].y = y + height - (selected ? 0 : 1);
 516
 517     XFillPolygon(dpy, d, selected ? light : WMColorGC(tPtr->tabColor), trap, 8,
 518                  Convex, CoordModeOrigin);
 519
 520     XDrawLine(dpy, d, white, trap[0].x, trap[0].y, trap[1].x, trap[1].y);
 521     XDrawLine(dpy, d, white, trap[1].x, trap[1].y, trap[2].x, trap[2].y);
 522     XDrawLine(dpy, d, white, trap[2].x, trap[2].y, trap[3].x, trap[3].y);
 523     XDrawLine(dpy, d, white, trap[3].x, trap[3].y, trap[4].x, trap[4].y);
 524     XDrawLine(dpy, d, dark, trap[4].x, trap[4].y, trap[5].x, trap[5].y);
 525     XDrawLine(dpy, d, black, trap[5].x, trap[5].y, trap[6].x, trap[6].y);
 526     XDrawLine(dpy, d, black, trap[6].x, trap[6].y, trap[7].x, trap[7].y);
 527
 528     XDrawLine(dpy, d, selected ? light : WMColorGC(scr->white),
 529               trap[0].x, trap[0].y, trap[7].x, trap[7].y);
 530 }
 531
 532
 533 static void
 534 paintDot(TabView *tPtr, Drawable d, int x, int y)
 535 {
 536     WMScreen *scr = W_VIEW(tPtr)->screen;
 537     Display *dpy = scr->display;
 538     GC white = WMColorGC(scr->white);
 539     GC black = WMColorGC(scr->black);
 540
 541     XFillRectangle(dpy, d, black, x, y, 2, 2);
 542     XDrawPoint(dpy, d, white, x, y);
 543 }
 544
 545
 546
 547 static void
 548 paintTabView(TabView *tPtr)
 549 {
 550     Pixmap buffer;
 551     WMScreen *scr = W_VIEW(tPtr)->screen;
 552     Display *dpy = scr->display;
 553     GC white = WMColorGC(scr->white);
 554     int i;
 555     WMRect rect;
 556
 557     if (tPtr->flags.type == WTTopTabsBevelBorder) {
 558         int count = tPtr->visibleTabs;
 559         int first = tPtr->firstVisible;
 560         int offs;
 561         int moreAtLeft;
 562         int moreAtRight;
 563         int selectedIsVisible;
 564
 565         buffer = XCreatePixmap(dpy, W_VIEW(tPtr)->window,
 566                                W_VIEW(tPtr)->size.width, tPtr->tabHeight,
 567                                W_VIEW(tPtr)->screen->depth);
 568
 569         XFillRectangle(dpy, buffer, WMColorGC(W_VIEW(tPtr)->backColor),
 570                        0, 0, W_VIEW(tPtr)->size.width, tPtr->tabHeight);
 571
 572         rect.pos.y = 2;
 573         if (tPtr->flags.dontFitAll) {
 574             rect.pos.x = 15 + BUTTONED_SIDE_OFFSET;
 575             offs = BUTTONED_SIDE_OFFSET;
 576             moreAtLeft = first > 0;
 577             moreAtRight = (first + count) < tPtr->itemCount;
 578             if (tPtr->selectedItem >= first
 579                 && tPtr->selectedItem < first + count)
 580                 selectedIsVisible = 1;
 581             else
 582                 selectedIsVisible = 0;
 583         } else {
 584             rect.pos.x = 15 + NORMAL_SIDE_OFFSET;
 585             offs = NORMAL_SIDE_OFFSET;
 586             moreAtLeft = 0;
 587             moreAtRight = 0;
 588             selectedIsVisible = 1;
 589         }
 590         rect.size.width = tPtr->tabWidth;
 591         rect.size.height = tPtr->tabHeight;
 592
 593         for (i = count - (moreAtRight ? 0 : 1);
 594              i >= (moreAtLeft ? -1 : 0); i--) {
 595             if (!selectedIsVisible || i != (tPtr->selectedItem-first)) {
 596                 drawTab(tPtr, buffer, offs + (rect.size.width-10)*i, 0,
 597                         rect.size.width, rect.size.height, False);
 598             }
 599         }
 600
 601         if (selectedIsVisible) {
 602             drawTab(tPtr, buffer,
 603                     offs + (rect.size.width-10) * (tPtr->selectedItem - first),
 604                     0, rect.size.width, rect.size.height, True);
 605
 606             XDrawLine(dpy, buffer, white, 0, tPtr->tabHeight - 1,
 607                       offs, tPtr->tabHeight - 1);
 608
 609             XDrawLine(dpy, buffer, white,
 610                       offs + 10 + (rect.size.width-10) * count,
 611                       tPtr->tabHeight - 1, W_VIEW(tPtr)->size.width - 1,
 612                       tPtr->tabHeight - 1);
 613         } else {
 614             XDrawLine(dpy, buffer, white, 0, tPtr->tabHeight - 1,
 615                       W_VIEW(tPtr)->size.width, tPtr->tabHeight - 1);
 616         }
 617
 618         for (i = 0; i < count; i++) {
 619             W_DrawLabel(tPtr->items[first+i], buffer, rect);
 620
 621             rect.pos.x += rect.size.width - 10;
 622         }
 623
 624         if (moreAtLeft) {
 625             paintDot(tPtr, buffer, 4, 10);
 626             paintDot(tPtr, buffer, 7, 10);
 627             paintDot(tPtr, buffer, 10, 10);
 628         }
 629         if (moreAtRight) {
 630             int x;
 631
 632             x = BUTTONED_SIDE_OFFSET - 5 + tPtr->visibleTabs * (tPtr->tabWidth - 10);
 633
 634             x = x + (W_VIEW(tPtr)->size.width - x)/2;
 635
 636             paintDot(tPtr, buffer, x + 5, 10);
 637             paintDot(tPtr, buffer, x + 8, 10);
 638             paintDot(tPtr, buffer, x + 11, 10);
 639         }
 640
 641         XCopyArea(dpy, buffer, W_VIEW(tPtr)->window, scr->copyGC, 0, 0,
 642                   W_VIEW(tPtr)->size.width, tPtr->tabHeight, 0, 0);
 643
 644         XFreePixmap(dpy, buffer);
 645     }
 646     switch (tPtr->flags.type) {
 647      case WTTopTabsBevelBorder:
 648         drawRelief(scr, W_VIEW(tPtr)->window, 0, tPtr->tabHeight - 1,
 649                    W_VIEW(tPtr)->size.width,
 650                    W_VIEW(tPtr)->size.height - tPtr->tabHeight + 1);
 651         break;
 652
 653      case WTNoTabsBevelBorder:
 654         W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
 655                      W_VIEW(tPtr)->size.height, WRRaised);
 656         break;
 657
 658      case WTNoTabsLineBorder:
 659         W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
 660                      W_VIEW(tPtr)->size.height, WRSimple);
 661         break;
 662
 663      case WTNoTabsNoBorder:
 664         break;
 665     }
 666 }
 667
 668
 669 static void
 670 rearrange(TabView *tPtr)
 671 {
 672     int i;
 673     int width, height;
 674
 675     recalcTabWidth(tPtr);
 676
 677     width = tPtr->view->size.width - 3;
 678     height = tPtr->view->size.height - tPtr->tabHeight - 3;
 679
 680     for (i = 0; i < tPtr->itemCount; i++) {
 681         W_ResizeView(W_TabViewItemView(tPtr->items[i]), width, height);
 682     }
 683     if (W_VIEW_MAPPED(tPtr->view) && W_VIEW_REALIZED(tPtr->view))
 684         paintTabView(tPtr);
 685 }
 686
 687
 688 static void
 689 didResize(struct W_ViewDelegate *deleg, WMView *view)
 690 {
 691     rearrange(view->self);
 692 }
 693
 694
 695 static void
 696 destroyTabView(TabView *tPtr)
 697 {
 698     int i;
 699
 700     for (i = 0; i < tPtr->itemCount; i++) {
 701         WMSetTabViewItemView(tPtr->items[i], NULL);
 702         WMDestroyTabViewItem(tPtr->items[i]);
 703     }
 704     wfree(tPtr->items);
 705
 706     WMReleaseColor(tPtr->lightGray);
 707     WMReleaseColor(tPtr->tabColor);
 708     WMReleaseFont(tPtr->font);
 709
 710     wfree(tPtr);
 711 }
 712
 713 /******************************************************************/
 714
 715
 716 typedef struct W_TabViewItem {
 717     WMTabView *tabView;
 718
 719     W_View *view;
 720
 721     char *label;
 722
 723     int identifier;
 724
 725     struct {
 726         unsigned visible:1;
 727     } flags;
 728 } TabViewItem;
 729
 730
 731 static void
 732 W_SetTabViewItemParent(WMTabViewItem *item, WMTabView *parent)
 733 {
 734     item->tabView = parent;
 735 }
 736
 737
 738 static void
 739 W_DrawLabel(WMTabViewItem *item, Drawable d, WMRect rect)
 740 {
 741     WMScreen *scr = W_VIEW(item->tabView)->screen;
 742
 743     if (!item->label)
 744         return;
 745
 746     WMDrawString(scr, d, WMColorGC(scr->black), item->tabView->font,
 747                  rect.pos.x, rect.pos.y, item->label, strlen(item->label));
 748 }
 749
 750
 751 static void
 752 W_UnmapTabViewItem(WMTabViewItem *item)
 753 {
 754     wassertr(item->view);
 755
 756     W_UnmapView(item->view);
 757
 758     item->flags.visible = 0;
 759 }
 760
 761
 762 static void
 763 W_MapTabViewItem(WMTabViewItem *item)
 764 {
 765     wassertr(item->view);
 766
 767     W_MapView(item->view);
 768     W_RaiseView(item->view);
 769
 770     item->flags.visible = 1;
 771 }
 772
 773
 774 static WMView*
 775 W_TabViewItemView(WMTabViewItem *item)
 776 {
 777     return item->view;
 778 }
 779
 780
 781 WMTabViewItem*
 782 WMCreateTabViewItemWithIdentifier(int identifier)
 783 {
 784     WMTabViewItem *item;
 785
 786     item = wmalloc(sizeof(WMTabViewItem));
 787     memset(item, 0, sizeof(WMTabViewItem));
 788
 789     item->identifier = identifier;
 790
 791     return item;
 792 }
 793
 794
 795 WMTabViewItem*
 796 WMCreateTabViewItem(int identifier, char *label)
 797 {
 798     WMTabViewItem *item;
 799
 800     item = wmalloc(sizeof(WMTabViewItem));
 801     memset(item, 0, sizeof(WMTabViewItem));
 802
 803     item->identifier = identifier;
 804     WMSetTabViewItemLabel(item, label);
 805
 806     return item;
 807 }
 808
 809
 810
 811 int
 812 WMGetTabViewItemIdentifier(WMTabViewItem *item)
 813 {
 814     return item->identifier;
 815 }
 816
 817
 818 void
 819 WMSetTabViewFont(WMTabView *tPtr, WMFont *font)
 820 {
 821     if (tPtr->font)
 822         WMReleaseFont(tPtr->font);
 823
 824     tPtr->font = WMRetainFont(font);
 825     tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;
 826     recalcTabWidth(tPtr);
 827 }
 828
 829
 830 void
 831 WMSetTabViewItemLabel(WMTabViewItem *item, char *label)
 832 {
 833     if (item->label)
 834         wfree(item->label);
 835
 836     item->label = wstrdup(label);
 837
 838     if (item->tabView)
 839         recalcTabWidth(item->tabView);
 840 }
 841
 842
 843 char*
 844 WMGetTabViewItemLabel(WMTabViewItem *item)
 845 {
 846     return item->label;
 847 }
 848
 849
 850 void
 851 WMSetTabViewItemView(WMTabViewItem *item, WMView *view)
 852 {
 853     item->view = view;
 854 }
 855
 856
 857 WMView*
 858 WMGetTabViewItemView(WMTabViewItem *item)
 859 {
 860     return item->view;
 861 }
 862
 863
 864 void
 865 WMDestroyTabViewItem(WMTabViewItem *item)
 866 {
 867     if (item->label)
 868         wfree(item->label);
 869
 870     if (item->view)
 871         W_DestroyView(item->view);
 872
 873     wfree(item);
 874 }