WINGs/wtabview.c

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