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