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