WINGs/wpopupbutton.c

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