WPrefs.app/editmenu.c

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