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