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