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