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