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 */
  12
  13     int selectedItem;
  14
  15     WMFont *font;
  16
  17     WMColor *lightGray;
  18     WMColor *tabColor;
  19
  20     WMTabViewDelegate *delegate;
  21
  22     short tabWidth;
  23     short tabHeight;
  24
  25     struct {
  26         WMReliefType relief:4;
  27         WMTitlePosition titlePosition:4;
  28         WMTabViewTypes type:2;
  29
  30         unsigned tabbed:1;
  31         unsigned allowsTruncatedLabels:1;
  32     } flags;
  33 } TabView;
  34
  35
  36
  37 #define DEFAULT_WIDTH   40
  38 #define DEFAULT_HEIGHT  40
  39
  40
  41 static void destroyTabView(TabView *tPtr);
  42 static void paintTabView(TabView *tPtr);
  43
  44
  45 static void W_SetTabViewItemParent(WMTabViewItem *item, WMTabView *parent);
  46
  47 static void W_DrawLabel(WMTabViewItem *item, Drawable d, WMRect rect);
  48
  49 static void W_UnmapTabViewItem(WMTabViewItem *item);
  50
  51 static void W_MapTabViewItem(WMTabViewItem *item);
  52
  53 static WMView *W_TabViewItemView(WMTabViewItem *item);
  54
  55 static void recalcTabWidth(TabView *tPtr);
  56
  57
  58 static void
  59 handleEvents(XEvent *event, void *data)
  60 {
  61     TabView *tPtr = (TabView*)data;
  62
  63     CHECK_CLASS(data, WC_TabView);
  64
  65     switch (event->type) {
  66      case Expose:
  67         if (event->xexpose.count!=0)
  68             break;
  69         paintTabView(tPtr);
  70         break;
  71
  72      case ButtonPress:
  73         {
  74             WMTabViewItem *item = WMTabViewItemAtPoint(tPtr,
  75                                                        event->xbutton.x,
  76                                                        event->xbutton.y);
  77             if (item) {
  78                 WMSelectTabViewItem(tPtr, item);
  79             }
  80         }
  81         break;
  82
  83      case DestroyNotify:
  84         destroyTabView(tPtr);
  85         break;
  86     }
  87 }
  88
  89
  90
  91 WMTabView*
  92 WMCreateTabView(WMWidget *parent)
  93 {
  94     TabView *tPtr;
  95     WMScreen *scr = WMWidgetScreen(parent);
  96
  97     tPtr = wmalloc(sizeof(TabView));
  98     memset(tPtr, 0, sizeof(TabView));
  99
 100     tPtr->widgetClass = WC_TabView;
 101
 102     tPtr->view = W_CreateView(W_VIEW(parent));
 103     if (!tPtr->view) {
 104         free(tPtr);
 105         return NULL;
 106     }
 107     tPtr->view->self = tPtr;
 108
 109     tPtr->lightGray = WMCreateRGBColor(scr, 0xd9d9, 0xd9d9, 0xd9d9, False);
 110     tPtr->tabColor = WMCreateRGBColor(scr, 0x8420, 0x8420, 0x8420, False);
 111
 112     tPtr->font = WMRetainFont(scr->normalFont);
 113
 114     WMCreateEventHandler(tPtr->view, ExposureMask|StructureNotifyMask
 115                          |ButtonPressMask, handleEvents, tPtr);
 116
 117     WMResizeWidget(tPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 118
 119     tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;
 120
 121     return tPtr;
 122 }
 123
 124
 125 void
 126 WMSetTabViewDelegate(WMTabView *tPtr, WMTabViewDelegate *delegate)
 127 {
 128     tPtr->delegate = delegate;
 129 }
 130
 131
 132 void
 133 WMAddItemInTabView(WMTabView *tPtr, WMTabViewItem *item)
 134 {
 135     WMInsertItemInTabView(tPtr, tPtr->itemCount, item);
 136 }
 137
 138
 139 void
 140 WMInsertItemInTabView(WMTabView *tPtr, int index, WMTabViewItem *item)
 141 {
 142     wassertr(W_TabViewItemView(item) != NULL);
 143
 144     if (tPtr->maxItems == tPtr->itemCount) {
 145         WMTabViewItem **items;
 146
 147         items = wrealloc(tPtr->items,
 148                          sizeof(WMTabViewItem*) * (tPtr->maxItems + 10));
 149         if (!items) {
 150             wwarning("out of memory allocating memory for tabview");
 151             return;
 152         }
 153         memset(&items[tPtr->maxItems], 0, sizeof(WMTabViewItem*) * 10);
 154         tPtr->items = items;
 155         tPtr->maxItems += 10;
 156     }
 157
 158     if (index > tPtr->itemCount)
 159         index = tPtr->itemCount;
 160
 161     if (index == 0 && tPtr->items[0]) {
 162         W_UnmapTabViewItem(tPtr->items[0]);
 163     }
 164
 165     if (index < tPtr->itemCount) {
 166         memmove(&tPtr->items[index + 1], &tPtr->items[index],
 167                 tPtr->itemCount - index);
 168     }
 169
 170     tPtr->items[index] = item;
 171
 172     tPtr->itemCount++;
 173
 174     recalcTabWidth(tPtr);
 175
 176     W_SetTabViewItemParent(item, tPtr);
 177
 178     W_UnmapTabViewItem(item);
 179
 180     W_ReparentView(W_TabViewItemView(item), tPtr->view, 1,
 181                    tPtr->tabHeight + 1);
 182
 183     W_ResizeView(W_TabViewItemView(item), tPtr->view->size.width - 3,
 184                  tPtr->view->size.height - tPtr->tabHeight - 3);
 185
 186     if (index == 0) {
 187         W_MapTabViewItem(item);
 188     }
 189     if (tPtr->delegate && tPtr->delegate->didChangeNumberOfItems)
 190         (*tPtr->delegate->didChangeNumberOfItems)(tPtr->delegate, tPtr);
 191 }
 192
 193
 194 void
 195 WMRemoveTabViewItem(WMTabView *tPtr, WMTabViewItem *item)
 196 {
 197     int i;
 198
 199     for (i = 0; i < tPtr->itemCount; i++) {
 200         if (tPtr->items[i] == item) {
 201             if (i < tPtr->itemCount - 1)
 202                 memmove(&tPtr->items[i], &tPtr->items[i + 1],
 203                         tPtr->itemCount - i - 1);
 204             else
 205                 tPtr->items[i] = NULL;
 206
 207             W_SetTabViewItemParent(item, NULL);
 208
 209             tPtr->itemCount--;
 210             break;
 211         }
 212     }
 213     if (tPtr->delegate && tPtr->delegate->didChangeNumberOfItems)
 214         (*tPtr->delegate->didChangeNumberOfItems)(tPtr->delegate, tPtr);
 215 }
 216
 217
 218
 219 static Bool
 220 isInside(int x, int y, int width, int height, int px, int py)
 221 {
 222     if (py >= y + height - 3 && py <= y + height
 223         && px >= x + py - (y + height - 3)
 224         && px <= x + width - (py - (y + height - 3))) {
 225
 226         return True;
 227     }
 228     if (py >= y + 3 && py < y + height - 3
 229         && px >= x + 3 + ((y + 3) - py)*3/7
 230         && px <= x + width - 3 - ((y + 3) - py)*3/7) {
 231
 232         return True;
 233     }
 234     if (py >= y && py < y + 3
 235         && px >= x + 7 + py - y
 236         && px <= x + width - 7 - (py - y)) {
 237
 238         return True;
 239     }
 240     return False;
 241 }
 242
 243
 244 WMTabViewItem*
 245 WMTabViewItemAtPoint(WMTabView *tPtr, int x, int y)
 246 {
 247     int i;
 248
 249     i = tPtr->selectedItem;
 250     if (isInside(8 + (tPtr->tabWidth-10)*i, 0, tPtr->tabWidth,
 251                  tPtr->tabHeight, x, y)) {
 252         return tPtr->items[i];
 253     }
 254
 255     for (i = 0; i < tPtr->itemCount; i++) {
 256         if (isInside(8 + (tPtr->tabWidth-10)*i, 0, tPtr->tabWidth,
 257                      tPtr->tabHeight, x, y)) {
 258             return tPtr->items[i];
 259         }
 260     }
 261     return NULL;
 262 }
 263
 264
 265 void
 266 WMSelectFirstTabViewItem(WMTabView *tPtr)
 267 {
 268     WMSelectTabViewItemAtIndex(tPtr, 0);
 269 }
 270
 271
 272 void
 273 WMSelectLastTabViewItem(WMTabView *tPtr)
 274 {
 275     WMSelectTabViewItemAtIndex(tPtr, tPtr->itemCount);
 276 }
 277
 278
 279 void
 280 WMSelectNextTabViewItem(WMTabView *tPtr)
 281 {
 282     WMSelectTabViewItemAtIndex(tPtr, tPtr->selectedItem + 1);
 283 }
 284
 285
 286 void
 287 WMSelectPreviousTabViewItem(WMTabView *tPtr)
 288 {
 289     WMSelectTabViewItemAtIndex(tPtr, tPtr->selectedItem - 1);
 290 }
 291
 292
 293 WMTabViewItem*
 294 WMGetSelectedTabViewItem(WMTabView *tPtr)
 295 {
 296     return tPtr->items[tPtr->selectedItem];
 297 }
 298
 299
 300 void
 301 WMSelectTabViewItem(WMTabView *tPtr, WMTabViewItem *item)
 302 {
 303     int i;
 304
 305     for (i = 0; i < tPtr->itemCount; i++) {
 306         if (tPtr->items[i] == item) {
 307             WMSelectTabViewItemAtIndex(tPtr, i);
 308             break;
 309         }
 310     }
 311 }
 312
 313
 314 void
 315 WMSelectTabViewItemAtIndex(WMTabView *tPtr, int index)
 316 {
 317     WMTabViewItem *item;
 318
 319     if (index == tPtr->selectedItem)
 320         return;
 321
 322     if (index < 0)
 323         index = 0;
 324     else if (index >= tPtr->itemCount)
 325         index = tPtr->itemCount - 1;
 326
 327     item = tPtr->items[tPtr->selectedItem];
 328
 329     if (tPtr->delegate && tPtr->delegate->shouldSelectItem)
 330         if (!(*tPtr->delegate->shouldSelectItem)(tPtr->delegate, tPtr,
 331                                                  tPtr->items[index]))
 332             return;
 333
 334     if (tPtr->delegate && tPtr->delegate->willSelectItem)
 335         (*tPtr->delegate->willSelectItem)(tPtr->delegate, tPtr,
 336                                           tPtr->items[index]);
 337
 338     W_UnmapTabViewItem(item);
 339
 340
 341     item = tPtr->items[index];
 342
 343     W_MapTabViewItem(item);
 344
 345     tPtr->selectedItem = index;
 346
 347     if (tPtr->delegate && tPtr->delegate->didSelectItem)
 348         (*tPtr->delegate->didSelectItem)(tPtr->delegate, tPtr,
 349                                          tPtr->items[index]);
 350 }
 351
 352
 353 static void
 354 recalcTabWidth(TabView *tPtr)
 355 {
 356     int i;
 357     int twidth = W_VIEW(tPtr)->size.width;
 358     int width;
 359
 360     tPtr->tabWidth = 0;
 361     for (i = 0; i < tPtr->itemCount; i++) {
 362         char *str = WMGetTabViewItemLabel(tPtr->items[i]);
 363
 364         if (str) {
 365             width = WMWidthOfString(tPtr->font, str, strlen(str));
 366             if (width > tPtr->tabWidth)
 367                 tPtr->tabWidth = width;
 368         }
 369     }
 370     tPtr->tabWidth += 30;
 371     if (tPtr->tabWidth > twidth - 10 * tPtr->itemCount
 372         && tPtr->tabWidth < twidth - 16)
 373         tPtr->tabWidth = (twidth - 16) / tPtr->itemCount;
 374 }
 375
 376
 377 static void
 378 drawRelief(W_Screen *scr, Drawable d, int x, int y, unsigned int width,
 379            unsigned int height)
 380 {
 381     Display *dpy = scr->display;
 382     GC bgc = WMColorGC(scr->black);
 383     GC wgc = WMColorGC(scr->white);
 384     GC dgc = WMColorGC(scr->darkGray);
 385
 386     XDrawLine(dpy, d, wgc, x, y, x, y+height-1);
 387
 388     XDrawLine(dpy, d, bgc, x, y+height-1, x+width-1, y+height-1);
 389     XDrawLine(dpy, d, dgc, x+1, y+height-2, x+width-2, y+height-2);
 390
 391     XDrawLine(dpy, d, bgc, x+width-1, y, x+width-1, y+height-1);
 392     XDrawLine(dpy, d, dgc, x+width-2, y+1, x+width-2, y+height-2);
 393 }
 394
 395
 396 static void
 397 drawTab(TabView *tPtr, Drawable d, int x, int y,
 398         unsigned width, unsigned height, Bool selected)
 399 {
 400     WMScreen *scr = W_VIEW(tPtr)->screen;
 401     Display *dpy = scr->display;
 402     GC white = WMColorGC(selected ? scr->white : tPtr->lightGray);
 403     GC black = WMColorGC(scr->black);
 404     GC dark = WMColorGC(scr->darkGray);
 405     GC light = WMColorGC(scr->gray);
 406     XPoint trap[8];
 407
 408     trap[0].x = x + (selected ? 0 : 1);
 409     trap[0].y = y + height - (selected ? 0 : 1);
 410
 411     trap[1].x = x + 3;
 412     trap[1].y = y + height - 3;
 413
 414     trap[2].x = x + 10 - 3;
 415     trap[2].y = y + 3;
 416
 417     trap[3].x = x + 10;
 418     trap[3].y = y;
 419
 420     trap[4].x = x + width - 10;
 421     trap[4].y = y;
 422
 423     trap[5].x = x + width - 10 + 3;
 424     trap[5].y = y + 3;
 425
 426     trap[6].x = x + width - 3;
 427     trap[6].y = y + height - 3;
 428
 429     trap[7].x = x + width - (selected ? 0 : 1);
 430     trap[7].y = y + height - (selected ? 0 : 1);
 431
 432     XFillPolygon(dpy, d, selected ? light : WMColorGC(tPtr->tabColor), trap, 8,
 433                  Convex, CoordModeOrigin);
 434
 435     XDrawLine(dpy, d, white, trap[0].x, trap[0].y, trap[1].x, trap[1].y);
 436     XDrawLine(dpy, d, white, trap[1].x, trap[1].y, trap[2].x, trap[2].y);
 437     XDrawLine(dpy, d, white, trap[2].x, trap[2].y, trap[3].x, trap[3].y);
 438     XDrawLine(dpy, d, white, trap[3].x, trap[3].y, trap[4].x, trap[4].y);
 439     XDrawLine(dpy, d, dark, trap[4].x, trap[4].y, trap[5].x, trap[5].y);
 440     XDrawLine(dpy, d, black, trap[5].x, trap[5].y, trap[6].x, trap[6].y);
 441     XDrawLine(dpy, d, black, trap[6].x, trap[6].y, trap[7].x, trap[7].y);
 442
 443     XDrawLine(dpy, d, selected ? light : WMColorGC(scr->white),
 444               trap[0].x, trap[0].y, trap[7].x, trap[7].y);
 445 }
 446
 447
 448 static void
 449 paintTabView(TabView *tPtr)
 450 {
 451     Pixmap buffer;
 452     WMScreen *scr = W_VIEW(tPtr)->screen;
 453     Display *dpy = scr->display;
 454     GC white = WMColorGC(scr->white);
 455     int i;
 456     WMRect rect;
 457
 458     if (tPtr->flags.type == WTTopTabsBevelBorder) {
 459         buffer = XCreatePixmap(dpy, W_VIEW(tPtr)->window,
 460                                W_VIEW(tPtr)->size.width, tPtr->tabHeight,
 461                                W_VIEW(tPtr)->screen->depth);
 462
 463         XFillRectangle(dpy, buffer, WMColorGC(W_VIEW(tPtr)->backColor),
 464                        0, 0, W_VIEW(tPtr)->size.width, tPtr->tabHeight);
 465
 466         rect.pos.x = 8 + 15;
 467         rect.pos.y = 2;
 468         rect.size.width = tPtr->tabWidth;
 469         rect.size.height = tPtr->tabHeight;
 470
 471         for (i = tPtr->itemCount - 1; i >= 0; i--) {
 472             if (i != tPtr->selectedItem) {
 473                 drawTab(tPtr, buffer, 8 + (rect.size.width-10)*i, 0,
 474                         rect.size.width, rect.size.height, False);
 475             }
 476         }
 477         drawTab(tPtr, buffer, 8 + (rect.size.width-10) * tPtr->selectedItem,
 478                 0, rect.size.width, rect.size.height, True);
 479
 480         XDrawLine(dpy, buffer, white, 0, tPtr->tabHeight - 1,
 481                   8, tPtr->tabHeight - 1);
 482
 483         XDrawLine(dpy, buffer, white,
 484                   8 + 10 + (rect.size.width-10) * tPtr->itemCount,
 485                   tPtr->tabHeight - 1, W_VIEW(tPtr)->size.width - 1,
 486                   tPtr->tabHeight - 1);
 487
 488
 489         for (i = 0; i < tPtr->itemCount; i++) {
 490             W_DrawLabel(tPtr->items[i], buffer, rect);
 491
 492             rect.pos.x += rect.size.width - 10;
 493         }
 494
 495         XCopyArea(dpy, buffer, W_VIEW(tPtr)->window, scr->copyGC, 0, 0,
 496                   W_VIEW(tPtr)->size.width, tPtr->tabHeight, 0, 0);
 497
 498         XFreePixmap(dpy, buffer);
 499     }
 500     switch (tPtr->flags.type) {
 501      case WTTopTabsBevelBorder:
 502         drawRelief(scr, W_VIEW(tPtr)->window, 0, tPtr->tabHeight - 1,
 503                    W_VIEW(tPtr)->size.width,
 504                    W_VIEW(tPtr)->size.height - tPtr->tabHeight + 1);
 505         break;
 506
 507      case WTNoTabsBevelBorder:
 508         W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
 509                      W_VIEW(tPtr)->size.height, WRRaised);
 510         break;
 511
 512      case WTNoTabsLineBorder:
 513         W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
 514                      W_VIEW(tPtr)->size.height, WRSimple);
 515         break;
 516
 517      case WTNoTabsNoBorder:
 518         break;
 519     }
 520 }
 521
 522
 523 static void
 524 destroyTabView(TabView *tPtr)
 525 {
 526     int i;
 527
 528     for (i = 0; i < tPtr->itemCount; i++) {
 529         WMSetTabViewItemView(tPtr->items[i], NULL);
 530         WMDestroyTabViewItem(tPtr->items[i]);
 531     }
 532     free(tPtr->items);
 533
 534     WMReleaseColor(tPtr->lightGray);
 535     WMReleaseColor(tPtr->tabColor);
 536     WMReleaseFont(tPtr->font);
 537
 538     free(tPtr);
 539 }
 540
 541 /******************************************************************/
 542
 543
 544 typedef struct W_TabViewItem {
 545     WMTabView *tabView;
 546
 547     W_View *view;
 548
 549     char *label;
 550
 551     int identifier;
 552
 553     struct {
 554         unsigned visible:1;
 555     } flags;
 556 } TabViewItem;
 557
 558
 559 static void
 560 W_SetTabViewItemParent(WMTabViewItem *item, WMTabView *parent)
 561 {
 562     item->tabView = parent;
 563 }
 564
 565
 566 static void
 567 W_DrawLabel(WMTabViewItem *item, Drawable d, WMRect rect)
 568 {
 569     WMScreen *scr = W_VIEW(item->tabView)->screen;
 570
 571     if (!item->label)
 572         return;
 573
 574     WMDrawString(scr, d, WMColorGC(scr->black), item->tabView->font,
 575                  rect.pos.x, rect.pos.y, item->label, strlen(item->label));
 576 }
 577
 578
 579 static void
 580 W_UnmapTabViewItem(WMTabViewItem *item)
 581 {
 582     wassertr(item->view);
 583
 584     W_UnmapView(item->view);
 585
 586     item->flags.visible = 0;
 587 }
 588
 589
 590 static void
 591 W_MapTabViewItem(WMTabViewItem *item)
 592 {
 593     wassertr(item->view);
 594
 595     W_MapView(item->view);
 596
 597     item->flags.visible = 1;
 598 }
 599
 600
 601 static WMView*
 602 W_TabViewItemView(WMTabViewItem *item)
 603 {
 604     return item->view;
 605 }
 606
 607
 608 WMTabViewItem*
 609 WMCreateTabViewItemWithIdentifier(int identifier)
 610 {
 611     WMTabViewItem *item;
 612
 613     item = wmalloc(sizeof(WMTabViewItem));
 614     memset(item, 0, sizeof(WMTabViewItem));
 615
 616     item->identifier = identifier;
 617
 618     return item;
 619 }
 620
 621
 622 int
 623 WMGetTabViewItemIdentifier(WMTabViewItem *item)
 624 {
 625     return item->identifier;
 626 }
 627
 628
 629 void
 630 WMSetTabViewFont(WMTabView *tPtr, WMFont *font)
 631 {
 632     if (tPtr->font)
 633         WMReleaseFont(tPtr->font);
 634
 635     tPtr->font = WMRetainFont(font);
 636     tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;
 637     recalcTabWidth(tPtr);
 638 }
 639
 640
 641 void
 642 WMSetTabViewItemLabel(WMTabViewItem *item, char *label)
 643 {
 644     if (item->label)
 645         free(item->label);
 646
 647     item->label = wstrdup(label);
 648
 649     if (item->tabView)
 650         recalcTabWidth(item->tabView);
 651 }
 652
 653
 654 char*
 655 WMGetTabViewItemLabel(WMTabViewItem *item)
 656 {
 657     return item->label;
 658 }
 659
 660
 661 void
 662 WMSetTabViewItemView(WMTabViewItem *item, WMView *view)
 663 {
 664     item->view = view;
 665 }
 666
 667
 668 WMView*
 669 WMGetTabViewItemView(WMTabViewItem *item)
 670 {
 671     return item->view;
 672 }
 673
 674
 675 void
 676 WMDestroyTabViewItem(WMTabViewItem *item)
 677 {
 678     if (item->label)
 679         free(item->label);
 680
 681     if (item->view)
 682         W_DestroyView(item->view);
 683
 684     free(item);
 685 }