WINGs/wpopupbutton.c

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