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