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