WPrefs.app/editmenu.c

   1 /* editmenu.c - editable menus
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 2000 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include <WINGsP.h>
  25 #include <WUtil.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <ctype.h>
  29
  30 #include "editmenu.h"
  31
  32 typedef struct W_EditMenuItem {
  33     W_Class widgetClass;
  34     WMView *view;
  35
  36     struct W_EditMenu *parent;
  37
  38     char *label;
  39     WMPixmap *pixmap;                  /* pixmap to show at left */
  40
  41     void *data;
  42     WMCallback *destroyData;
  43
  44     struct W_EditMenu *submenu;        /* if it's a cascade, NULL otherwise */
  45
  46     struct {
  47         unsigned isTitle:1;
  48         unsigned isHighlighted:1;
  49     } flags;
  50 } EditMenuItem;
  51
  52
  53 typedef struct W_EditMenu {
  54     W_Class widgetClass;
  55     WMView *view;
  56
  57     struct W_EditMenu *parent;
  58
  59     WMBag *items; /* EditMenuItem */
  60
  61     EditMenuItem *selectedItem;
  62
  63     WMTextField *tfield;
  64
  65     WMButton *closeB;
  66
  67     int titleHeight;
  68     int itemHeight;
  69
  70     WEditMenuDelegate *delegate;
  71
  72     /* item dragging */
  73     int draggedItem;
  74     int dragX, dragY;
  75
  76     /* only for non-standalone menu */
  77     WMSize maxSize;
  78     WMSize minSize;
  79
  80     struct {
  81         unsigned standalone:1;
  82         unsigned isTitled:1;
  83
  84         unsigned acceptsDrop:1;
  85         unsigned isFactory:1;
  86         unsigned isSelectable:1;
  87         unsigned isEditable:1;
  88
  89         unsigned isTornOff:1;
  90
  91         unsigned isDragging:1;
  92         unsigned isEditing:1;
  93     } flags;
  94 } EditMenu;
  95
  96
  97
  98 /******************** WEditMenuItem ********************/
  99
 100 static void destroyEditMenuItem(WEditMenuItem *iPtr);
 101 static void paintEditMenuItem(WEditMenuItem *iPtr);
 102 static void handleItemEvents(XEvent *event, void *data);
 103
 104 static void handleItemClick(XEvent *event, void *data);
 105
 106
 107 static W_Class EditMenuItemClass = 0;
 108
 109
 110 W_Class
 111 InitEditMenuItem(WMScreen *scr)
 112 {
 113     /* register our widget with WINGs and get our widget class ID */
 114     if (!EditMenuItemClass) {
 115         EditMenuItemClass = W_RegisterUserWidget();
 116     }
 117
 118     return EditMenuItemClass;
 119 }
 120
 121
 122 WEditMenuItem*
 123 WCreateEditMenuItem(WMWidget *parent, char *title, Bool isTitle)
 124 {
 125     WEditMenuItem *iPtr;
 126     WMScreen *scr = WMWidgetScreen(parent);
 127
 128     if (!EditMenuItemClass)
 129         InitEditMenuItem(scr);
 130
 131
 132     iPtr = wmalloc(sizeof(WEditMenuItem));
 133
 134     memset(iPtr, 0, sizeof(WEditMenuItem));
 135
 136     iPtr->widgetClass = EditMenuItemClass;
 137
 138     iPtr->view = W_CreateView(W_VIEW(parent));
 139     if (!iPtr->view) {
 140         free(iPtr);
 141         return NULL;
 142     }
 143     iPtr->view->self = iPtr;
 144
 145     iPtr->parent = parent;
 146
 147     iPtr->label = wstrdup(title);
 148
 149     iPtr->flags.isTitle = isTitle;
 150
 151     if (isTitle) {
 152         WMSetWidgetBackgroundColor(iPtr, WMBlackColor(scr));
 153     }
 154
 155     WMCreateEventHandler(iPtr->view, ExposureMask|StructureNotifyMask,
 156                          handleItemEvents, iPtr);
 157
 158     WMCreateEventHandler(iPtr->view, ButtonPressMask|ButtonReleaseMask
 159                          |ButtonMotionMask, handleItemClick, iPtr);
 160
 161
 162     return iPtr;
 163 }
 164
 165
 166 char *WGetEditMenuItemTitle(WEditMenuItem *item)
 167 {
 168     return item->label;
 169 }
 170
 171 void *WGetEditMenuItemData(WEditMenuItem *item)
 172 {
 173     return item->data;
 174 }
 175
 176
 177 void WSetEditMenuItemData(WEditMenuItem *item, void *data,
 178                            WMCallback *destroyer)
 179 {
 180     item->data = data;
 181     item->destroyData = destroyer;
 182 }
 183
 184
 185 void WSetEditMenuItemImage(WEditMenuItem *item, WMPixmap *pixmap)
 186 {
 187     if (item->pixmap)
 188         WMReleasePixmap(item->pixmap);
 189     item->pixmap = WMRetainPixmap(pixmap);
 190 }
 191
 192
 193 static void
 194 paintEditMenuItem(WEditMenuItem *iPtr)
 195 {
 196     WMScreen *scr = WMWidgetScreen(iPtr);
 197     WMColor *color;
 198     Window win = W_VIEW(iPtr)->window;
 199     int w = W_VIEW(iPtr)->size.width;
 200     int h = W_VIEW(iPtr)->size.height;
 201     WMFont *font = (iPtr->flags.isTitle ? scr->boldFont : scr->normalFont);
 202
 203     if (!iPtr->view->flags.realized)
 204         return;
 205
 206     color = scr->black;
 207     if (iPtr->flags.isTitle && !iPtr->flags.isHighlighted) {
 208         color = scr->white;
 209     }
 210
 211
 212     XClearWindow(scr->display, win);
 213
 214     W_DrawRelief(scr, win, 0, 0, w+1, h, WRRaised);
 215
 216     WMDrawString(scr, win, WMColorGC(color), font, 5, 3, iPtr->label,
 217                  strlen(iPtr->label));
 218
 219     if (iPtr->pixmap) {
 220         WMSize size = WMGetPixmapSize(iPtr->pixmap);
 221
 222         WMDrawPixmap(iPtr->pixmap, win, w - size.width - 5,
 223                      (h - size.height)/2);
 224     } else if (iPtr->submenu) {
 225         /* draw the cascade indicator */
 226         XDrawLine(scr->display,win,WMColorGC(scr->darkGray),
 227                   w-11, 6, w-6, h/2-1);
 228         XDrawLine(scr->display,win,WMColorGC(scr->white),
 229                   w-11, h-8, w-6, h/2-1);
 230         XDrawLine(scr->display,win,WMColorGC(scr->black),
 231                   w-12, 6, w-12, h-8);
 232     }
 233 }
 234
 235
 236 static void
 237 highlightItem(WEditMenuItem *iPtr, Bool high)
 238 {
 239     if (iPtr->flags.isTitle)
 240         return;
 241
 242     iPtr->flags.isHighlighted = high;
 243
 244     if (high) {
 245         WMSetWidgetBackgroundColor(iPtr, WMWhiteColor(WMWidgetScreen(iPtr)));
 246     } else {
 247         if (!iPtr->flags.isTitle) {
 248             WMSetWidgetBackgroundColor(iPtr,
 249                                        WMGrayColor(WMWidgetScreen(iPtr)));
 250         } else {
 251             WMSetWidgetBackgroundColor(iPtr,
 252                                        WMBlackColor(WMWidgetScreen(iPtr)));
 253         }
 254     }
 255 }
 256
 257
 258 static int
 259 getItemTextWidth(WEditMenuItem *iPtr)
 260 {
 261     WMScreen *scr = WMWidgetScreen(iPtr);
 262
 263     if (iPtr->flags.isTitle) {
 264         return WMWidthOfString(scr->boldFont, iPtr->label,
 265                                strlen(iPtr->label));
 266     } else {
 267         return WMWidthOfString(scr->normalFont, iPtr->label,
 268                                strlen(iPtr->label));
 269     }
 270 }
 271
 272
 273
 274 static void
 275 handleItemEvents(XEvent *event, void *data)
 276 {
 277     WEditMenuItem *iPtr = (WEditMenuItem*)data;
 278
 279     switch (event->type) {
 280      case Expose:
 281         if (event->xexpose.count!=0)
 282             break;
 283         paintEditMenuItem(iPtr);
 284         break;
 285
 286      case DestroyNotify:
 287         destroyEditMenuItem(iPtr);
 288         break;
 289     }
 290 }
 291
 292
 293 static void
 294 destroyEditMenuItem(WEditMenuItem *iPtr)
 295 {
 296     if (iPtr->label)
 297         free(iPtr->label);
 298     if (iPtr->data && iPtr->destroyData)
 299         (*iPtr->destroyData)(iPtr->data);
 300
 301     free(iPtr);
 302 }
 303
 304
 305
 306 /******************** WEditMenu *******************/
 307
 308 static void destroyEditMenu(WEditMenu *mPtr);
 309
 310 static void updateMenuContents(WEditMenu *mPtr);
 311
 312 static void handleEvents(XEvent *event, void *data);
 313
 314 static void editItemLabel(WEditMenuItem *item);
 315 static void stopEditItem(WEditMenu *menu, Bool apply);
 316
 317
 318 static void unmapMenu(WEditMenu *menu);
 319 static void deselectItem(WEditMenu *menu);
 320
 321
 322 static W_Class EditMenuClass = 0;
 323
 324
 325 W_Class
 326 InitEditMenu(WMScreen *scr)
 327 {
 328     /* register our widget with WINGs and get our widget class ID */
 329     if (!EditMenuClass) {
 330
 331         EditMenuClass = W_RegisterUserWidget();
 332     }
 333
 334     return EditMenuClass;
 335 }
 336
 337
 338
 339 typedef struct {
 340     int flags;
 341     int window_style;
 342     int window_level;
 343     int reserved;
 344     Pixmap miniaturize_pixmap;         /* pixmap for miniaturize button */
 345     Pixmap close_pixmap;               /* pixmap for close button */
 346     Pixmap miniaturize_mask;           /* miniaturize pixmap mask */
 347     Pixmap close_mask;                 /* close pixmap mask */
 348     int extra_flags;
 349 } GNUstepWMAttributes;
 350
 351
 352 #define GSWindowStyleAttr       (1<<0)
 353 #define GSWindowLevelAttr       (1<<1)
 354
 355
 356 static void
 357 writeGNUstepWMAttr(WMScreen *scr, Window window, GNUstepWMAttributes *attr)
 358 {
 359     unsigned long data[9];
 360
 361     /* handle idiot compilers where array of CARD32 != struct of CARD32 */
 362     data[0] = attr->flags;
 363     data[1] = attr->window_style;
 364     data[2] = attr->window_level;
 365     data[3] = 0;                       /* reserved */
 366     /* The X protocol says XIDs are 32bit */
 367     data[4] = attr->miniaturize_pixmap;
 368     data[5] = attr->close_pixmap;
 369     data[6] = attr->miniaturize_mask;
 370     data[7] = attr->close_mask;
 371     data[8] = attr->extra_flags;
 372     XChangeProperty(scr->display, window, scr->attribsAtom, scr->attribsAtom,
 373                     32, PropModeReplace,  (unsigned char *)data, 9);
 374 }
 375
 376
 377 static void
 378 realizeObserver(void *self, WMNotification *not)
 379 {
 380     WEditMenu *menu = (WEditMenu*)self;
 381     GNUstepWMAttributes attribs;
 382
 383     memset(&attribs, 0, sizeof(GNUstepWMAttributes));
 384     attribs.flags = GSWindowStyleAttr|GSWindowLevelAttr;
 385     attribs.window_style = WMBorderlessWindowMask;
 386     attribs.window_level = WMSubmenuWindowLevel;
 387
 388     writeGNUstepWMAttr(WMWidgetScreen(menu), menu->view->window, &attribs);
 389 }
 390
 391
 392 static void
 393 itemSelectObserver(void *self, WMNotification *notif)
 394 {
 395     WEditMenu *menu = (WEditMenu*)self;
 396     WEditMenu *rmenu;
 397
 398     rmenu = (WEditMenu*)WMGetNotificationObject(notif);
 399     /* check whether rmenu is from the same hierarchy of menu? */
 400
 401     if (rmenu == menu) {
 402         return;
 403     }
 404
 405     if (menu->selectedItem && !menu->selectedItem->submenu) {
 406         deselectItem(menu);
 407     }
 408 }
 409
 410
 411 static WEditMenu*
 412 makeEditMenu(WMScreen *scr, WMWidget *parent, char *title)
 413 {
 414     WEditMenu *mPtr;
 415     WEditMenuItem *item;
 416
 417     if (!EditMenuClass)
 418         InitEditMenu(scr);
 419
 420
 421     mPtr = wmalloc(sizeof(WEditMenu));
 422     memset(mPtr, 0, sizeof(WEditMenu));
 423
 424     mPtr->widgetClass = EditMenuClass;
 425
 426     if (parent) {
 427         mPtr->view = W_CreateView(W_VIEW(parent));
 428         mPtr->flags.standalone = 0;
 429     } else {
 430         mPtr->view = W_CreateTopView(scr);
 431         mPtr->flags.standalone = 1;
 432     }
 433     if (!mPtr->view) {
 434         free(mPtr);
 435         return NULL;
 436     }
 437     mPtr->view->self = mPtr;
 438
 439     mPtr->flags.isSelectable = 1;
 440     mPtr->flags.isEditable = 1;
 441
 442     W_SetViewBackgroundColor(mPtr->view, scr->darkGray);
 443
 444     WMAddNotificationObserver(realizeObserver, mPtr,
 445                               WMViewRealizedNotification, mPtr->view);
 446
 447     WMAddNotificationObserver(itemSelectObserver, mPtr,
 448                               "EditMenuItemSelected", NULL);
 449
 450     mPtr->items = WMCreateBag(4);
 451
 452     WMCreateEventHandler(mPtr->view, ExposureMask|StructureNotifyMask,
 453                          handleEvents, mPtr);
 454
 455
 456     if (title != NULL) {
 457         item = WCreateEditMenuItem(mPtr, title, True);
 458
 459         WMMapWidget(item);
 460         WMPutInBag(mPtr->items, item);
 461
 462         mPtr->flags.isTitled = 1;
 463     }
 464
 465     mPtr->itemHeight = WMFontHeight(scr->normalFont) + 6;
 466     mPtr->titleHeight = WMFontHeight(scr->boldFont) + 8;
 467
 468     updateMenuContents(mPtr);
 469
 470     return mPtr;
 471 }
 472
 473
 474 WEditMenu*
 475 WCreateEditMenu(WMScreen *scr, char *title)
 476 {
 477     return makeEditMenu(scr, NULL, title);
 478 }
 479
 480
 481 WEditMenu*
 482 WCreateEditMenuPad(WMWidget *parent)
 483 {
 484     return makeEditMenu(WMWidgetScreen(parent), parent, NULL);
 485 }
 486
 487
 488 void
 489 WSetEditMenuDelegate(WEditMenu *mPtr, WEditMenuDelegate *delegate)
 490 {
 491     mPtr->delegate = delegate;
 492 }
 493
 494
 495 WEditMenuItem*
 496 WInsertMenuItemWithTitle(WEditMenu *mPtr, int index, char *title)
 497 {
 498     WEditMenuItem *item;
 499
 500     item = WCreateEditMenuItem(mPtr, title, False);
 501
 502     WMMapWidget(item);
 503
 504     if (index >= WMGetBagItemCount(mPtr->items)) {
 505         WMPutInBag(mPtr->items, item);
 506     } else {
 507         if (index < 0)
 508             index = 0;
 509         if (mPtr->flags.isTitled)
 510             index++;
 511         WMInsertInBag(mPtr->items, index, item);
 512     }
 513
 514     updateMenuContents(mPtr);
 515
 516     return item;
 517 }
 518
 519
 520 WEditMenuItem*
 521 WGetEditMenuItem(WEditMenu *mPtr, int index)
 522 {
 523     if (index >= WMGetBagItemCount(mPtr->items))
 524         return NULL;
 525     else
 526         return WMGetFromBag(mPtr->items, index + (mPtr->flags.isTitled ? 1 : 0));
 527 }
 528
 529
 530 WEditMenuItem*
 531 WAddMenuItemWithTitle(WEditMenu *mPtr, char *title)
 532 {
 533     return WInsertMenuItemWithTitle(mPtr, WMGetBagItemCount(mPtr->items),
 534                                     title);
 535 }
 536
 537
 538
 539 void
 540 WSetEditMenuTitle(WEditMenu *mPtr, char *title)
 541 {
 542     WEditMenuItem *item;
 543
 544     item = WMGetFromBag(mPtr->items, 0);
 545
 546     free(item->label);
 547     item->label = wstrdup(title);
 548     updateMenuContents(mPtr);
 549 }
 550
 551
 552
 553 char*
 554 WGetEditMenuTitle(WEditMenu *mPtr)
 555 {
 556     WEditMenuItem *item;
 557
 558     item = WMGetFromBag(mPtr->items, 0);
 559
 560     return item->label;
 561 }
 562
 563
 564 void
 565 WSetEditMenuAcceptsDrop(WEditMenu *mPtr, Bool flag)
 566 {
 567     mPtr->flags.acceptsDrop = flag;
 568 }
 569
 570
 571 void
 572 WSetEditMenuSubmenu(WEditMenu *mPtr, WEditMenuItem *item, WEditMenu *submenu)
 573 {
 574     item->submenu = submenu;
 575     submenu->parent = mPtr;
 576
 577     paintEditMenuItem(item);
 578 }
 579
 580
 581 WEditMenu*
 582 WGetEditMenuSubmenu(WEditMenu *mPtr, WEditMenuItem *item)
 583 {
 584     return item->submenu;
 585 }
 586
 587
 588 static int simpleMatch(void *a, void *b)
 589 {
 590     if (a == b)
 591         return 1;
 592     else
 593         return 0;
 594 }
 595
 596
 597 void
 598 WRemoveEditMenuItem(WEditMenu *mPtr, WEditMenuItem *item)
 599 {
 600     int index;
 601
 602     index = WMFindInBag(mPtr->items, simpleMatch, item);
 603
 604     if (index == WBNotFound) {
 605         return;
 606     }
 607
 608     WMDeleteFromBag(mPtr->items, index);
 609
 610     updateMenuContents(mPtr);
 611 }
 612
 613
 614 void
 615 WSetEditMenuSelectable(WEditMenu *mPtr, Bool flag)
 616 {
 617     mPtr->flags.isSelectable = flag;
 618 }
 619
 620
 621 void
 622 WSetEditMenuEditable(WEditMenu *mPtr, Bool flag)
 623 {
 624     mPtr->flags.isEditable = flag;
 625 }
 626
 627
 628 void
 629 WSetEditMenuIsFactory(WEditMenu *mPtr, Bool flag)
 630 {
 631     mPtr->flags.isFactory = flag;
 632 }
 633
 634
 635 void
 636 WSetEditMenuMinSize(WEditMenu *mPtr, WMSize size)
 637 {
 638     mPtr->minSize.width = size.width;
 639     mPtr->minSize.height = size.height;
 640 }
 641
 642
 643 void
 644 WSetEditMenuMaxSize(WEditMenu *mPtr, WMSize size)
 645 {
 646     mPtr->maxSize.width = size.width;
 647     mPtr->maxSize.height = size.height;
 648 }
 649
 650
 651 WMPoint
 652 WGetEditMenuLocationForSubmenu(WEditMenu *mPtr, WEditMenu *submenu)
 653 {
 654     WMBagIterator iter;
 655     WEditMenuItem *item;
 656     int y;
 657
 658     if (mPtr->flags.isTitled)
 659         y = -mPtr->titleHeight;
 660     else
 661         y = 0;
 662     WM_ITERATE_BAG(mPtr->items, item, iter) {
 663         if (item->submenu == submenu) {
 664             WMPoint pt = WMGetViewScreenPosition(mPtr->view);
 665
 666             return wmkpoint(pt.x + mPtr->view->size.width, pt.y + y);
 667         }
 668         y += W_VIEW_HEIGHT(item->view);
 669     }
 670
 671     puts("invalid submenu passed to WGetEditMenuLocationForSubmenu()");
 672
 673     return wmkpoint(0,0);
 674 }
 675
 676
 677
 678 static void
 679 closeMenuAction(WMWidget *w, void *data)
 680 {
 681     WEditMenu *menu = (WEditMenu*)data;
 682
 683     WMAddIdleHandler(WMDestroyWidget, menu->closeB);
 684     menu->closeB = NULL;
 685
 686     unmapMenu(menu);
 687 }
 688
 689
 690 void
 691 WTearOffEditMenu(WEditMenu *menu, WEditMenu *submenu)
 692 {
 693     WEditMenuItem *item;
 694
 695     submenu->flags.isTornOff = 1;
 696
 697     item = (WEditMenuItem*)WMGetFromBag(submenu->items, 0);
 698
 699     submenu->closeB = WMCreateCommandButton(item);
 700     WMResizeWidget(submenu->closeB, 15, 15);
 701     WMMoveWidget(submenu->closeB, W_VIEW(submenu)->size.width - 20, 3);
 702     WMRealizeWidget(submenu->closeB);
 703     WMSetButtonText(submenu->closeB, "X");
 704     WMSetButtonAction(submenu->closeB, closeMenuAction, submenu);
 705     WMMapWidget(submenu->closeB);
 706
 707     if (menu->selectedItem && menu->selectedItem->submenu == submenu)
 708         deselectItem(menu);
 709 }
 710
 711
 712
 713 Bool
 714 WEditMenuIsTornOff(WEditMenu *mPtr)
 715 {
 716     return mPtr->flags.isTornOff;
 717 }
 718
 719
 720 static void
 721 updateMenuContents(WEditMenu *mPtr)
 722 {
 723     int newW, newH;
 724     int w;
 725     int i;
 726     int iheight = mPtr->itemHeight;
 727     int offs = 1;
 728     WMBagIterator iter;
 729     WEditMenuItem *item;
 730
 731     newW = 0;
 732     newH = offs;
 733
 734     i = 0;
 735     WM_ITERATE_BAG(mPtr->items, item, iter) {
 736         w = getItemTextWidth(item);
 737
 738         newW = WMAX(w, newW);
 739
 740         WMMoveWidget(item, offs, newH);
 741         if (i == 0 && mPtr->flags.isTitled) {
 742             newH += mPtr->titleHeight;
 743         } else {
 744             newH += iheight;
 745         }
 746         i = 1;
 747     }
 748
 749     newW += iheight + 10;
 750     newH--;
 751
 752     if (mPtr->minSize.width)
 753         newW = WMAX(newW, mPtr->minSize.width);
 754     if (mPtr->maxSize.width)
 755         newW = WMIN(newW, mPtr->maxSize.width);
 756
 757     if (mPtr->minSize.height)
 758         newH = WMAX(newH, mPtr->minSize.height);
 759     if (mPtr->maxSize.height)
 760         newH = WMIN(newH, mPtr->maxSize.height);
 761
 762     W_ResizeView(mPtr->view, newW, newH+1);
 763
 764     if (mPtr->closeB)
 765         WMMoveWidget(mPtr->closeB, newW - 20, 3);
 766
 767     newW -= 2*offs;
 768
 769     i = 0;
 770     WM_ITERATE_BAG(mPtr->items, item, iter) {
 771         if (i == 0 && mPtr->flags.isTitled) {
 772             WMResizeWidget(item, newW, mPtr->titleHeight);
 773         } else {
 774             WMResizeWidget(item, newW, iheight);
 775         }
 776         i = 1;
 777     }
 778 }
 779
 780
 781 static void
 782 unmapMenu(WEditMenu *menu)
 783 {
 784     WMUnmapWidget(menu);
 785
 786     if (menu->selectedItem) {
 787         deselectItem(menu);
 788     }
 789 }
 790
 791
 792 static void
 793 deselectItem(WEditMenu *menu)
 794 {
 795     WEditMenu *submenu;
 796     WEditMenuItem *item = menu->selectedItem;
 797
 798     highlightItem(item, False);
 799
 800     if (menu->delegate && menu->delegate->itemDeselected) {
 801         (*menu->delegate->itemDeselected)(menu->delegate, menu, item);
 802     }
 803     submenu = item->submenu;
 804
 805     if (submenu && !WEditMenuIsTornOff(submenu)) {
 806         unmapMenu(submenu);
 807     }
 808
 809     menu->selectedItem = NULL;
 810 }
 811
 812
 813 static void
 814 selectItem(WEditMenu *menu, WEditMenuItem *item)
 815 {
 816     if (!menu->flags.isSelectable || menu->selectedItem == item) {
 817         return;
 818     }
 819     if (menu->selectedItem) {
 820         deselectItem(menu);
 821     }
 822
 823     if (menu->flags.isEditing) {
 824         stopEditItem(menu, False);
 825     }
 826
 827     if (item && !item->flags.isTitle) {
 828         highlightItem(item, True);
 829
 830         if (item->submenu) {
 831             WMPoint pt;
 832             XSizeHints *hints;
 833
 834             hints = XAllocSizeHints();
 835
 836             pt = WGetEditMenuLocationForSubmenu(menu, item->submenu);
 837
 838             hints->flags = USPosition;
 839             hints->x = pt.x;
 840             hints->y = pt.y;
 841
 842             WMMoveWidget(item->submenu, pt.x, pt.y);
 843             XSetWMNormalHints(W_VIEW_DISPLAY(item->submenu->view),
 844                               W_VIEW_DRAWABLE(item->submenu->view),
 845                               hints);
 846             XFree(hints);
 847             WMMapWidget(item->submenu);
 848
 849             item->submenu->flags.isTornOff = 0;
 850         }
 851
 852         WMPostNotificationName("EditMenuItemSelected", menu, NULL);
 853
 854         if (menu->delegate && menu->delegate->itemSelected) {
 855             (*menu->delegate->itemSelected)(menu->delegate, menu, item);
 856         }
 857     }
 858
 859     menu->selectedItem = item;
 860 }
 861
 862
 863 static void
 864 paintMenu(WEditMenu *mPtr)
 865 {
 866     W_View *view = mPtr->view;
 867
 868     W_DrawRelief(W_VIEW_SCREEN(view), W_VIEW_DRAWABLE(view), 0, 0,
 869                  W_VIEW_WIDTH(view), W_VIEW_HEIGHT(view), WRSimple);
 870 }
 871
 872
 873 static void
 874 handleEvents(XEvent *event, void *data)
 875 {
 876     WEditMenu *mPtr = (WEditMenu*)data;
 877
 878     switch (event->type) {
 879      case DestroyNotify:
 880         destroyEditMenu(mPtr);
 881         break;
 882
 883      case Expose:
 884         if (event->xexpose.count == 0)
 885             paintMenu(mPtr);
 886         break;
 887     }
 888 }
 889
 890
 891
 892
 893 /* -------------------------- Menu Label Editing ------------------------ */
 894
 895
 896 static void
 897 stopEditItem(WEditMenu *menu, Bool apply)
 898 {
 899     char *text;
 900
 901     if (apply) {
 902         text = WMGetTextFieldText(menu->tfield);
 903
 904         free(menu->selectedItem->label);
 905         menu->selectedItem->label = wstrdup(text);
 906
 907         updateMenuContents(menu);
 908
 909         if (menu->delegate && menu->delegate->itemEdited) {
 910             (*menu->delegate->itemEdited)(menu->delegate, menu,
 911                                           menu->selectedItem);
 912         }
 913
 914     }
 915     WMUnmapWidget(menu->tfield);
 916     menu->flags.isEditing = 0;
 917 }
 918
 919
 920 static void
 921 textEndedEditing(struct WMTextFieldDelegate *self, WMNotification *notif)
 922 {
 923     WEditMenu *menu = (WEditMenu*)self->data;
 924     int reason;
 925     int i;
 926     WEditMenuItem *item;
 927
 928     if (!menu->flags.isEditing)
 929         return;
 930
 931     reason = (int)WMGetNotificationClientData(notif);
 932
 933     switch (reason) {
 934      case WMEscapeTextMovement:
 935         stopEditItem(menu, False);
 936         break;
 937
 938      case WMReturnTextMovement:
 939         stopEditItem(menu, True);
 940         break;
 941
 942      case WMTabTextMovement:
 943         stopEditItem(menu, True);
 944
 945         i = WMFindInBag(menu->items, simpleMatch, menu->selectedItem);
 946         item = WMGetFromBag(menu->items, i+1);
 947         if (item != NULL) {
 948             selectItem(menu, item);
 949             editItemLabel(item);
 950         }
 951         break;
 952
 953      case WMBacktabTextMovement:
 954         stopEditItem(menu, True);
 955
 956         i = WMFindInBag(menu->items, simpleMatch, menu->selectedItem);
 957         item = WMGetFromBag(menu->items, i-1);
 958         if (item != NULL) {
 959             selectItem(menu, item);
 960             editItemLabel(item);
 961         }
 962         break;
 963     }
 964 }
 965
 966
 967
 968 static WMTextFieldDelegate textFieldDelegate = {
 969     NULL,
 970         NULL,
 971         NULL,
 972         textEndedEditing,
 973         NULL,
 974         NULL
 975 };
 976
 977
 978 static void
 979 editItemLabel(WEditMenuItem *item)
 980 {
 981     WEditMenu *mPtr = item->parent;
 982     WMTextField *tf;
 983     int i;
 984
 985     if (!mPtr->flags.isEditable) {
 986         return;
 987     }
 988
 989     if (!mPtr->tfield) {
 990         mPtr->tfield = WMCreateTextField(mPtr);
 991         WMSetTextFieldBeveled(mPtr->tfield, False);
 992         WMRealizeWidget(mPtr->tfield);
 993
 994         textFieldDelegate.data = mPtr;
 995
 996         WMSetTextFieldDelegate(mPtr->tfield, &textFieldDelegate);
 997     }
 998     tf = mPtr->tfield;
 999
1000     i = WMFindInBag(mPtr->items, simpleMatch, item);
1001
1002     WMSetTextFieldText(tf, item->label);
1003     WMSelectTextFieldRange(tf, wmkrange(0, strlen(item->label)));
1004     WMResizeWidget(tf, mPtr->view->size.width, mPtr->itemHeight);
1005     WMMoveWidget(tf, 0, item->view->pos.y);
1006     WMMapWidget(tf);
1007     WMSetFocusToWidget(tf);
1008
1009     mPtr->flags.isEditing = 1;
1010 }
1011
1012
1013
1014 /* -------------------------------------------------- */
1015
1016
1017 static void
1018 slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
1019 {
1020     double x, y, dx, dy;
1021     int i;
1022     int iterations;
1023
1024     iterations = WMIN(25, WMAX(abs(dstX-srcX), abs(dstY-srcY)));
1025
1026     x = srcX;
1027     y = srcY;
1028
1029     dx = (double)(dstX-srcX)/iterations;
1030     dy = (double)(dstY-srcY)/iterations;
1031
1032     for (i = 0; i <= iterations; i++) {
1033         XMoveWindow(dpy, win, x, y);
1034         XFlush(dpy);
1035
1036         wusleep(800);
1037
1038         x += dx;
1039         y += dy;
1040     }
1041 }
1042
1043
1044 static int errorHandler(Display *d, XErrorEvent *ev)
1045 {
1046     /* just ignore */
1047     return 0;
1048 }
1049
1050
1051 static WEditMenu*
1052 findMenuInWindow(Display *dpy, Window toplevel, int x, int y)
1053 {
1054     Window foo, bar;
1055     Window *children;
1056     unsigned nchildren;
1057     int i;
1058     WEditMenu *menu;
1059     WMView *view;
1060     int (*oldHandler)(Display *, XErrorEvent *);
1061
1062     view = W_GetViewForXWindow(dpy, toplevel);
1063     if (view && view->self && WMWidgetClass(view->self) == EditMenuClass) {
1064         menu = (WEditMenu*)view->self;
1065         if (menu->flags.acceptsDrop) {
1066             return menu;
1067         }
1068     }
1069
1070     if (!XQueryTree(dpy, toplevel, &foo, &bar,
1071                     &children, &nchildren) || children == NULL) {
1072         return NULL;
1073     }
1074
1075     oldHandler = XSetErrorHandler(errorHandler);
1076
1077     /* first window that contains the point is the one */
1078     for (i = nchildren-1; i >= 0; i--) {
1079         XWindowAttributes attr;
1080
1081         if (XGetWindowAttributes(dpy, children[i], &attr)
1082             && attr.map_state == IsViewable
1083             && x >= attr.x && y >= attr.y
1084             && x < attr.x + attr.width && y < attr.y + attr.height) {
1085             Window tmp;
1086
1087             tmp = children[i];
1088
1089             menu = findMenuInWindow(dpy, tmp, x - attr.x, y - attr.y);
1090             if (menu) {
1091                 XFree(children);
1092                 return menu;
1093             }
1094         }
1095     }
1096
1097     XSetErrorHandler(oldHandler);
1098
1099     XFree(children);
1100     return NULL;
1101 }
1102
1103
1104 static void
1105 handleDragOver(WEditMenu *menu, WMView *view, WEditMenuItem *item,
1106                int x, int y)
1107 {
1108     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1109     Window blaw;
1110     int mx, my;
1111     int offs;
1112
1113     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1114                           scr->rootWin, 0, 0, &mx, &my, &blaw);
1115
1116     offs = menu->flags.standalone ? 0 : 1;
1117
1118     W_MoveView(view, mx + offs, y);
1119     if (view->size.width != menu->view->size.width) {
1120         W_ResizeView(view, menu->view->size.width - 2*offs,
1121                      menu->itemHeight);
1122         W_ResizeView(item->view, menu->view->size.width - 2*offs,
1123                      menu->itemHeight);
1124     }
1125 }
1126
1127
1128 static void
1129 handleItemDrop(WEditMenu *menu, WEditMenuItem *item, int x, int y)
1130 {
1131     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1132     Window blaw;
1133     int mx, my;
1134     int index;
1135
1136     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1137                           scr->rootWin, 0, 0, &mx, &my, &blaw);
1138
1139     index = y - my;
1140     if (menu->flags.isTitled) {
1141         index -= menu->titleHeight;
1142     }
1143     index = (index + menu->itemHeight/2) / menu->itemHeight;
1144     if (index < 0)
1145         index = 0;
1146
1147     if (menu->flags.isTitled) {
1148         index++;
1149     }
1150
1151     if (index > WMGetBagItemCount(menu->items)) {
1152         WMPutInBag(menu->items, item);
1153     } else {
1154         WMInsertInBag(menu->items, index, item);
1155     }
1156
1157     W_ReparentView(item->view, menu->view, 0, index*menu->itemHeight);
1158
1159     item->parent = menu;
1160     if (item->submenu) {
1161         item->submenu->parent = menu;
1162     }
1163
1164     updateMenuContents(menu);
1165 }
1166
1167
1168 static void
1169 dragMenu(WEditMenu *menu)
1170 {
1171     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1172     XEvent ev;
1173     Bool done = False;
1174     int dx, dy;
1175     unsigned blau;
1176     Window blaw;
1177
1178     XGetGeometry(scr->display, W_VIEW_DRAWABLE(menu->view), &blaw, &dx, &dy,
1179                  &blau, &blau, &blau, &blau);
1180
1181     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1182                           scr->rootWin, dx, dy, &dx, &dy, &blaw);
1183
1184     dx = menu->dragX - dx;
1185     dy = menu->dragY - dy;
1186
1187     XGrabPointer(scr->display, scr->rootWin, False,
1188                  ButtonReleaseMask|ButtonMotionMask,
1189                  GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
1190                  CurrentTime);
1191
1192     if (menu->parent)
1193         WTearOffEditMenu(menu->parent, menu);
1194
1195     while (!done) {
1196         WMNextEvent(scr->display, &ev);
1197
1198         switch (ev.type) {
1199          case ButtonRelease:
1200             done = True;
1201             break;
1202
1203          case MotionNotify:
1204             WMMoveWidget(menu, ev.xmotion.x_root - dx,
1205                          ev.xmotion.y_root - dy);
1206             break;
1207
1208          default:
1209             WMHandleEvent(&ev);
1210             break;
1211         }
1212     }
1213
1214     XUngrabPointer(scr->display, CurrentTime);
1215 }
1216
1217
1218 static WEditMenu*
1219 duplicateMenu(WEditMenu *menu)
1220 {
1221     WEditMenu *nmenu;
1222     WEditMenuItem *title;
1223
1224     if (menu->flags.isTitled) {
1225         title = WMGetFromBag(menu->items, 0);
1226     }
1227
1228     nmenu = WCreateEditMenu(WMWidgetScreen(menu), title->label);
1229
1230     memcpy(&nmenu->flags, &menu->flags, sizeof(menu->flags));
1231     nmenu->delegate = menu->delegate;
1232
1233     WMRealizeWidget(nmenu);
1234
1235     return nmenu;
1236 }
1237
1238
1239
1240 static WEditMenuItem*
1241 duplicateItem(WEditMenuItem *item)
1242 {
1243     WEditMenuItem *nitem;
1244
1245     nitem = WCreateEditMenuItem(item->parent, item->label, False);
1246     if (item->pixmap)
1247         nitem->pixmap = WMRetainPixmap(item->pixmap);
1248
1249     return nitem;
1250 }
1251
1252
1253 static void
1254 dragItem(WEditMenu *menu, WEditMenuItem *item)
1255 {
1256     Display *dpy = W_VIEW_DISPLAY(menu->view);
1257     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1258     int x, y;
1259     int dx, dy;
1260     Bool done = False;
1261     Window blaw;
1262     int blai;
1263     unsigned blau;
1264     Window win;
1265     WMView *dview;
1266     int orix, oriy;
1267     Bool enteredMenu = False;
1268     WMSize oldSize = item->view->size;
1269     WEditMenuItem *dritem = item;
1270     WEditMenu *dmenu = NULL;
1271
1272
1273     if (item->flags.isTitle) {
1274         WMRaiseWidget(menu);
1275
1276         dragMenu(menu);
1277
1278         return;
1279     }
1280
1281
1282     selectItem(menu, NULL);
1283
1284     win = scr->rootWin;
1285
1286     XTranslateCoordinates(dpy, W_VIEW_DRAWABLE(item->view), win,
1287                           0, 0, &orix, &oriy, &blaw);
1288
1289     dview = W_CreateUnmanagedTopView(scr);
1290     W_SetViewBackgroundColor(dview, scr->black);
1291     W_ResizeView(dview, W_VIEW_WIDTH(item->view), W_VIEW_HEIGHT(item->view));
1292     W_MoveView(dview, orix, oriy);
1293     W_RealizeView(dview);
1294
1295     if (menu->flags.isFactory) {
1296         dritem = duplicateItem(item);
1297
1298         W_ReparentView(dritem->view, dview, 0, 0);
1299         WMResizeWidget(dritem, oldSize.width, oldSize.height);
1300         WMRealizeWidget(dritem);
1301         WMMapWidget(dritem);
1302     } else {
1303         W_ReparentView(item->view, dview, 0, 0);
1304     }
1305
1306     W_MapView(dview);
1307
1308     dx = menu->dragX - orix;
1309     dy = menu->dragY - oriy;
1310
1311     XGrabPointer(dpy, scr->rootWin, False,
1312                  ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
1313                  GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
1314                  CurrentTime);
1315
1316     while (!done) {
1317         XEvent ev;
1318
1319         WMNextEvent(dpy, &ev);
1320
1321         switch (ev.type) {
1322          case MotionNotify:
1323             XQueryPointer(dpy, win, &blaw, &blaw, &blai, &blai, &x, &y, &blau);
1324
1325             dmenu = findMenuInWindow(dpy, win, x, y);
1326
1327             if (dmenu) {
1328                 handleDragOver(dmenu, dview, dritem, x - dx, y - dy);
1329                 enteredMenu = True;
1330             } else {
1331                 if (enteredMenu) {
1332                     W_ResizeView(dview, oldSize.width, oldSize.height);
1333                     W_ResizeView(dritem->view, oldSize.width, oldSize.height);
1334                     enteredMenu = False;
1335                 }
1336                 W_MoveView(dview, x - dx, y - dy);
1337             }
1338
1339             break;
1340
1341          case ButtonRelease:
1342             done = True;
1343             break;
1344
1345          default:
1346             WMHandleEvent(&ev);
1347             break;
1348         }
1349     }
1350     XUngrabPointer(dpy, CurrentTime);
1351
1352
1353     if (!enteredMenu) {
1354         Bool rem = True;
1355
1356         if (!menu->flags.isFactory) {
1357             W_UnmapView(dview);
1358             if (menu->delegate && menu->delegate->shouldRemoveItem) {
1359                 rem = (*menu->delegate->shouldRemoveItem)(menu->delegate,
1360                                                           menu, item);
1361             }
1362             W_MapView(dview);
1363         }
1364
1365         if (!rem || menu->flags.isFactory) {
1366             slideWindow(dpy, W_VIEW_DRAWABLE(dview), x-dx, y-dy, orix, oriy);
1367
1368             if (!menu->flags.isFactory) {
1369                 WRemoveEditMenuItem(menu, dritem);
1370                 handleItemDrop(dmenu ? dmenu : menu, dritem, orix, oriy);
1371             }
1372         } else {
1373             WRemoveEditMenuItem(menu, dritem);
1374         }
1375     } else {
1376         WRemoveEditMenuItem(menu, dritem);
1377
1378         if (menu->delegate && menu->delegate->itemCloned
1379             && menu->flags.isFactory) {
1380             (*menu->delegate->itemCloned)(menu->delegate, menu,
1381                                           item, dritem);
1382         }
1383
1384         handleItemDrop(dmenu, dritem, x-dy, y-dy);
1385
1386         if (item->submenu && menu->flags.isFactory) {
1387             WEditMenu *submenu;
1388
1389             submenu = duplicateMenu(item->submenu);
1390             WSetEditMenuSubmenu(dmenu, dritem, submenu);
1391         }
1392     }
1393
1394     /* can't destroy now because we're being called from
1395      * the event handler of the item. and destroying now,
1396      * would mean destroying the item too in some cases.
1397      */
1398     WMAddIdleHandler((WMCallback*)W_DestroyView, dview);
1399 }
1400
1401
1402
1403 static void
1404 handleItemClick(XEvent *event, void *data)
1405 {
1406     WEditMenuItem *item = (WEditMenuItem*)data;
1407     WEditMenu *menu = item->parent;
1408
1409     switch (event->type) {
1410      case ButtonPress:
1411         selectItem(menu, item);
1412
1413         if (WMIsDoubleClick(event)) {
1414             editItemLabel(item);
1415         }
1416
1417         menu->flags.isDragging = 1;
1418         menu->dragX = event->xbutton.x_root;
1419         menu->dragY = event->xbutton.y_root;
1420         break;
1421
1422      case ButtonRelease:
1423         menu->flags.isDragging = 0;
1424         break;
1425
1426      case MotionNotify:
1427         if (menu->flags.isDragging) {
1428             if (abs(event->xbutton.x_root - menu->dragX) > 5
1429                 || abs(event->xbutton.y_root - menu->dragY) > 5) {
1430                 menu->flags.isDragging = 0;
1431                 dragItem(menu, item);
1432             }
1433         }
1434         break;
1435     }
1436 }
1437
1438
1439 static void
1440 destroyEditMenu(WEditMenu *mPtr)
1441 {
1442     WEditMenuItem *item;
1443     WMBagIterator iter;
1444
1445     WMRemoveNotificationObserver(mPtr);
1446
1447     WM_ITERATE_BAG(mPtr->items, item, iter) {
1448         if (item->submenu) {
1449             WMDestroyWidget(item->submenu);
1450         }
1451     }
1452
1453     WMFreeBag(mPtr->items);
1454
1455     free(mPtr);
1456 }
1457
1458
1459