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 == NULL)
 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     WMMenuItem *item;
 468     WMBagIterator iter;
 469     int yo, i;
 470     int width, height, itemHeight;
 471
 472     itemHeight = bPtr->view->size.height;
 473     width = bPtr->view->size.width;
 474     height = itemHeight * WMGetBagItemCount(bPtr->items);
 475     yo = (itemHeight - WMFontHeight(scr->normalFont))/2;
 476
 477     pixmap = XCreatePixmap(scr->display, bPtr->view->window, width, height,
 478                            scr->depth);
 479
 480     XFillRectangle(scr->display, pixmap, WMColorGC(scr->gray), 0, 0,
 481                    width, height);
 482
 483     i = 0;
 484     WM_ITERATE_BAG(bPtr->items, item, iter) {
 485         GC gc;
 486         char *text;
 487
 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         i++;
 511     }
 512
 513     return pixmap;
 514 }
 515
 516
 517 static void
 518 resizeMenu(PopUpButton *bPtr)
 519 {
 520     int height;
 521
 522     height = WMGetBagItemCount(bPtr->items) * bPtr->view->size.height;
 523     if (height > 0)
 524         W_ResizeView(bPtr->menuView, bPtr->view->size.width, height);
 525 }
 526
 527
 528 static void
 529 popUpMenu(PopUpButton *bPtr)
 530 {
 531     W_Screen *scr = bPtr->view->screen;
 532     Window dummyW;
 533     int x, y;
 534
 535     if (!bPtr->menuView->flags.realized) {
 536         W_RealizeView(bPtr->menuView);
 537         resizeMenu(bPtr);
 538     }
 539
 540     if (WMGetBagItemCount(bPtr->items) < 1)
 541         return;
 542
 543     XTranslateCoordinates(scr->display, bPtr->view->window, scr->rootWin,
 544                           0, 0, &x, &y, &dummyW);
 545
 546     if (bPtr->flags.pullsDown) {
 547         y += bPtr->view->size.height;
 548     } else {
 549         y -= bPtr->view->size.height*bPtr->selectedItemIndex;
 550     }
 551     W_MoveView(bPtr->menuView, x, y);
 552
 553     XSetWindowBackgroundPixmap(scr->display, bPtr->menuView->window,
 554                                makeMenuPixmap(bPtr));
 555     XClearWindow(scr->display, bPtr->menuView->window);
 556
 557     W_MapView(bPtr->menuView);
 558
 559     bPtr->highlightedItem = 0;
 560     if (!bPtr->flags.pullsDown && bPtr->selectedItemIndex < 0)
 561         paintMenuEntry(bPtr, bPtr->selectedItemIndex, True);
 562 }
 563
 564
 565 static void
 566 popDownMenu(PopUpButton *bPtr)
 567 {
 568     W_UnmapView(bPtr->menuView);
 569
 570     /* free the background pixmap used to draw the menu contents */
 571     XSetWindowBackgroundPixmap(bPtr->view->screen->display,
 572                                bPtr->menuView->window, None);
 573 }
 574
 575
 576 static void
 577 autoScroll(void *data)
 578 {
 579     PopUpButton *bPtr = (PopUpButton*)data;
 580     int scrHeight = WMWidgetScreen(bPtr)->rootView->size.height;
 581     int repeat = 0;
 582     int dy = 0;
 583
 584
 585     if (bPtr->scrollStartY >= scrHeight-1
 586         && bPtr->menuView->pos.y+bPtr->menuView->size.height >= scrHeight-1) {
 587         repeat = 1;
 588
 589         if (bPtr->menuView->pos.y+bPtr->menuView->size.height-5
 590             <= scrHeight - 1) {
 591             dy = scrHeight - 1
 592                 - (bPtr->menuView->pos.y+bPtr->menuView->size.height);
 593         } else
 594             dy = -5;
 595
 596     } else if (bPtr->scrollStartY <= 1 && bPtr->menuView->pos.y < 1) {
 597         repeat = 1;
 598
 599         if (bPtr->menuView->pos.y+5 > 1)
 600             dy = 1 - bPtr->menuView->pos.y;
 601         else
 602             dy = 5;
 603     }
 604
 605     if (repeat) {
 606         int oldItem;
 607
 608         W_MoveView(bPtr->menuView, bPtr->menuView->pos.x,
 609                    bPtr->menuView->pos.y + dy);
 610
 611         oldItem = bPtr->highlightedItem;
 612         bPtr->highlightedItem = (bPtr->scrollStartY - bPtr->menuView->pos.y)
 613             / bPtr->view->size.height;
 614
 615         if (oldItem!=bPtr->highlightedItem) {
 616             WMMenuItem *item;
 617
 618             paintMenuEntry(bPtr, oldItem, False);
 619
 620             if (bPtr->highlightedItem >= 0 &&
 621                 bPtr->highlightedItem < WMGetBagItemCount(bPtr->items)) {
 622                 item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 623                 paintMenuEntry(bPtr, bPtr->highlightedItem,
 624                                WMGetMenuItemEnabled(item));
 625             } else {
 626                 bPtr->highlightedItem = -1;
 627             }
 628         }
 629
 630         bPtr->timer = WMAddTimerHandler(SCROLL_DELAY, autoScroll, bPtr);
 631     } else {
 632         bPtr->timer = NULL;
 633     }
 634 }
 635
 636
 637 static void
 638 wheelScrollUp(PopUpButton *bPtr)
 639 {
 640     int testIndex = bPtr->selectedItemIndex - 1;
 641
 642     while (testIndex>=0 && !WMGetPopUpButtonItemEnabled(bPtr, testIndex))
 643         testIndex--;
 644     if (testIndex != -1) {
 645         WMSetPopUpButtonSelectedItem(bPtr, testIndex);
 646         if (bPtr->action)
 647             (*bPtr->action)(bPtr, bPtr->clientData);
 648     }
 649 }
 650
 651
 652 static void
 653 wheelScrollDown(PopUpButton *bPtr)
 654 {
 655     int itemCount = WMGetBagItemCount(bPtr->items);
 656     int testIndex = bPtr->selectedItemIndex + 1;
 657
 658     while (testIndex<itemCount && !WMGetPopUpButtonItemEnabled(bPtr, testIndex))
 659         testIndex++;
 660     if (testIndex != itemCount) {
 661         WMSetPopUpButtonSelectedItem(bPtr, testIndex);
 662         if (bPtr->action)
 663             (*bPtr->action)(bPtr, bPtr->clientData);
 664     }
 665 }
 666
 667
 668 static void
 669 handleActionEvents(XEvent *event, void *data)
 670 {
 671     PopUpButton *bPtr = (PopUpButton*)data;
 672     int oldItem;
 673     int scrHeight = WMWidgetScreen(bPtr)->rootView->size.height;
 674
 675     CHECK_CLASS(data, WC_PopUpButton);
 676
 677     if (WMGetBagItemCount(bPtr->items) < 1)
 678         return;
 679
 680     switch (event->type) {
 681         /* called for menuView */
 682      case Expose:
 683         paintMenuEntry(bPtr, bPtr->highlightedItem, True);
 684         break;
 685
 686      case LeaveNotify:
 687         bPtr->flags.insideMenu = 0;
 688         if (bPtr->menuView->flags.mapped)
 689             paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 690         bPtr->highlightedItem = -1;
 691         break;
 692
 693      case EnterNotify:
 694         bPtr->flags.insideMenu = 1;
 695         break;
 696
 697      case MotionNotify:
 698         if (bPtr->flags.insideMenu) {
 699             oldItem = bPtr->highlightedItem;
 700             bPtr->highlightedItem = event->xmotion.y / bPtr->view->size.height;
 701             if (oldItem!=bPtr->highlightedItem) {
 702                 WMMenuItem *item;
 703
 704                 paintMenuEntry(bPtr, oldItem, False);
 705                 if (bPtr->highlightedItem >= 0 &&
 706                     bPtr->highlightedItem < WMGetBagItemCount(bPtr->items)) {
 707                     item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 708                     paintMenuEntry(bPtr, bPtr->highlightedItem,
 709                                    WMGetMenuItemEnabled(item));
 710                 } else {
 711                     bPtr->highlightedItem = -1;
 712                 }
 713
 714             }
 715
 716             if (event->xmotion.y_root >= scrHeight-1
 717                 || event->xmotion.y_root <= 1) {
 718                 bPtr->scrollStartY = event->xmotion.y_root;
 719                 if (!bPtr->timer)
 720                     autoScroll(bPtr);
 721             } else if (bPtr->timer) {
 722                 WMDeleteTimerHandler(bPtr->timer);
 723                 bPtr->timer = NULL;
 724             }
 725         }
 726         break;
 727
 728         /* called for bPtr->view */
 729      case ButtonPress:
 730         if (!bPtr->flags.enabled)
 731             break;
 732
 733         if (event->xbutton.button==WINGsConfiguration.mouseWheelUp) {
 734             if (!bPtr->menuView->flags.mapped && !bPtr->flags.pullsDown) {
 735                 wheelScrollUp(bPtr);
 736             }
 737             break;
 738         } else if (event->xbutton.button==WINGsConfiguration.mouseWheelDown) {
 739             if (!bPtr->menuView->flags.mapped && !bPtr->flags.pullsDown) {
 740                 wheelScrollDown(bPtr);
 741             }
 742             break;
 743         }
 744         popUpMenu(bPtr);
 745         if (!bPtr->flags.pullsDown) {
 746             bPtr->highlightedItem = bPtr->selectedItemIndex;
 747             bPtr->flags.insideMenu = 1;
 748         } else {
 749             bPtr->highlightedItem = -1;
 750             bPtr->flags.insideMenu = 0;
 751         }
 752         XGrabPointer(bPtr->view->screen->display, bPtr->menuView->window,
 753                      False, ButtonReleaseMask|ButtonMotionMask|EnterWindowMask
 754                      |LeaveWindowMask, GrabModeAsync, GrabModeAsync,
 755                      None, None, CurrentTime);
 756         break;
 757
 758      case ButtonRelease:
 759         if (event->xbutton.button==WINGsConfiguration.mouseWheelUp ||
 760             event->xbutton.button==WINGsConfiguration.mouseWheelDown) {
 761             break;
 762         }
 763         XUngrabPointer(bPtr->view->screen->display, event->xbutton.time);
 764         if (!bPtr->flags.pullsDown)
 765             popDownMenu(bPtr);
 766
 767         if (bPtr->timer) {
 768             WMDeleteTimerHandler(bPtr->timer);
 769             bPtr->timer = NULL;
 770         }
 771
 772         if (bPtr->flags.insideMenu && bPtr->highlightedItem>=0) {
 773             WMMenuItem *item;
 774
 775             item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 776
 777             if (WMGetMenuItemEnabled(item)) {
 778                 int i;
 779                 WMSetPopUpButtonSelectedItem(bPtr, bPtr->highlightedItem);
 780
 781                 if (bPtr->flags.pullsDown) {
 782                     for (i=0; i<MENU_BLINK_COUNT; i++) {
 783                         paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 784                         XSync(bPtr->view->screen->display, 0);
 785                         wusleep(MENU_BLINK_DELAY);
 786                         paintMenuEntry(bPtr, bPtr->highlightedItem, True);
 787                         XSync(bPtr->view->screen->display, 0);
 788                         wusleep(MENU_BLINK_DELAY);
 789                     }
 790                 }
 791                 paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 792                 popDownMenu(bPtr);
 793                 if (bPtr->action)
 794                     (*bPtr->action)(bPtr, bPtr->clientData);
 795             }
 796         }
 797         if (bPtr->menuView->flags.mapped)
 798             popDownMenu(bPtr);
 799         break;
 800     }
 801 }
 802
 803
 804
 805 static void
 806 destroyPopUpButton(PopUpButton *bPtr)
 807 {
 808     WMMenuItem *item;
 809     WMBagIterator i;
 810
 811     if (bPtr->timer) {
 812         WMDeleteTimerHandler(bPtr->timer);
 813     }
 814
 815     WM_ITERATE_BAG(bPtr->items, item, i) {
 816         WMDestroyMenuItem(item);
 817     }
 818     WMFreeBag(bPtr->items);
 819
 820     if (bPtr->caption)
 821         wfree(bPtr->caption);
 822
 823     /* have to destroy explicitly because the popup is a toplevel */
 824     W_DestroyView(bPtr->menuView);
 825
 826     wfree(bPtr);
 827 }