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     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         free(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         free(iPtr->label);
 304     if (iPtr->data && iPtr->destroyData)
 305         (*iPtr->destroyData)(iPtr->data);
 306     if (iPtr->submenu)
 307         WMDestroyWidget(iPtr->submenu);
 308
 309     free(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         free(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     free(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     WMMapWidget(menu);
 793 }
 794
 795
 796 static void
 797 updateMenuContents(WEditMenu *mPtr)
 798 {
 799     int newW, newH;
 800     int w;
 801     int i;
 802     int iheight = mPtr->itemHeight;
 803     int offs = 1;
 804     WMBagIterator iter;
 805     WEditMenuItem *item;
 806
 807     newW = 0;
 808     newH = offs;
 809
 810     i = 0;
 811     WM_ITERATE_BAG(mPtr->items, item, iter) {
 812         w = getItemTextWidth(item);
 813
 814         newW = WMAX(w, newW);
 815
 816         WMMoveWidget(item, offs, newH);
 817         if (i == 0 && mPtr->flags.isTitled) {
 818             newH += mPtr->titleHeight;
 819         } else {
 820             newH += iheight;
 821         }
 822         i = 1;
 823     }
 824
 825     newW += iheight + 10;
 826     newH--;
 827
 828     if (mPtr->minSize.width)
 829         newW = WMAX(newW, mPtr->minSize.width);
 830     if (mPtr->maxSize.width)
 831         newW = WMIN(newW, mPtr->maxSize.width);
 832
 833     if (mPtr->minSize.height)
 834         newH = WMAX(newH, mPtr->minSize.height);
 835     if (mPtr->maxSize.height)
 836         newH = WMIN(newH, mPtr->maxSize.height);
 837
 838     if (W_VIEW(mPtr)->size.width == newW && mPtr->view->size.height == newH+1)
 839         return;
 840
 841     W_ResizeView(mPtr->view, newW, newH+1);
 842
 843     if (mPtr->closeB)
 844         WMMoveWidget(mPtr->closeB, newW - 20, 3);
 845
 846     newW -= 2*offs;
 847
 848     i = 0;
 849     WM_ITERATE_BAG(mPtr->items, item, iter) {
 850         if (i == 0 && mPtr->flags.isTitled) {
 851             WMResizeWidget(item, newW, mPtr->titleHeight);
 852         } else {
 853             WMResizeWidget(item, newW, iheight);
 854         }
 855         i = 1;
 856     }
 857 }
 858
 859
 860 static void
 861 deselectItem(WEditMenu *menu)
 862 {
 863     WEditMenu *submenu;
 864     WEditMenuItem *item = menu->selectedItem;
 865
 866     highlightItem(item, False);
 867
 868     if (menu->delegate && menu->delegate->itemDeselected) {
 869         (*menu->delegate->itemDeselected)(menu->delegate, menu, item);
 870     }
 871     submenu = item->submenu;
 872
 873     if (submenu && !WEditMenuIsTornOff(submenu)) {
 874         WEditMenuHide(submenu);
 875     }
 876
 877     menu->selectedItem = NULL;
 878 }
 879
 880
 881 static void
 882 selectItem(WEditMenu *menu, WEditMenuItem *item)
 883 {
 884     if (!menu->flags.isSelectable || menu->selectedItem == item) {
 885         return;
 886     }
 887     if (menu->selectedItem) {
 888         deselectItem(menu);
 889     }
 890
 891     if (menu->flags.isEditing) {
 892         stopEditItem(menu, False);
 893     }
 894
 895     if (item && !item->flags.isTitle) {
 896         highlightItem(item, True);
 897
 898         if (item->submenu && !W_VIEW_MAPPED(item->submenu->view)) {
 899             WMPoint pt;
 900
 901             pt = WGetEditMenuLocationForSubmenu(menu, item->submenu);
 902
 903             WEditMenuShowAt(item->submenu, pt.x, pt.y);
 904
 905             item->submenu->flags.isTornOff = 0;
 906         }
 907
 908         WMPostNotificationName("EditMenuItemSelected", menu, NULL);
 909
 910         if (menu->delegate && menu->delegate->itemSelected) {
 911             (*menu->delegate->itemSelected)(menu->delegate, menu, item);
 912         }
 913     }
 914
 915     menu->selectedItem = item;
 916 }
 917
 918
 919 static void
 920 paintMenu(WEditMenu *mPtr)
 921 {
 922     W_View *view = mPtr->view;
 923
 924     W_DrawRelief(W_VIEW_SCREEN(view), W_VIEW_DRAWABLE(view), 0, 0,
 925                  W_VIEW_WIDTH(view), W_VIEW_HEIGHT(view), WRSimple);
 926 }
 927
 928
 929 static void
 930 handleEvents(XEvent *event, void *data)
 931 {
 932     WEditMenu *mPtr = (WEditMenu*)data;
 933
 934     switch (event->type) {
 935      case DestroyNotify:
 936         destroyEditMenu(mPtr);
 937         break;
 938
 939      case Expose:
 940         if (event->xexpose.count == 0)
 941             paintMenu(mPtr);
 942         break;
 943     }
 944 }
 945
 946
 947
 948
 949 /* -------------------------- Menu Label Editing ------------------------ */
 950
 951
 952 static void
 953 stopEditItem(WEditMenu *menu, Bool apply)
 954 {
 955     char *text;
 956
 957     if (apply) {
 958         text = WMGetTextFieldText(menu->tfield);
 959
 960         free(menu->selectedItem->label);
 961         menu->selectedItem->label = wstrdup(text);
 962
 963         updateMenuContents(menu);
 964
 965         if (menu->delegate && menu->delegate->itemEdited) {
 966             (*menu->delegate->itemEdited)(menu->delegate, menu,
 967                                           menu->selectedItem);
 968         }
 969
 970     }
 971     WMUnmapWidget(menu->tfield);
 972     menu->flags.isEditing = 0;
 973 }
 974
 975
 976 static void
 977 textEndedEditing(struct WMTextFieldDelegate *self, WMNotification *notif)
 978 {
 979     WEditMenu *menu = (WEditMenu*)self->data;
 980     int reason;
 981     int i;
 982     WEditMenuItem *item;
 983
 984     if (!menu->flags.isEditing)
 985         return;
 986
 987     reason = (int)WMGetNotificationClientData(notif);
 988
 989     switch (reason) {
 990      case WMEscapeTextMovement:
 991         stopEditItem(menu, False);
 992         break;
 993
 994      case WMReturnTextMovement:
 995         stopEditItem(menu, True);
 996         break;
 997
 998      case WMTabTextMovement:
 999         stopEditItem(menu, True);
1000
1001         i = WMFindInBag(menu->items, simpleMatch, menu->selectedItem);
1002         item = WMGetFromBag(menu->items, i+1);
1003         if (item != NULL) {
1004             selectItem(menu, item);
1005             editItemLabel(item);
1006         }
1007         break;
1008
1009      case WMBacktabTextMovement:
1010         stopEditItem(menu, True);
1011
1012         i = WMFindInBag(menu->items, simpleMatch, menu->selectedItem);
1013         item = WMGetFromBag(menu->items, i-1);
1014         if (item != NULL) {
1015             selectItem(menu, item);
1016             editItemLabel(item);
1017         }
1018         break;
1019     }
1020 }
1021
1022
1023
1024 static WMTextFieldDelegate textFieldDelegate = {
1025     NULL,
1026         NULL,
1027         NULL,
1028         textEndedEditing,
1029         NULL,
1030         NULL
1031 };
1032
1033
1034 static void
1035 editItemLabel(WEditMenuItem *item)
1036 {
1037     WEditMenu *mPtr = item->parent;
1038     WMTextField *tf;
1039     int i;
1040
1041     if (!mPtr->flags.isEditable) {
1042         return;
1043     }
1044
1045     if (!mPtr->tfield) {
1046         mPtr->tfield = WMCreateTextField(mPtr);
1047         WMSetTextFieldBeveled(mPtr->tfield, False);
1048         WMRealizeWidget(mPtr->tfield);
1049
1050         mPtr->tdelegate = wmalloc(sizeof(WMTextFieldDelegate));
1051         memcpy(mPtr->tdelegate, &textFieldDelegate,
1052                sizeof(WMTextFieldDelegate));
1053
1054         mPtr->tdelegate->data = mPtr;
1055
1056         WMSetTextFieldDelegate(mPtr->tfield, mPtr->tdelegate);
1057     }
1058     tf = mPtr->tfield;
1059
1060     i = WMFindInBag(mPtr->items, simpleMatch, item);
1061
1062     WMSetTextFieldText(tf, item->label);
1063     WMSelectTextFieldRange(tf, wmkrange(0, strlen(item->label)));
1064     WMResizeWidget(tf, mPtr->view->size.width, mPtr->itemHeight);
1065     WMMoveWidget(tf, 0, item->view->pos.y);
1066     WMMapWidget(tf);
1067     WMSetFocusToWidget(tf);
1068
1069     mPtr->flags.isEditing = 1;
1070 }
1071
1072
1073
1074 /* -------------------------------------------------- */
1075
1076
1077 static void
1078 slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
1079 {
1080     double x, y, dx, dy;
1081     int i;
1082     int iterations;
1083
1084     iterations = WMIN(25, WMAX(abs(dstX-srcX), abs(dstY-srcY)));
1085
1086     x = srcX;
1087     y = srcY;
1088
1089     dx = (double)(dstX-srcX)/iterations;
1090     dy = (double)(dstY-srcY)/iterations;
1091
1092     for (i = 0; i <= iterations; i++) {
1093         XMoveWindow(dpy, win, x, y);
1094         XFlush(dpy);
1095
1096         wusleep(800);
1097
1098         x += dx;
1099         y += dy;
1100     }
1101 }
1102
1103
1104 static int
1105 errorHandler(Display *d, XErrorEvent *ev)
1106 {
1107     /* just ignore */
1108     return 0;
1109 }
1110
1111
1112 static WEditMenu*
1113 findMenuInWindow(Display *dpy, Window toplevel, int x, int y)
1114 {
1115     Window foo, bar;
1116     Window *children;
1117     unsigned nchildren;
1118     int i;
1119     WEditMenu *menu;
1120     WMView *view;
1121     int (*oldHandler)(Display *, XErrorEvent *);
1122
1123     view = W_GetViewForXWindow(dpy, toplevel);
1124     if (view && view->self && WMWidgetClass(view->self) == EditMenuClass) {
1125         menu = (WEditMenu*)view->self;
1126         if (menu->flags.acceptsDrop) {
1127             return menu;
1128         }
1129     }
1130
1131     if (!XQueryTree(dpy, toplevel, &foo, &bar,
1132                     &children, &nchildren) || children == NULL) {
1133         return NULL;
1134     }
1135
1136     oldHandler = XSetErrorHandler(errorHandler);
1137
1138     /* first window that contains the point is the one */
1139     for (i = nchildren-1; i >= 0; i--) {
1140         XWindowAttributes attr;
1141
1142         if (XGetWindowAttributes(dpy, children[i], &attr)
1143             && attr.map_state == IsViewable
1144             && x >= attr.x && y >= attr.y
1145             && x < attr.x + attr.width && y < attr.y + attr.height) {
1146             Window tmp;
1147
1148             tmp = children[i];
1149
1150             menu = findMenuInWindow(dpy, tmp, x - attr.x, y - attr.y);
1151             if (menu) {
1152                 XFree(children);
1153                 return menu;
1154             }
1155         }
1156     }
1157
1158     XSetErrorHandler(oldHandler);
1159
1160     XFree(children);
1161     return NULL;
1162 }
1163
1164
1165 static void
1166 handleDragOver(WEditMenu *menu, WMView *view, WEditMenuItem *item,
1167                int x, int y)
1168 {
1169     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1170     Window blaw;
1171     int mx, my;
1172     int offs;
1173
1174     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1175                           scr->rootWin, 0, 0, &mx, &my, &blaw);
1176
1177     offs = menu->flags.standalone ? 0 : 1;
1178
1179     W_MoveView(view, mx + offs, y);
1180     if (view->size.width != menu->view->size.width) {
1181         W_ResizeView(view, menu->view->size.width - 2*offs,
1182                      menu->itemHeight);
1183         W_ResizeView(item->view, menu->view->size.width - 2*offs,
1184                      menu->itemHeight);
1185     }
1186 }
1187
1188
1189 static void
1190 handleItemDrop(WEditMenu *menu, WEditMenuItem *item, int x, int y)
1191 {
1192     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1193     Window blaw;
1194     int mx, my;
1195     int index;
1196
1197     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1198                           scr->rootWin, 0, 0, &mx, &my, &blaw);
1199
1200     index = y - my;
1201     if (menu->flags.isTitled) {
1202         index -= menu->titleHeight;
1203     }
1204     index = (index + menu->itemHeight/2) / menu->itemHeight;
1205     if (index < 0)
1206         index = 0;
1207
1208     if (menu->flags.isTitled) {
1209         index++;
1210     }
1211
1212     if (index > WMGetBagItemCount(menu->items)) {
1213         WMPutInBag(menu->items, item);
1214     } else {
1215         WMInsertInBag(menu->items, index, item);
1216     }
1217
1218     W_ReparentView(item->view, menu->view, 0, index*menu->itemHeight);
1219
1220     item->parent = menu;
1221     if (item->submenu) {
1222         item->submenu->parent = menu;
1223     }
1224
1225     updateMenuContents(menu);
1226 }
1227
1228
1229 static void
1230 dragMenu(WEditMenu *menu)
1231 {
1232     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1233     XEvent ev;
1234     Bool done = False;
1235     int dx, dy;
1236     unsigned blau;
1237     Window blaw;
1238
1239     XGetGeometry(scr->display, W_VIEW_DRAWABLE(menu->view), &blaw, &dx, &dy,
1240                  &blau, &blau, &blau, &blau);
1241
1242     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view),
1243                           scr->rootWin, dx, dy, &dx, &dy, &blaw);
1244
1245     dx = menu->dragX - dx;
1246     dy = menu->dragY - dy;
1247
1248     XGrabPointer(scr->display, scr->rootWin, False,
1249                  ButtonReleaseMask|ButtonMotionMask,
1250                  GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
1251                  CurrentTime);
1252
1253     if (menu->parent)
1254         WTearOffEditMenu(menu->parent, menu);
1255
1256     while (!done) {
1257         WMNextEvent(scr->display, &ev);
1258
1259         switch (ev.type) {
1260          case ButtonRelease:
1261             done = True;
1262             break;
1263
1264          case MotionNotify:
1265             while (XCheckMaskEvent(scr->display, ButtonMotionMask, &ev)) ;
1266
1267             WMMoveWidget(menu, ev.xmotion.x_root - dx,
1268                          ev.xmotion.y_root - dy);
1269             break;
1270
1271          default:
1272             WMHandleEvent(&ev);
1273             break;
1274         }
1275     }
1276
1277     XUngrabPointer(scr->display, CurrentTime);
1278 }
1279
1280
1281
1282 static WEditMenuItem*
1283 duplicateItem(WEditMenuItem *item)
1284 {
1285     WEditMenuItem *nitem;
1286
1287     nitem = WCreateEditMenuItem(item->parent, item->label, False);
1288     if (item->pixmap)
1289         nitem->pixmap = WMRetainPixmap(item->pixmap);
1290
1291     return nitem;
1292 }
1293
1294
1295
1296
1297 static WEditMenu*
1298 duplicateMenu(WEditMenu *menu)
1299 {
1300     WEditMenu *nmenu;
1301     WEditMenuItem *item;
1302     WMBagIterator iter;
1303     Bool first = menu->flags.isTitled;
1304
1305     nmenu = WCreateEditMenu(WMWidgetScreen(menu), WGetEditMenuTitle(menu));
1306
1307     memcpy(&nmenu->flags, &menu->flags, sizeof(menu->flags));
1308     nmenu->delegate = menu->delegate;
1309
1310     WM_ITERATE_BAG(menu->items, item, iter) {
1311         WEditMenuItem *nitem;
1312
1313         if (first) {
1314             first = False;
1315             continue;
1316         }
1317
1318         nitem = WAddMenuItemWithTitle(nmenu, item->label);
1319         if (item->pixmap)
1320             WSetEditMenuItemImage(nitem, item->pixmap);
1321
1322         if (menu->delegate && menu->delegate->itemCloned) {
1323             (*menu->delegate->itemCloned)(menu->delegate, menu,
1324                                           item, nitem);
1325         }
1326     }
1327
1328     WMRealizeWidget(nmenu);
1329
1330     return nmenu;
1331 }
1332
1333
1334
1335 static void
1336 dragItem(WEditMenu *menu, WEditMenuItem *item)
1337 {
1338     static XColor black = {0, 0,0,0, DoRed|DoGreen|DoBlue};
1339     static XColor green = {0x0045b045, 0x4500,0xb000,0x4500, DoRed|DoGreen|DoBlue};
1340     static XColor back = {0, 0xffff,0xffff,0xffff, DoRed|DoGreen|DoBlue};
1341     Display *dpy = W_VIEW_DISPLAY(menu->view);
1342     WMScreen *scr = W_VIEW_SCREEN(menu->view);
1343     int x, y;
1344     int dx, dy;
1345     Bool done = False;
1346     Window blaw;
1347     int blai;
1348     unsigned blau;
1349     Window win;
1350     WMView *dview;
1351     int orix, oriy;
1352     Bool enteredMenu = False;
1353     WMSize oldSize = item->view->size;
1354     WEditMenuItem *dritem = item;
1355     WEditMenu *dmenu = NULL;
1356
1357
1358     if (item->flags.isTitle) {
1359         WMRaiseWidget(menu);
1360
1361         dragMenu(menu);
1362
1363         return;
1364     }
1365
1366     selectItem(menu, NULL);
1367
1368     win = scr->rootWin;
1369
1370     XTranslateCoordinates(dpy, W_VIEW_DRAWABLE(item->view), win,
1371                           0, 0, &orix, &oriy, &blaw);
1372
1373     dview = W_CreateUnmanagedTopView(scr);
1374     W_SetViewBackgroundColor(dview, scr->black);
1375     W_ResizeView(dview, W_VIEW_WIDTH(item->view), W_VIEW_HEIGHT(item->view));
1376     W_MoveView(dview, orix, oriy);
1377     W_RealizeView(dview);
1378
1379     if (menu->flags.isFactory) {
1380         dritem = duplicateItem(item);
1381
1382         W_ReparentView(dritem->view, dview, 0, 0);
1383         WMResizeWidget(dritem, oldSize.width, oldSize.height);
1384         WMRealizeWidget(dritem);
1385         WMMapWidget(dritem);
1386     } else {
1387         W_ReparentView(item->view, dview, 0, 0);
1388     }
1389
1390     W_MapView(dview);
1391
1392     dx = menu->dragX - orix;
1393     dy = menu->dragY - oriy;
1394
1395     XGrabPointer(dpy, scr->rootWin, False,
1396                  ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
1397                  GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
1398                  CurrentTime);
1399
1400     if (menu->flags.acceptsDrop)
1401         XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1402
1403     while (!done) {
1404         XEvent ev;
1405
1406         WMNextEvent(dpy, &ev);
1407
1408         switch (ev.type) {
1409          case MotionNotify:
1410             while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
1411
1412             XQueryPointer(dpy, win, &blaw, &blaw, &blai, &blai, &x, &y, &blau);
1413
1414             dmenu = findMenuInWindow(dpy, win, x, y);
1415
1416             if (dmenu) {
1417                 handleDragOver(dmenu, dview, dritem, x - dx, y - dy);
1418                 if (!enteredMenu) {
1419                     enteredMenu = True;
1420                     XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1421                 }
1422             } else {
1423                 if (enteredMenu) {
1424                     W_ResizeView(dview, oldSize.width, oldSize.height);
1425                     W_ResizeView(dritem->view, oldSize.width, oldSize.height);
1426                     enteredMenu = False;
1427                     XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1428                 }
1429                 W_MoveView(dview, x - dx, y - dy);
1430             }
1431
1432             break;
1433
1434          case ButtonRelease:
1435             done = True;
1436             break;
1437
1438          default:
1439             WMHandleEvent(&ev);
1440             break;
1441         }
1442     }
1443     XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1444
1445     XUngrabPointer(dpy, CurrentTime);
1446
1447
1448     if (!enteredMenu) {
1449         Bool rem = True;
1450
1451         if (!menu->flags.isFactory) {
1452             W_UnmapView(dview);
1453             if (menu->delegate && menu->delegate->shouldRemoveItem) {
1454                 rem = (*menu->delegate->shouldRemoveItem)(menu->delegate,
1455                                                           menu, item);
1456             }
1457             W_MapView(dview);
1458         }
1459
1460         if (!rem || menu->flags.isFactory) {
1461             slideWindow(dpy, W_VIEW_DRAWABLE(dview), x-dx, y-dy, orix, oriy);
1462
1463             if (!menu->flags.isFactory) {
1464                 WRemoveEditMenuItem(menu, dritem);
1465                 handleItemDrop(dmenu ? dmenu : menu, dritem, orix, oriy);
1466             }
1467         } else {
1468             WRemoveEditMenuItem(menu, dritem);
1469         }
1470     } else {
1471         WRemoveEditMenuItem(menu, dritem);
1472
1473         if (menu->delegate && menu->delegate->itemCloned
1474             && menu->flags.isFactory) {
1475             (*menu->delegate->itemCloned)(menu->delegate, menu,
1476                                           item, dritem);
1477         }
1478
1479         handleItemDrop(dmenu, dritem, x-dy, y-dy);
1480
1481         if (item->submenu && menu->flags.isFactory) {
1482             WEditMenu *submenu;
1483
1484             submenu = duplicateMenu(item->submenu);
1485             WSetEditMenuSubmenu(dmenu, dritem, submenu);
1486         }
1487     }
1488
1489     /* can't destroy now because we're being called from
1490      * the event handler of the item. and destroying now,
1491      * would mean destroying the item too in some cases.
1492      */
1493     WMAddIdleHandler((WMCallback*)W_DestroyView, dview);
1494 }
1495
1496
1497
1498 static void
1499 handleItemClick(XEvent *event, void *data)
1500 {
1501     WEditMenuItem *item = (WEditMenuItem*)data;
1502     WEditMenu *menu = item->parent;
1503
1504     switch (event->type) {
1505      case ButtonPress:
1506         selectItem(menu, item);
1507
1508         if (WMIsDoubleClick(event)) {
1509             editItemLabel(item);
1510         }
1511
1512         menu->flags.isDragging = 1;
1513         menu->dragX = event->xbutton.x_root;
1514         menu->dragY = event->xbutton.y_root;
1515         break;
1516
1517      case ButtonRelease:
1518         menu->flags.isDragging = 0;
1519         break;
1520
1521      case MotionNotify:
1522         if (menu->flags.isDragging) {
1523             if (abs(event->xbutton.x_root - menu->dragX) > 5
1524                 || abs(event->xbutton.y_root - menu->dragY) > 5) {
1525                 menu->flags.isDragging = 0;
1526                 dragItem(menu, item);
1527             }
1528         }
1529         break;
1530     }
1531 }
1532
1533
1534 static void
1535 destroyEditMenu(WEditMenu *mPtr)
1536 {
1537     WEditMenuItem *item;
1538     WMBagIterator iter;
1539
1540     WMRemoveNotificationObserver(mPtr);
1541
1542     WM_ITERATE_BAG(mPtr->items, item, iter) {
1543         if (item->submenu) {
1544             WMDestroyWidget(item->submenu);
1545         }
1546     }
1547
1548     WMFreeBag(mPtr->items);
1549
1550     free(mPtr->tdelegate);
1551
1552     free(mPtr);
1553 }
1554
1555
1556