WINGs/wpopupbutton.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 typedef struct ItemList {
   8     char *text;
   9     struct ItemList *nextPtr;
  10     unsigned int disabled:1;
  11 } ItemList;
  12
  13 typedef struct W_PopUpButton {
  14     W_Class widgetClass;
  15     WMView *view;
  16
  17     void *clientData;
  18     WMAction *action;
  19
  20     char *caption;
  21
  22     ItemList *items;
  23     short itemCount;
  24
  25     short selectedItemIndex;
  26
  27     short highlightedItem;
  28
  29     ItemList *selectedItem;            /* selected item if it is a menu btn */
  30
  31     WMView *menuView;                  /* override redirect popup menu */
  32
  33     struct {
  34         unsigned int pullsDown:1;
  35
  36         unsigned int configured:1;
  37
  38         unsigned int insideMenu:1;
  39     } flags;
  40 } PopUpButton;
  41
  42
  43 #define MENU_BLINK_DELAY        60000
  44 #define MENU_BLINK_COUNT        2
  45
  46
  47 W_ViewProcedureTable _PopUpButtonViewProcedures = {
  48     NULL,
  49         NULL,
  50         NULL
  51 };
  52
  53
  54 #define DEFAULT_WIDTH   60
  55 #define DEFAULT_HEIGHT  20
  56 #define DEFAULT_CAPTION ""
  57
  58
  59 static void destroyPopUpButton(PopUpButton *bPtr);
  60 static void paintPopUpButton(PopUpButton *bPtr);
  61
  62 static void handleEvents(XEvent *event, void *data);
  63 static void handleActionEvents(XEvent *event, void *data);
  64
  65 static void resizeMenu(PopUpButton *bPtr);
  66
  67
  68 WMPopUpButton*
  69 WMCreatePopUpButton(WMWidget *parent)
  70 {
  71     PopUpButton *bPtr;
  72     W_Screen *scr = W_VIEW(parent)->screen;
  73
  74
  75     bPtr = wmalloc(sizeof(PopUpButton));
  76     memset(bPtr, 0, sizeof(PopUpButton));
  77
  78     bPtr->widgetClass = WC_PopUpButton;
  79
  80     bPtr->view = W_CreateView(W_VIEW(parent));
  81     if (!bPtr->view) {
  82         free(bPtr);
  83         return NULL;
  84     }
  85     bPtr->view->self = bPtr;
  86
  87     WMCreateEventHandler(bPtr->view, ExposureMask|StructureNotifyMask
  88                          |ClientMessageMask, handleEvents, bPtr);
  89
  90
  91     W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
  92     bPtr->caption = wstrdup(DEFAULT_CAPTION);
  93
  94     WMCreateEventHandler(bPtr->view, ButtonPressMask|ButtonReleaseMask,
  95                          handleActionEvents, bPtr);
  96
  97     bPtr->menuView = W_CreateTopView(scr);
  98     bPtr->menuView->attribs.override_redirect = True;
  99     bPtr->menuView->attribFlags |= CWOverrideRedirect;
 100
 101     W_ResizeView(bPtr->menuView, bPtr->view->size.width, 1);
 102
 103     WMCreateEventHandler(bPtr->menuView, ButtonPressMask|ButtonReleaseMask
 104                          |EnterWindowMask|LeaveWindowMask|ButtonMotionMask,
 105                          handleActionEvents, bPtr);
 106
 107     return bPtr;
 108 }
 109
 110
 111 void
 112 WMSetPopUpButtonAction(WMPopUpButton *bPtr, WMAction *action, void *clientData)
 113 {
 114     CHECK_CLASS(bPtr, WC_PopUpButton);
 115
 116     bPtr->action = action;
 117
 118     bPtr->clientData = clientData;
 119 }
 120
 121
 122 void
 123 WMAddPopUpButtonItem(WMPopUpButton *bPtr, char *title)
 124 {
 125     ItemList *itemPtr, *tmp;
 126
 127     CHECK_CLASS(bPtr, WC_PopUpButton);
 128
 129     itemPtr = wmalloc(sizeof(ItemList));
 130     memset(itemPtr, 0, sizeof(ItemList));
 131     itemPtr->text = wstrdup(title);
 132
 133     /* append item to list */
 134     tmp = bPtr->items;
 135     if (!tmp)
 136         bPtr->items = itemPtr;
 137     else {
 138         while (tmp->nextPtr!=NULL)
 139             tmp = tmp->nextPtr;
 140         tmp->nextPtr = itemPtr;
 141     }
 142
 143     bPtr->itemCount++;
 144
 145     if (bPtr->menuView && bPtr->menuView->flags.realized)
 146         resizeMenu(bPtr);
 147 }
 148
 149
 150 void
 151 WMInsertPopUpButtonItem(WMPopUpButton *bPtr, int index, char *title)
 152 {
 153     ItemList *itemPtr;
 154
 155     CHECK_CLASS(bPtr, WC_PopUpButton);
 156
 157     if (index < 0)
 158         index = 0;
 159     if (index >= bPtr->itemCount) {
 160         WMAddPopUpButtonItem(bPtr, title);
 161         return;
 162     }
 163
 164     itemPtr = wmalloc(sizeof(ItemList));
 165     memset(itemPtr, 0, sizeof(ItemList));
 166     itemPtr->text = wstrdup(title);
 167
 168     if (index == 0) {
 169         itemPtr->nextPtr = bPtr->items;
 170         bPtr->items = itemPtr;
 171     } else {
 172         ItemList *tmp;
 173         int i = index;
 174
 175         tmp = bPtr->items;
 176         /* insert item in list */
 177         while (--i > 0) {
 178             tmp = tmp->nextPtr;
 179         }
 180         bPtr->items->nextPtr = tmp->nextPtr;
 181         tmp->nextPtr = bPtr->items;
 182     }
 183
 184     bPtr->itemCount++;
 185
 186     /* if there is an selected item, update it's index to match the new
 187      * position */
 188     if (index < bPtr->selectedItemIndex)
 189         bPtr->selectedItemIndex++;
 190
 191     if (bPtr->menuView && bPtr->menuView->flags.realized)
 192         resizeMenu(bPtr);
 193 }
 194
 195
 196 void
 197 WMRemovePopUpButtonItem(WMPopUpButton *bPtr, int index)
 198 {
 199     ItemList *tmp;
 200
 201     CHECK_CLASS(bPtr, WC_PopUpButton);
 202
 203     if (index < 0 || index >= bPtr->itemCount)
 204         return;
 205
 206
 207     if (index == 0) {
 208         free(bPtr->items->text);
 209         tmp = bPtr->items->nextPtr;
 210         free(bPtr->items);
 211         bPtr->items = tmp;
 212     } else {
 213         ItemList *next;
 214         int i = index;
 215
 216         tmp = bPtr->items;
 217         while (--i > 0)
 218             tmp = tmp->nextPtr;
 219         next = tmp->nextPtr->nextPtr;
 220
 221         free(tmp->nextPtr->text);
 222         free(tmp->nextPtr);
 223
 224         tmp->nextPtr = next;
 225     }
 226
 227     bPtr->itemCount--;
 228
 229     if (bPtr->selectedItem!=NULL && !bPtr->flags.pullsDown) {
 230         if (index < bPtr->selectedItemIndex)
 231             bPtr->selectedItemIndex--;
 232         else if (index == bPtr->selectedItemIndex) {
 233             /* reselect first item if the removed item is the
 234              * selected one */
 235             bPtr->selectedItem = bPtr->items;
 236             bPtr->selectedItemIndex = 0;
 237             if (bPtr->view->flags.mapped)
 238                 paintPopUpButton(bPtr);
 239         }
 240     }
 241
 242     if (bPtr->menuView && bPtr->menuView->flags.realized)
 243         resizeMenu(bPtr);
 244 }
 245
 246
 247 void
 248 WMSetPopUpButtonSelectedItem(WMPopUpButton *bPtr, int index)
 249 {
 250     ItemList *itemPtr = bPtr->items;
 251     int i = index;
 252
 253     if (index < 0) {
 254         bPtr->selectedItem = NULL;
 255         if (bPtr->view->flags.mapped)
 256             paintPopUpButton(bPtr);
 257         return;
 258     }
 259
 260     while (i-- > 0) {
 261         itemPtr = itemPtr->nextPtr;
 262     }
 263     bPtr->selectedItem = itemPtr;
 264     bPtr->selectedItemIndex = index;
 265
 266     if (bPtr->view->flags.mapped)
 267         paintPopUpButton(bPtr);
 268 }
 269
 270 int
 271 WMGetPopUpButtonSelectedItem(WMPopUpButton *bPtr)
 272 {
 273     if (!bPtr->flags.pullsDown && bPtr->selectedItem==NULL)
 274         return -1;
 275     else
 276         return bPtr->selectedItemIndex;
 277 }
 278
 279
 280 void
 281 WMSetPopUpButtonText(WMPopUpButton *bPtr, char *text)
 282 {
 283     if (bPtr->caption)
 284         free(bPtr->caption);
 285     if (text)
 286         bPtr->caption = wstrdup(text);
 287     else
 288         bPtr->caption = NULL;
 289     if (bPtr->view->flags.realized) {
 290         if (bPtr->flags.pullsDown || bPtr->selectedItemIndex < 0) {
 291             paintPopUpButton(bPtr);
 292         }
 293     }
 294 }
 295
 296
 297
 298 void
 299 WMSetPopUpButtonItemEnabled(WMPopUpButton *bPtr, int index, Bool flag)
 300 {
 301     int i;
 302     ItemList *item = bPtr->items;
 303
 304     if (index < 0 || index >= bPtr->itemCount)
 305         return;
 306
 307     for (i = 0; i<index; i++)
 308         item=item->nextPtr;
 309
 310     item->disabled = !flag;
 311 }
 312
 313
 314 void
 315 WMSetPopUpButtonPullsDown(WMPopUpButton *bPtr, Bool flag)
 316 {
 317     bPtr->flags.pullsDown = flag;
 318     if (!flag) {
 319         bPtr->selectedItem = bPtr->items;
 320         if (bPtr->selectedItem)
 321             bPtr->selectedItemIndex = 0;
 322         else
 323             bPtr->selectedItemIndex = -1;
 324     } else
 325         bPtr->selectedItemIndex = -1;
 326
 327     if (bPtr->view->flags.mapped)
 328         paintPopUpButton(bPtr);
 329 }
 330
 331
 332 int
 333 WMGetPopUpButtonNumberOfItems(WMPopUpButton *bPtr)
 334 {
 335     return bPtr->itemCount;
 336 }
 337
 338
 339 char*
 340 WMGetPopUpButtonItem(WMPopUpButton *bPtr, int index)
 341 {
 342     ItemList *itemPtr = bPtr->items;
 343
 344     if ((index < 0) || (index >= bPtr->itemCount))
 345         return NULL;
 346
 347     while (index-->0)
 348         itemPtr = itemPtr->nextPtr;
 349
 350     return itemPtr->text;
 351 }
 352
 353
 354 static void
 355 paintPopUpButton(PopUpButton *bPtr)
 356 {
 357     W_Screen *scr = bPtr->view->screen;
 358     char *caption;
 359     Pixmap pixmap;
 360
 361
 362     if (bPtr->flags.pullsDown) {
 363         caption = bPtr->caption;
 364     } else {
 365         if (bPtr->selectedItem == NULL) {
 366             /* if no item selected, show the caption */
 367             caption = bPtr->caption;
 368         } else {
 369             caption = bPtr->selectedItem->text;
 370         }
 371     }
 372
 373     pixmap = XCreatePixmap(scr->display, bPtr->view->window,
 374                            bPtr->view->size.width, bPtr->view->size.height,
 375                            scr->depth);
 376     XFillRectangle(scr->display, pixmap, W_GC(scr->gray), 0, 0,
 377                    bPtr->view->size.width, bPtr->view->size.height);
 378
 379     W_DrawRelief(scr, pixmap, 0, 0, bPtr->view->size.width,
 380                  bPtr->view->size.height, WRRaised);
 381
 382     if (caption) {
 383         W_PaintText(bPtr->view, pixmap, scr->normalFont,
 384                     6, (bPtr->view->size.height-scr->normalFont->height)/2,
 385                     bPtr->view->size.width, WALeft, W_GC(scr->black), False,
 386                     caption, strlen(caption));
 387     }
 388
 389     if (bPtr->flags.pullsDown) {
 390         XCopyArea(scr->display, scr->pullDownIndicator->pixmap,
 391                   pixmap, scr->copyGC, 0, 0, scr->pullDownIndicator->width,
 392                   scr->pullDownIndicator->height,
 393                   bPtr->view->size.width-scr->pullDownIndicator->width-4,
 394                   (bPtr->view->size.height-scr->pullDownIndicator->height)/2);
 395     } else {
 396         int x, y;
 397
 398         x = bPtr->view->size.width - scr->popUpIndicator->width - 4;
 399         y = (bPtr->view->size.height-scr->popUpIndicator->height)/2;
 400
 401         XSetClipOrigin(scr->display, scr->clipGC, x, y);
 402         XSetClipMask(scr->display, scr->clipGC, scr->popUpIndicator->mask);
 403         XCopyArea(scr->display, scr->popUpIndicator->pixmap, pixmap,
 404                   scr->clipGC, 0, 0, scr->popUpIndicator->width,
 405                   scr->popUpIndicator->height, x, y);
 406     }
 407
 408     XCopyArea(scr->display, pixmap, bPtr->view->window, scr->copyGC, 0, 0,
 409               bPtr->view->size.width, bPtr->view->size.height, 0, 0);
 410
 411     XFreePixmap(scr->display, pixmap);
 412 }
 413
 414
 415
 416 static void
 417 handleEvents(XEvent *event, void *data)
 418 {
 419     PopUpButton *bPtr = (PopUpButton*)data;
 420
 421     CHECK_CLASS(data, WC_PopUpButton);
 422
 423
 424     switch (event->type) {
 425      case Expose:
 426         if (event->xexpose.count!=0)
 427             break;
 428         paintPopUpButton(bPtr);
 429         break;
 430
 431      case DestroyNotify:
 432         destroyPopUpButton(bPtr);
 433         break;
 434     }
 435 }
 436
 437
 438
 439 static void
 440 paintMenuEntry(PopUpButton *bPtr, int index, int highlight)
 441 {
 442     W_Screen *scr = bPtr->view->screen;
 443     int i;
 444     int yo;
 445     ItemList *itemPtr;
 446     int width, height, itemHeight;
 447
 448     itemHeight = bPtr->view->size.height;
 449     width = bPtr->view->size.width;
 450     height = itemHeight * bPtr->itemCount;
 451     yo = (itemHeight - scr->normalFont->height)/2;
 452
 453     if (!highlight) {
 454         XClearArea(scr->display, bPtr->menuView->window, 0, index*itemHeight,
 455                    width, itemHeight, False);
 456         return;
 457     } else if (index < 0 && bPtr->flags.pullsDown) {
 458         return;
 459     }
 460
 461     XFillRectangle(scr->display, bPtr->menuView->window, W_GC(scr->white),
 462                    1, index*itemHeight+1, width-3, itemHeight-3);
 463
 464     itemPtr = bPtr->items;
 465     for (i = 0; i < index; i++)
 466         itemPtr = itemPtr->nextPtr;
 467
 468     W_DrawRelief(scr, bPtr->menuView->window, 0, index*itemHeight,
 469                  width, itemHeight, WRRaised);
 470
 471     W_PaintText(bPtr->menuView, bPtr->menuView->window, scr->normalFont,  6,
 472                 index*itemHeight + yo, width, WALeft, W_GC(scr->black), False,
 473                 itemPtr->text, strlen(itemPtr->text));
 474
 475     if (!bPtr->flags.pullsDown && index == bPtr->selectedItemIndex) {
 476         XCopyArea(scr->display, scr->popUpIndicator->pixmap,
 477                   bPtr->menuView->window, scr->copyGC, 0, 0,
 478                   scr->popUpIndicator->width, scr->popUpIndicator->height,
 479                   width-scr->popUpIndicator->width-4,
 480                   i*itemHeight+(itemHeight-scr->popUpIndicator->height)/2);
 481     }
 482 }
 483
 484
 485 Pixmap
 486 makeMenuPixmap(PopUpButton *bPtr)
 487 {
 488     Pixmap pixmap;
 489     W_Screen *scr = bPtr->view->screen;
 490     int i;
 491     int yo;
 492     ItemList *itemPtr;
 493     int width, height, itemHeight;
 494
 495     itemHeight = bPtr->view->size.height;
 496     width = bPtr->view->size.width;
 497     height = itemHeight * bPtr->itemCount;
 498     yo = (itemHeight - scr->normalFont->height)/2;
 499
 500     pixmap = XCreatePixmap(scr->display, bPtr->view->window, width, height,
 501                            scr->depth);
 502
 503     XFillRectangle(scr->display, pixmap, W_GC(scr->gray), 0, 0, width, height);
 504
 505     itemPtr = bPtr->items;
 506     for (i = 0; i < bPtr->itemCount; i++) {
 507         GC gc;
 508
 509         W_DrawRelief(scr, pixmap, 0, i*itemHeight, width, itemHeight,
 510                      WRRaised);
 511
 512         if (itemPtr->disabled)
 513             gc = W_GC(scr->darkGray);
 514         else
 515             gc = W_GC(scr->black);
 516
 517         W_PaintText(bPtr->menuView, pixmap, scr->normalFont,  6,
 518                     i*itemHeight + yo, width, WALeft, gc, False,
 519                     itemPtr->text, strlen(itemPtr->text));
 520
 521         if (!bPtr->flags.pullsDown && i == bPtr->selectedItemIndex) {
 522             XCopyArea(scr->display, scr->popUpIndicator->pixmap, pixmap,
 523                       scr->copyGC, 0, 0, scr->popUpIndicator->width,
 524                       scr->popUpIndicator->height,
 525                       width-scr->popUpIndicator->width-4,
 526                       i*itemHeight+(itemHeight-scr->popUpIndicator->height)/2);
 527         }
 528         itemPtr = itemPtr->nextPtr;
 529     }
 530
 531     return pixmap;
 532 }
 533
 534
 535 static void
 536 resizeMenu(PopUpButton *bPtr)
 537 {
 538     int height;
 539
 540     height = bPtr->itemCount * bPtr->view->size.height;
 541     W_ResizeView(bPtr->menuView, bPtr->view->size.width, height);
 542 }
 543
 544
 545 static void
 546 popUpMenu(PopUpButton *bPtr)
 547 {
 548     W_Screen *scr = bPtr->view->screen;
 549     Window dummyW;
 550     int x, y;
 551
 552     if (!bPtr->menuView->flags.realized) {
 553         W_RealizeView(bPtr->menuView);
 554         resizeMenu(bPtr);
 555     }
 556
 557     if (bPtr->itemCount < 1)
 558         return;
 559
 560     XTranslateCoordinates(scr->display, bPtr->view->window, scr->rootWin,
 561                           0, 0, &x, &y, &dummyW);
 562
 563     if (bPtr->flags.pullsDown) {
 564         y += bPtr->view->size.height;
 565     } else {
 566         y -= bPtr->view->size.height*bPtr->selectedItemIndex;
 567     }
 568     W_MoveView(bPtr->menuView, x, y);
 569
 570     XSetWindowBackgroundPixmap(scr->display, bPtr->menuView->window,
 571                                makeMenuPixmap(bPtr));
 572     XClearWindow(scr->display, bPtr->menuView->window);
 573
 574     W_MapView(bPtr->menuView);
 575
 576     bPtr->highlightedItem = 0;
 577     if (!bPtr->flags.pullsDown && bPtr->selectedItem != NULL)
 578         paintMenuEntry(bPtr, bPtr->selectedItemIndex, True);
 579 }
 580
 581
 582 static void
 583 popDownMenu(PopUpButton *bPtr)
 584 {
 585     W_UnmapView(bPtr->menuView);
 586
 587     /* free the background pixmap used to draw the menu contents */
 588     XSetWindowBackgroundPixmap(bPtr->view->screen->display,
 589                                bPtr->menuView->window, None);
 590 }
 591
 592
 593 static int
 594 itemIsEnabled(PopUpButton *bPtr, int index)
 595 {
 596     ItemList *item = bPtr->items;
 597
 598     while (index-- > 0)
 599         item = item->nextPtr;
 600
 601     return !item->disabled;
 602 }
 603
 604 static void
 605 handleActionEvents(XEvent *event, void *data)
 606 {
 607     PopUpButton *bPtr = (PopUpButton*)data;
 608     int oldItem;
 609
 610     CHECK_CLASS(data, WC_PopUpButton);
 611
 612     if (bPtr->itemCount < 1)
 613         return;
 614
 615     switch (event->type) {
 616         /* called for menuView */
 617      case LeaveNotify:
 618         bPtr->flags.insideMenu = 0;
 619         if (bPtr->menuView->flags.mapped)
 620             paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 621         bPtr->highlightedItem = -1;
 622         break;
 623
 624      case EnterNotify:
 625         bPtr->flags.insideMenu = 1;
 626         break;
 627
 628      case MotionNotify:
 629         if (bPtr->flags.insideMenu) {
 630             oldItem = bPtr->highlightedItem;
 631             bPtr->highlightedItem = event->xmotion.y / bPtr->view->size.height;
 632             if (oldItem!=bPtr->highlightedItem) {
 633                 paintMenuEntry(bPtr, oldItem, False);
 634                 paintMenuEntry(bPtr, bPtr->highlightedItem,
 635                                itemIsEnabled(bPtr, bPtr->highlightedItem));
 636             }
 637         }
 638         break;
 639
 640         /* called for bPtr->view */
 641      case ButtonPress:
 642         popUpMenu(bPtr);
 643         if (!bPtr->flags.pullsDown) {
 644             bPtr->highlightedItem = bPtr->selectedItemIndex;
 645             bPtr->flags.insideMenu = 1;
 646         } else {
 647             bPtr->highlightedItem = -1;
 648             bPtr->flags.insideMenu = 0;
 649         }
 650         XGrabPointer(bPtr->view->screen->display, bPtr->menuView->window,
 651                      False, ButtonReleaseMask|ButtonMotionMask|EnterWindowMask
 652                      |LeaveWindowMask, GrabModeAsync, GrabModeAsync,
 653                      None, None, CurrentTime);
 654         break;
 655
 656      case ButtonRelease:
 657         XUngrabPointer(bPtr->view->screen->display, event->xbutton.time);
 658         if (!bPtr->flags.pullsDown)
 659             popDownMenu(bPtr);
 660         if (bPtr->flags.insideMenu && bPtr->highlightedItem>=0) {
 661             if (itemIsEnabled(bPtr, bPtr->highlightedItem)) {
 662                 int i;
 663                 WMSetPopUpButtonSelectedItem(bPtr, bPtr->highlightedItem);
 664
 665                 if (bPtr->flags.pullsDown) {
 666                     for (i=0; i<MENU_BLINK_COUNT; i++) {
 667                         paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 668                         XSync(bPtr->view->screen->display, 0);
 669                         wusleep(MENU_BLINK_DELAY);
 670                         paintMenuEntry(bPtr, bPtr->highlightedItem, True);
 671                         XSync(bPtr->view->screen->display, 0);
 672                         wusleep(MENU_BLINK_DELAY);
 673                     }
 674                 }
 675                 paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 676                 popDownMenu(bPtr);
 677                 if (bPtr->action)
 678                     (*bPtr->action)(bPtr, bPtr->clientData);
 679             }
 680         }
 681         if (bPtr->menuView->flags.mapped)
 682             popDownMenu(bPtr);
 683         break;
 684     }
 685 }
 686
 687
 688
 689 static void
 690 destroyPopUpButton(PopUpButton *bPtr)
 691 {
 692     ItemList *itemPtr, *tmp;
 693
 694     itemPtr = bPtr->items;
 695     while (itemPtr!=NULL) {
 696         free(itemPtr->text);
 697         tmp = itemPtr->nextPtr;
 698         free(itemPtr);
 699         itemPtr = tmp;
 700     }
 701
 702     if (bPtr->caption)
 703         free(bPtr->caption);
 704
 705     /* have to destroy explicitly because the popup is a toplevel */
 706     W_DestroyView(bPtr->menuView);
 707
 708     free(bPtr);
 709 }