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, height, 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         height = itemHeight * itemCount;
 343         yo = (itemHeight - WMFontHeight(scr->normalFont)) / 2;
 344
 345         if (!highlight) {
 346                 XClearArea(scr->display, bPtr->menuView->window, 0, index * itemHeight, width, itemHeight, False);
 347                 return;
 348         } else if (index < 0 && bPtr->flags.pullsDown) {
 349                 return;
 350         }
 351
 352         XFillRectangle(scr->display, bPtr->menuView->window, WMColorGC(scr->white),
 353                        1, index * itemHeight + 1, width - 3, itemHeight - 3);
 354
 355         title = WMGetPopUpButtonItem(bPtr, index);
 356
 357         W_DrawRelief(scr, bPtr->menuView->window, 0, index * itemHeight, width, itemHeight, WRRaised);
 358
 359         W_PaintText(bPtr->menuView, bPtr->menuView->window, scr->normalFont, 6,
 360                     index * itemHeight + yo, width, WALeft, scr->black, False, title, strlen(title));
 361
 362         if (!bPtr->flags.pullsDown && index == bPtr->selectedItemIndex) {
 363                 XCopyArea(scr->display, scr->popUpIndicator->pixmap,
 364                           bPtr->menuView->window, scr->copyGC, 0, 0,
 365                           scr->popUpIndicator->width, scr->popUpIndicator->height,
 366                           width - scr->popUpIndicator->width - 4,
 367                           index * itemHeight + (itemHeight - scr->popUpIndicator->height) / 2);
 368         }
 369 }
 370
 371 Pixmap makeMenuPixmap(PopUpButton * bPtr)
 372 {
 373         Pixmap pixmap;
 374         W_Screen *scr = bPtr->view->screen;
 375         WMMenuItem *item;
 376         WMArrayIterator iter;
 377         int yo, i;
 378         int width, height, itemHeight;
 379
 380         itemHeight = bPtr->view->size.height;
 381         width = bPtr->view->size.width;
 382         height = itemHeight * WMGetArrayItemCount(bPtr->items);
 383         yo = (itemHeight - WMFontHeight(scr->normalFont)) / 2;
 384
 385         pixmap = XCreatePixmap(scr->display, bPtr->view->window, width, height, scr->depth);
 386
 387         XFillRectangle(scr->display, pixmap, WMColorGC(scr->gray), 0, 0, width, height);
 388
 389         i = 0;
 390         WM_ITERATE_ARRAY(bPtr->items, item, iter) {
 391                 WMColor *color;
 392                 char *text;
 393
 394                 text = WMGetMenuItemTitle(item);
 395
 396                 W_DrawRelief(scr, pixmap, 0, i * itemHeight, width, itemHeight, WRRaised);
 397
 398                 if (!WMGetMenuItemEnabled(item))
 399                         color = scr->darkGray;
 400                 else
 401                         color = scr->black;
 402
 403                 W_PaintText(bPtr->menuView, pixmap, scr->normalFont, 6,
 404                             i * itemHeight + yo, width, WALeft, color, False, text, strlen(text));
 405
 406                 if (!bPtr->flags.pullsDown && i == bPtr->selectedItemIndex) {
 407                         XCopyArea(scr->display, scr->popUpIndicator->pixmap, pixmap,
 408                                   scr->copyGC, 0, 0, scr->popUpIndicator->width,
 409                                   scr->popUpIndicator->height,
 410                                   width - scr->popUpIndicator->width - 4,
 411                                   i * itemHeight + (itemHeight - scr->popUpIndicator->height) / 2);
 412                 }
 413
 414                 i++;
 415         }
 416
 417         return pixmap;
 418 }
 419
 420 static void resizeMenu(PopUpButton * bPtr)
 421 {
 422         int height;
 423
 424         height = WMGetArrayItemCount(bPtr->items) * bPtr->view->size.height;
 425         if (height > 0)
 426                 W_ResizeView(bPtr->menuView, bPtr->view->size.width, height);
 427 }
 428
 429 static void popUpMenu(PopUpButton * bPtr)
 430 {
 431         W_Screen *scr = bPtr->view->screen;
 432         Window dummyW;
 433         int x, y;
 434
 435         if (!bPtr->flags.enabled)
 436                 return;
 437
 438         if (!bPtr->menuView->flags.realized) {
 439                 W_RealizeView(bPtr->menuView);
 440                 resizeMenu(bPtr);
 441         }
 442
 443         if (WMGetArrayItemCount(bPtr->items) < 1)
 444                 return;
 445
 446         XTranslateCoordinates(scr->display, bPtr->view->window, scr->rootWin, 0, 0, &x, &y, &dummyW);
 447
 448         if (bPtr->flags.pullsDown) {
 449                 y += bPtr->view->size.height;
 450         } else {
 451                 y -= bPtr->view->size.height * bPtr->selectedItemIndex;
 452         }
 453         W_MoveView(bPtr->menuView, x, y);
 454
 455         XSetWindowBackgroundPixmap(scr->display, bPtr->menuView->window, makeMenuPixmap(bPtr));
 456         XClearWindow(scr->display, bPtr->menuView->window);
 457
 458         if (W_VIEW_WIDTH(bPtr->menuView) != W_VIEW_WIDTH(bPtr->view))
 459                 resizeMenu(bPtr);
 460
 461         W_MapView(bPtr->menuView);
 462
 463         bPtr->highlightedItem = 0;
 464         if (!bPtr->flags.pullsDown && bPtr->selectedItemIndex < 0)
 465                 paintMenuEntry(bPtr, bPtr->selectedItemIndex, True);
 466 }
 467
 468 static void popDownMenu(PopUpButton * bPtr)
 469 {
 470         W_UnmapView(bPtr->menuView);
 471 }
 472
 473 static void autoScroll(void *data)
 474 {
 475         PopUpButton *bPtr = (PopUpButton *) data;
 476         int scrHeight = WMWidgetScreen(bPtr)->rootView->size.height;
 477         int repeat = 0;
 478         int dy = 0;
 479
 480         if (bPtr->scrollStartY >= scrHeight - 1
 481             && bPtr->menuView->pos.y + bPtr->menuView->size.height >= scrHeight - 1) {
 482                 repeat = 1;
 483
 484                 if (bPtr->menuView->pos.y + bPtr->menuView->size.height - 5 <= scrHeight - 1) {
 485                         dy = scrHeight - 1 - (bPtr->menuView->pos.y + bPtr->menuView->size.height);
 486                 } else
 487                         dy = -5;
 488
 489         } else if (bPtr->scrollStartY <= 1 && bPtr->menuView->pos.y < 1) {
 490                 repeat = 1;
 491
 492                 if (bPtr->menuView->pos.y + 5 > 1)
 493                         dy = 1 - bPtr->menuView->pos.y;
 494                 else
 495                         dy = 5;
 496         }
 497
 498         if (repeat) {
 499                 int oldItem;
 500
 501                 W_MoveView(bPtr->menuView, bPtr->menuView->pos.x, bPtr->menuView->pos.y + dy);
 502
 503                 oldItem = bPtr->highlightedItem;
 504                 bPtr->highlightedItem = (bPtr->scrollStartY - bPtr->menuView->pos.y)
 505                     / bPtr->view->size.height;
 506
 507                 if (oldItem != bPtr->highlightedItem) {
 508                         WMMenuItem *item;
 509
 510                         paintMenuEntry(bPtr, oldItem, False);
 511
 512                         if (bPtr->highlightedItem >= 0 && bPtr->highlightedItem < WMGetArrayItemCount(bPtr->items)) {
 513                                 item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 514                                 paintMenuEntry(bPtr, bPtr->highlightedItem, WMGetMenuItemEnabled(item));
 515                         } else {
 516                                 bPtr->highlightedItem = -1;
 517                         }
 518                 }
 519
 520                 bPtr->timer = WMAddTimerHandler(SCROLL_DELAY, autoScroll, bPtr);
 521         } else {
 522                 bPtr->timer = NULL;
 523         }
 524 }
 525
 526 static void wheelScrollUp(PopUpButton * bPtr)
 527 {
 528         int testIndex = bPtr->selectedItemIndex - 1;
 529
 530         while (testIndex >= 0 && !WMGetPopUpButtonItemEnabled(bPtr, testIndex))
 531                 testIndex--;
 532         if (testIndex != -1) {
 533                 WMSetPopUpButtonSelectedItem(bPtr, testIndex);
 534                 if (bPtr->action)
 535                         (*bPtr->action) (bPtr, bPtr->clientData);
 536         }
 537 }
 538
 539 static void wheelScrollDown(PopUpButton * bPtr)
 540 {
 541         int itemCount = WMGetArrayItemCount(bPtr->items);
 542         int testIndex = bPtr->selectedItemIndex + 1;
 543
 544         while (testIndex < itemCount && !WMGetPopUpButtonItemEnabled(bPtr, testIndex))
 545                 testIndex++;
 546         if (testIndex != itemCount) {
 547                 WMSetPopUpButtonSelectedItem(bPtr, testIndex);
 548                 if (bPtr->action)
 549                         (*bPtr->action) (bPtr, bPtr->clientData);
 550         }
 551 }
 552
 553 static void handleActionEvents(XEvent * event, void *data)
 554 {
 555         PopUpButton *bPtr = (PopUpButton *) data;
 556         int oldItem;
 557         int scrHeight = WMWidgetScreen(bPtr)->rootView->size.height;
 558
 559         CHECK_CLASS(data, WC_PopUpButton);
 560
 561         if (WMGetArrayItemCount(bPtr->items) < 1)
 562                 return;
 563
 564         switch (event->type) {
 565                 /* called for menuView */
 566         case Expose:
 567                 paintMenuEntry(bPtr, bPtr->highlightedItem, True);
 568                 break;
 569
 570         case LeaveNotify:
 571                 bPtr->flags.insideMenu = 0;
 572                 if (bPtr->menuView->flags.mapped)
 573                         paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 574                 bPtr->highlightedItem = -1;
 575                 break;
 576
 577         case EnterNotify:
 578                 bPtr->flags.insideMenu = 1;
 579                 break;
 580
 581         case MotionNotify:
 582                 if (bPtr->flags.insideMenu) {
 583                         oldItem = bPtr->highlightedItem;
 584                         bPtr->highlightedItem = event->xmotion.y / bPtr->view->size.height;
 585                         if (oldItem != bPtr->highlightedItem) {
 586                                 WMMenuItem *item;
 587
 588                                 paintMenuEntry(bPtr, oldItem, False);
 589                                 if (bPtr->highlightedItem >= 0 &&
 590                                     bPtr->highlightedItem < WMGetArrayItemCount(bPtr->items)) {
 591                                         item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 592                                         paintMenuEntry(bPtr, bPtr->highlightedItem, WMGetMenuItemEnabled(item));
 593                                 } else {
 594                                         bPtr->highlightedItem = -1;
 595                                 }
 596
 597                         }
 598
 599                         if (event->xmotion.y_root >= scrHeight - 1 || event->xmotion.y_root <= 1) {
 600                                 bPtr->scrollStartY = event->xmotion.y_root;
 601                                 if (!bPtr->timer)
 602                                         autoScroll(bPtr);
 603                         } else if (bPtr->timer) {
 604                                 WMDeleteTimerHandler(bPtr->timer);
 605                                 bPtr->timer = NULL;
 606                         }
 607                 }
 608                 break;
 609
 610                 /* called for bPtr->view */
 611         case ButtonPress:
 612                 if (!bPtr->flags.enabled)
 613                         break;
 614
 615                 if (event->xbutton.button == WINGsConfiguration.mouseWheelUp) {
 616                         if (!bPtr->menuView->flags.mapped && !bPtr->flags.pullsDown) {
 617                                 wheelScrollUp(bPtr);
 618                         }
 619                         break;
 620                 } else if (event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 621                         if (!bPtr->menuView->flags.mapped && !bPtr->flags.pullsDown) {
 622                                 wheelScrollDown(bPtr);
 623                         }
 624                         break;
 625                 }
 626                 popUpMenu(bPtr);
 627                 if (!bPtr->flags.pullsDown) {
 628                         bPtr->highlightedItem = bPtr->selectedItemIndex;
 629                         bPtr->flags.insideMenu = 1;
 630                 } else {
 631                         bPtr->highlightedItem = -1;
 632                         bPtr->flags.insideMenu = 0;
 633                 }
 634                 XGrabPointer(bPtr->view->screen->display, bPtr->menuView->window,
 635                              False, ButtonReleaseMask | ButtonMotionMask | EnterWindowMask
 636                              | LeaveWindowMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
 637                 break;
 638
 639         case ButtonRelease:
 640                 if (event->xbutton.button == WINGsConfiguration.mouseWheelUp ||
 641                     event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
 642                         break;
 643                 }
 644                 XUngrabPointer(bPtr->view->screen->display, event->xbutton.time);
 645                 if (!bPtr->flags.pullsDown)
 646                         popDownMenu(bPtr);
 647
 648                 if (bPtr->timer) {
 649                         WMDeleteTimerHandler(bPtr->timer);
 650                         bPtr->timer = NULL;
 651                 }
 652
 653                 if (bPtr->flags.insideMenu && bPtr->highlightedItem >= 0) {
 654                         WMMenuItem *item;
 655
 656                         item = WMGetPopUpButtonMenuItem(bPtr, bPtr->highlightedItem);
 657
 658                         if (WMGetMenuItemEnabled(item)) {
 659                                 int i;
 660                                 WMSetPopUpButtonSelectedItem(bPtr, bPtr->highlightedItem);
 661
 662                                 if (bPtr->flags.pullsDown) {
 663                                         for (i = 0; i < MENU_BLINK_COUNT; i++) {
 664                                                 paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 665                                                 XSync(bPtr->view->screen->display, 0);
 666                                                 wusleep(MENU_BLINK_DELAY);
 667                                                 paintMenuEntry(bPtr, bPtr->highlightedItem, True);
 668                                                 XSync(bPtr->view->screen->display, 0);
 669                                                 wusleep(MENU_BLINK_DELAY);
 670                                         }
 671                                 }
 672                                 paintMenuEntry(bPtr, bPtr->highlightedItem, False);
 673                                 popDownMenu(bPtr);
 674                                 if (bPtr->action)
 675                                         (*bPtr->action) (bPtr, bPtr->clientData);
 676                         }
 677                 }
 678                 if (bPtr->menuView->flags.mapped)
 679                         popDownMenu(bPtr);
 680                 break;
 681         }
 682 }
 683
 684 static void destroyPopUpButton(PopUpButton * bPtr)
 685 {
 686         if (bPtr->timer) {
 687                 WMDeleteTimerHandler(bPtr->timer);
 688         }
 689
 690         WMFreeArray(bPtr->items);
 691
 692         if (bPtr->caption)
 693                 wfree(bPtr->caption);
 694
 695         /* have to destroy explicitly because the popup is a toplevel */
 696         W_DestroyView(bPtr->menuView);
 697
 698         wfree(bPtr);
 699 }