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(WMScreen * scr)
 109 {
 110         /* register our widget with WINGs and get our widget class ID */
 111         if (!EditMenuItemClass) {
 112                 EditMenuItemClass = W_RegisterUserWidget();
 113         }
 114
 115         return EditMenuItemClass;
 116 }
 117
 118 WEditMenuItem *WCreateEditMenuItem(WMWidget * parent, char *title, Bool isTitle)
 119 {
 120         WEditMenuItem *iPtr;
 121         WMScreen *scr = WMWidgetScreen(parent);
 122
 123         if (!EditMenuItemClass)
 124                 InitEditMenuItem(scr);
 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(WMScreen * scr)
 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         memset(&attribs, 0, sizeof(GNUstepWMAttributes));
 338         attribs.flags = GSWindowStyleAttr | GSWindowLevelAttr;
 339         attribs.window_style = WMBorderlessWindowMask;
 340         attribs.window_level = WMSubmenuWindowLevel;
 341
 342         writeGNUstepWMAttr(WMWidgetScreen(menu), menu->view->window, &attribs);
 343 }
 344
 345 static void itemSelectObserver(void *self, WMNotification * notif)
 346 {
 347         WEditMenu *menu = (WEditMenu *) self;
 348         WEditMenu *rmenu;
 349
 350         rmenu = (WEditMenu *) WMGetNotificationObject(notif);
 351         /* check whether rmenu is from the same hierarchy of menu? */
 352
 353         if (rmenu == menu) {
 354                 return;
 355         }
 356
 357         if (menu->selectedItem) {
 358                 if (!menu->selectedItem->submenu)
 359                         deselectItem(menu);
 360                 if (menu->flags.isEditing)
 361                         stopEditItem(menu, False);
 362         }
 363 }
 364
 365 static WEditMenu *makeEditMenu(WMScreen * scr, WMWidget * parent, char *title)
 366 {
 367         WEditMenu *mPtr;
 368         WEditMenuItem *item;
 369
 370         if (!EditMenuClass)
 371                 InitEditMenu(scr);
 372
 373         mPtr = wmalloc(sizeof(WEditMenu));
 374
 375         mPtr->widgetClass = EditMenuClass;
 376
 377         if (parent) {
 378                 mPtr->view = W_CreateView(W_VIEW(parent));
 379                 mPtr->flags.standalone = 0;
 380         } else {
 381                 mPtr->view = W_CreateTopView(scr);
 382                 mPtr->flags.standalone = 1;
 383         }
 384         if (!mPtr->view) {
 385                 wfree(mPtr);
 386                 return NULL;
 387         }
 388         mPtr->view->self = mPtr;
 389
 390         mPtr->flags.isSelectable = 1;
 391         mPtr->flags.isEditable = 1;
 392
 393         W_SetViewBackgroundColor(mPtr->view, scr->darkGray);
 394
 395         WMAddNotificationObserver(realizeObserver, mPtr, WMViewRealizedNotification, mPtr->view);
 396
 397         WMAddNotificationObserver(itemSelectObserver, mPtr, "EditMenuItemSelected", NULL);
 398
 399         mPtr->items = WMCreateArray(4);
 400
 401         WMCreateEventHandler(mPtr->view, ExposureMask | StructureNotifyMask, handleEvents, mPtr);
 402
 403         if (title != NULL) {
 404                 item = WCreateEditMenuItem(mPtr, title, True);
 405
 406                 WMMapWidget(item);
 407                 WMAddToArray(mPtr->items, item);
 408
 409                 mPtr->flags.isTitled = 1;
 410         }
 411
 412         mPtr->itemHeight = WMFontHeight(scr->normalFont) + 6;
 413         mPtr->titleHeight = WMFontHeight(scr->boldFont) + 8;
 414
 415         updateMenuContents(mPtr);
 416
 417         return mPtr;
 418 }
 419
 420 WEditMenu *WCreateEditMenu(WMScreen * scr, char *title)
 421 {
 422         return makeEditMenu(scr, NULL, title);
 423 }
 424
 425 WEditMenu *WCreateEditMenuPad(WMWidget * parent)
 426 {
 427         return makeEditMenu(WMWidgetScreen(parent), parent, NULL);
 428 }
 429
 430 void WSetEditMenuDelegate(WEditMenu * mPtr, WEditMenuDelegate * delegate)
 431 {
 432         mPtr->delegate = delegate;
 433 }
 434
 435 WEditMenuItem *WInsertMenuItemWithTitle(WEditMenu * mPtr, int index, char *title)
 436 {
 437         WEditMenuItem *item;
 438
 439         item = WCreateEditMenuItem(mPtr, title, False);
 440
 441         WMMapWidget(item);
 442
 443         if (index >= WMGetArrayItemCount(mPtr->items)) {
 444                 WMAddToArray(mPtr->items, item);
 445         } else {
 446                 if (index < 0)
 447                         index = 0;
 448                 if (mPtr->flags.isTitled)
 449                         index++;
 450                 WMInsertInArray(mPtr->items, index, item);
 451         }
 452
 453         updateMenuContents(mPtr);
 454
 455         return item;
 456 }
 457
 458 WEditMenuItem *WGetEditMenuItem(WEditMenu * mPtr, int index)
 459 {
 460         if (index >= WMGetArrayItemCount(mPtr->items))
 461                 return NULL;
 462
 463         return WMGetFromArray(mPtr->items, index + (mPtr->flags.isTitled ? 1 : 0));
 464 }
 465
 466 WEditMenuItem *WAddMenuItemWithTitle(WEditMenu * mPtr, char *title)
 467 {
 468         return WInsertMenuItemWithTitle(mPtr, WMGetArrayItemCount(mPtr->items), title);
 469 }
 470
 471 void WSetEditMenuTitle(WEditMenu * mPtr, char *title)
 472 {
 473         WEditMenuItem *item;
 474
 475         item = WMGetFromArray(mPtr->items, 0);
 476
 477         wfree(item->label);
 478         item->label = wstrdup(title);
 479
 480         updateMenuContents(mPtr);
 481
 482         WMRedisplayWidget(item);
 483 }
 484
 485 char *WGetEditMenuTitle(WEditMenu * mPtr)
 486 {
 487         WEditMenuItem *item;
 488
 489         item = WMGetFromArray(mPtr->items, 0);
 490
 491         return item->label;
 492 }
 493
 494 void WSetEditMenuAcceptsDrop(WEditMenu * mPtr, Bool flag)
 495 {
 496         mPtr->flags.acceptsDrop = flag;
 497 }
 498
 499 void WSetEditMenuSubmenu(WEditMenu * mPtr, WEditMenuItem * item, WEditMenu * submenu)
 500 {
 501         item->submenu = submenu;
 502         submenu->parent = mPtr;
 503
 504         paintEditMenuItem(item);
 505 }
 506
 507 WEditMenu *WGetEditMenuSubmenu(WEditMenu * mPtr, WEditMenuItem * item)
 508 {
 509         return item->submenu;
 510 }
 511
 512 void WRemoveEditMenuItem(WEditMenu * mPtr, WEditMenuItem * item)
 513 {
 514         if (WMRemoveFromArray(mPtr->items, item) != 0) {
 515                 updateMenuContents(mPtr);
 516         }
 517 }
 518
 519 void WSetEditMenuSelectable(WEditMenu * mPtr, Bool flag)
 520 {
 521         mPtr->flags.isSelectable = flag;
 522 }
 523
 524 void WSetEditMenuEditable(WEditMenu * mPtr, Bool flag)
 525 {
 526         mPtr->flags.isEditable = flag;
 527 }
 528
 529 void WSetEditMenuIsFactory(WEditMenu * mPtr, Bool flag)
 530 {
 531         mPtr->flags.isFactory = flag;
 532 }
 533
 534 void WSetEditMenuMinSize(WEditMenu * mPtr, WMSize size)
 535 {
 536         mPtr->minSize.width = size.width;
 537         mPtr->minSize.height = size.height;
 538 }
 539
 540 void WSetEditMenuMaxSize(WEditMenu * mPtr, WMSize size)
 541 {
 542         mPtr->maxSize.width = size.width;
 543         mPtr->maxSize.height = size.height;
 544 }
 545
 546 WMPoint WGetEditMenuLocationForSubmenu(WEditMenu * mPtr, WEditMenu * submenu)
 547 {
 548         WMArrayIterator iter;
 549         WEditMenuItem *item;
 550         int y;
 551
 552         if (mPtr->flags.isTitled)
 553                 y = -mPtr->titleHeight;
 554         else
 555                 y = 0;
 556         WM_ITERATE_ARRAY(mPtr->items, item, iter) {
 557                 if (item->submenu == submenu) {
 558                         WMPoint pt = WMGetViewScreenPosition(mPtr->view);
 559
 560                         return wmkpoint(pt.x + mPtr->view->size.width, pt.y + y);
 561                 }
 562                 y += W_VIEW_HEIGHT(item->view);
 563         }
 564
 565         puts("invalid submenu passed to WGetEditMenuLocationForSubmenu()");
 566
 567         return wmkpoint(0, 0);
 568 }
 569
 570 static void closeMenuAction(WMWidget * w, void *data)
 571 {
 572         WEditMenu *menu = (WEditMenu *) data;
 573
 574         WMAddIdleHandler(WMDestroyWidget, menu->closeB);
 575         menu->closeB = NULL;
 576
 577         WEditMenuHide(menu);
 578 }
 579
 580 void WTearOffEditMenu(WEditMenu * menu, WEditMenu * submenu)
 581 {
 582         WEditMenuItem *item;
 583
 584         submenu->flags.isTornOff = 1;
 585
 586         item = (WEditMenuItem *) WMGetFromArray(submenu->items, 0);
 587
 588         submenu->closeB = WMCreateCommandButton(item);
 589         WMResizeWidget(submenu->closeB, 15, 15);
 590         WMMoveWidget(submenu->closeB, W_VIEW(submenu)->size.width - 20, 3);
 591         WMRealizeWidget(submenu->closeB);
 592         WMSetButtonText(submenu->closeB, "X");
 593         WMSetButtonAction(submenu->closeB, closeMenuAction, submenu);
 594         WMMapWidget(submenu->closeB);
 595
 596         if (menu->selectedItem && menu->selectedItem->submenu == submenu)
 597                 deselectItem(menu);
 598 }
 599
 600 Bool WEditMenuIsTornOff(WEditMenu * mPtr)
 601 {
 602         return mPtr->flags.isTornOff;
 603 }
 604
 605 void WEditMenuHide(WEditMenu * mPtr)
 606 {
 607         WEditMenuItem *item;
 608         int i = 0;
 609
 610         if (WMWidgetIsMapped(mPtr)) {
 611                 WMUnmapWidget(mPtr);
 612                 mPtr->flags.wasMapped = 1;
 613         } else {
 614                 mPtr->flags.wasMapped = 0;
 615         }
 616         while ((item = WGetEditMenuItem(mPtr, i++))) {
 617                 WEditMenu *submenu;
 618
 619                 submenu = WGetEditMenuSubmenu(mPtr, item);
 620                 if (submenu) {
 621                         WEditMenuHide(submenu);
 622                 }
 623         }
 624 }
 625
 626 void WEditMenuUnhide(WEditMenu * mPtr)
 627 {
 628         WEditMenuItem *item;
 629         int i = 0;
 630
 631         if (mPtr->flags.wasMapped) {
 632                 WMMapWidget(mPtr);
 633         }
 634         while ((item = WGetEditMenuItem(mPtr, i++))) {
 635                 WEditMenu *submenu;
 636
 637                 submenu = WGetEditMenuSubmenu(mPtr, item);
 638                 if (submenu) {
 639                         WEditMenuUnhide(submenu);
 640                 }
 641         }
 642 }
 643
 644 void WEditMenuShowAt(WEditMenu * menu, int x, int y)
 645 {
 646         XSizeHints *hints;
 647
 648         hints = XAllocSizeHints();
 649
 650         hints->flags = USPosition;
 651         hints->x = x;
 652         hints->y = y;
 653
 654         WMMoveWidget(menu, x, y);
 655         XSetWMNormalHints(W_VIEW_DISPLAY(menu->view), W_VIEW_DRAWABLE(menu->view), hints);
 656         XFree(hints);
 657
 658         WMMapWidget(menu);
 659 }
 660
 661 static void updateMenuContents(WEditMenu * mPtr)
 662 {
 663         int newW, newH;
 664         int w;
 665         int i;
 666         int iheight = mPtr->itemHeight;
 667         int offs = 1;
 668         WMArrayIterator iter;
 669         WEditMenuItem *item;
 670
 671         newW = 0;
 672         newH = offs;
 673
 674         i = 0;
 675         WM_ITERATE_ARRAY(mPtr->items, item, iter) {
 676                 w = getItemTextWidth(item);
 677
 678                 newW = WMAX(w, newW);
 679
 680                 WMMoveWidget(item, offs, newH);
 681                 if (i == 0 && mPtr->flags.isTitled) {
 682                         newH += mPtr->titleHeight;
 683                 } else {
 684                         newH += iheight;
 685                 }
 686                 i = 1;
 687         }
 688
 689         newW += iheight + 10;
 690         newH--;
 691
 692         if (mPtr->minSize.width)
 693                 newW = WMAX(newW, mPtr->minSize.width);
 694         if (mPtr->maxSize.width)
 695                 newW = WMIN(newW, mPtr->maxSize.width);
 696
 697         if (mPtr->minSize.height)
 698                 newH = WMAX(newH, mPtr->minSize.height);
 699         if (mPtr->maxSize.height)
 700                 newH = WMIN(newH, mPtr->maxSize.height);
 701
 702         if (W_VIEW(mPtr)->size.width == newW && mPtr->view->size.height == newH + 1)
 703                 return;
 704
 705         W_ResizeView(mPtr->view, newW, newH + 1);
 706
 707         if (mPtr->closeB)
 708                 WMMoveWidget(mPtr->closeB, newW - 20, 3);
 709
 710         newW -= 2 * offs;
 711
 712         i = 0;
 713         WM_ITERATE_ARRAY(mPtr->items, item, iter) {
 714                 if (i == 0 && mPtr->flags.isTitled) {
 715                         WMResizeWidget(item, newW, mPtr->titleHeight);
 716                 } else {
 717                         WMResizeWidget(item, newW, iheight);
 718                 }
 719                 i = 1;
 720         }
 721 }
 722
 723 static void deselectItem(WEditMenu * menu)
 724 {
 725         WEditMenu *submenu;
 726         WEditMenuItem *item = menu->selectedItem;
 727
 728         highlightItem(item, False);
 729
 730         if (menu->delegate && menu->delegate->itemDeselected) {
 731                 (*menu->delegate->itemDeselected) (menu->delegate, menu, item);
 732         }
 733         submenu = item->submenu;
 734
 735         if (submenu && !WEditMenuIsTornOff(submenu)) {
 736                 WEditMenuHide(submenu);
 737         }
 738
 739         menu->selectedItem = NULL;
 740 }
 741
 742 static void selectItem(WEditMenu * menu, WEditMenuItem * item)
 743 {
 744         if (!menu->flags.isSelectable || menu->selectedItem == item) {
 745                 return;
 746         }
 747         if (menu->selectedItem) {
 748                 deselectItem(menu);
 749         }
 750
 751         if (menu->flags.isEditing) {
 752                 stopEditItem(menu, False);
 753         }
 754
 755         if (item && !item->flags.isTitle) {
 756                 highlightItem(item, True);
 757
 758                 if (item->submenu && !W_VIEW_MAPPED(item->submenu->view)) {
 759                         WMPoint pt;
 760
 761                         pt = WGetEditMenuLocationForSubmenu(menu, item->submenu);
 762
 763                         WEditMenuShowAt(item->submenu, pt.x, pt.y);
 764
 765                         item->submenu->flags.isTornOff = 0;
 766                 }
 767
 768                 WMPostNotificationName("EditMenuItemSelected", menu, NULL);
 769
 770                 if (menu->delegate && menu->delegate->itemSelected) {
 771                         (*menu->delegate->itemSelected) (menu->delegate, menu, item);
 772                 }
 773         }
 774
 775         menu->selectedItem = item;
 776 }
 777
 778 static void paintMenu(WEditMenu * mPtr)
 779 {
 780         W_View *view = mPtr->view;
 781
 782         W_DrawRelief(W_VIEW_SCREEN(view), W_VIEW_DRAWABLE(view), 0, 0,
 783                      W_VIEW_WIDTH(view), W_VIEW_HEIGHT(view), WRSimple);
 784 }
 785
 786 static void handleEvents(XEvent * event, void *data)
 787 {
 788         WEditMenu *mPtr = (WEditMenu *) data;
 789
 790         switch (event->type) {
 791         case DestroyNotify:
 792                 destroyEditMenu(mPtr);
 793                 break;
 794
 795         case Expose:
 796                 if (event->xexpose.count == 0)
 797                         paintMenu(mPtr);
 798                 break;
 799         }
 800 }
 801
 802 /* -------------------------- Menu Label Editing ------------------------ */
 803
 804 static void stopEditItem(WEditMenu * menu, Bool apply)
 805 {
 806         char *text;
 807
 808         if (apply) {
 809                 text = WMGetTextFieldText(menu->tfield);
 810
 811                 wfree(menu->selectedItem->label);
 812                 menu->selectedItem->label = wstrdup(text);
 813
 814                 updateMenuContents(menu);
 815
 816                 if (menu->delegate && menu->delegate->itemEdited) {
 817                         (*menu->delegate->itemEdited) (menu->delegate, menu, menu->selectedItem);
 818                 }
 819
 820         }
 821         WMUnmapWidget(menu->tfield);
 822         menu->flags.isEditing = 0;
 823 }
 824
 825 static void textEndedEditing(struct WMTextFieldDelegate *self, WMNotification * notif)
 826 {
 827         WEditMenu *menu = (WEditMenu *) self->data;
 828         uintptr_t reason;
 829         int i;
 830         WEditMenuItem *item;
 831
 832         if (!menu->flags.isEditing)
 833                 return;
 834
 835         reason = (uintptr_t)WMGetNotificationClientData(notif);
 836
 837         switch (reason) {
 838         case WMEscapeTextMovement:
 839                 stopEditItem(menu, False);
 840                 break;
 841
 842         case WMReturnTextMovement:
 843                 stopEditItem(menu, True);
 844                 break;
 845
 846         case WMTabTextMovement:
 847                 stopEditItem(menu, True);
 848
 849                 i = WMGetFirstInArray(menu->items, menu->selectedItem);
 850                 item = WMGetFromArray(menu->items, i + 1);
 851                 if (item != NULL) {
 852                         selectItem(menu, item);
 853                         editItemLabel(item);
 854                 }
 855                 break;
 856
 857         case WMBacktabTextMovement:
 858                 stopEditItem(menu, True);
 859
 860                 i = WMGetFirstInArray(menu->items, menu->selectedItem);
 861                 item = WMGetFromArray(menu->items, i - 1);
 862                 if (item != NULL) {
 863                         selectItem(menu, item);
 864                         editItemLabel(item);
 865                 }
 866                 break;
 867         }
 868 }
 869
 870 static WMTextFieldDelegate textFieldDelegate = {
 871         NULL,
 872         NULL,
 873         NULL,
 874         textEndedEditing,
 875         NULL,
 876         NULL
 877 };
 878
 879 static void editItemLabel(WEditMenuItem * item)
 880 {
 881         WEditMenu *mPtr = item->parent;
 882         WMTextField *tf;
 883
 884         if (!mPtr->flags.isEditable) {
 885                 return;
 886         }
 887
 888         if (!mPtr->tfield) {
 889                 mPtr->tfield = WMCreateTextField(mPtr);
 890                 WMSetTextFieldBeveled(mPtr->tfield, False);
 891                 WMRealizeWidget(mPtr->tfield);
 892
 893                 mPtr->tdelegate = wmalloc(sizeof(WMTextFieldDelegate));
 894                 memcpy(mPtr->tdelegate, &textFieldDelegate, sizeof(WMTextFieldDelegate));
 895
 896                 mPtr->tdelegate->data = mPtr;
 897
 898                 WMSetTextFieldDelegate(mPtr->tfield, mPtr->tdelegate);
 899         }
 900         tf = mPtr->tfield;
 901
 902         WMSetTextFieldText(tf, item->label);
 903         WMSelectTextFieldRange(tf, wmkrange(0, strlen(item->label)));
 904         WMResizeWidget(tf, mPtr->view->size.width, mPtr->itemHeight);
 905         WMMoveWidget(tf, 0, item->view->pos.y);
 906         WMMapWidget(tf);
 907         WMSetFocusToWidget(tf);
 908
 909         mPtr->flags.isEditing = 1;
 910 }
 911
 912 /* -------------------------------------------------- */
 913
 914 static void slideWindow(Display * dpy, Window win, int srcX, int srcY, int dstX, int dstY)
 915 {
 916         double x, y, dx, dy;
 917         int i;
 918         int iterations;
 919
 920         iterations = WMIN(25, WMAX(abs(dstX - srcX), abs(dstY - srcY)));
 921
 922         x = srcX;
 923         y = srcY;
 924
 925         dx = (double)(dstX - srcX) / iterations;
 926         dy = (double)(dstY - srcY) / iterations;
 927
 928         for (i = 0; i <= iterations; i++) {
 929                 XMoveWindow(dpy, win, x, y);
 930                 XFlush(dpy);
 931
 932                 wusleep(800);
 933
 934                 x += dx;
 935                 y += dy;
 936         }
 937 }
 938
 939 static int errorHandler(Display * d, XErrorEvent * ev)
 940 {
 941         /* just ignore */
 942         return 0;
 943 }
 944
 945 static WEditMenu *findMenuInWindow(Display * dpy, Window toplevel, int x, int y)
 946 {
 947         Window foo, bar;
 948         Window *children;
 949         unsigned nchildren;
 950         int i;
 951         WEditMenu *menu;
 952         WMView *view;
 953         int (*oldHandler) (Display *, XErrorEvent *);
 954
 955         view = W_GetViewForXWindow(dpy, toplevel);
 956         if (view && view->self && WMWidgetClass(view->self) == EditMenuClass) {
 957                 menu = (WEditMenu *) view->self;
 958                 if (menu->flags.acceptsDrop) {
 959                         return menu;
 960                 }
 961         }
 962
 963         if (!XQueryTree(dpy, toplevel, &foo, &bar, &children, &nchildren) || children == NULL) {
 964                 return NULL;
 965         }
 966
 967         oldHandler = XSetErrorHandler(errorHandler);
 968
 969         /* first window that contains the point is the one */
 970         for (i = nchildren - 1; i >= 0; i--) {
 971                 XWindowAttributes attr;
 972
 973                 if (XGetWindowAttributes(dpy, children[i], &attr)
 974                     && attr.map_state == IsViewable
 975                     && x >= attr.x && y >= attr.y && x < attr.x + attr.width && y < attr.y + attr.height) {
 976                         Window tmp;
 977
 978                         tmp = children[i];
 979
 980                         menu = findMenuInWindow(dpy, tmp, x - attr.x, y - attr.y);
 981                         if (menu) {
 982                                 XFree(children);
 983                                 return menu;
 984                         }
 985                 }
 986         }
 987
 988         XSetErrorHandler(oldHandler);
 989
 990         XFree(children);
 991         return NULL;
 992 }
 993
 994 static void handleDragOver(WEditMenu * menu, WMView * view, WEditMenuItem * item, int x, int y)
 995 {
 996         WMScreen *scr = W_VIEW_SCREEN(menu->view);
 997         Window blaw;
 998         int mx, my;
 999         int offs;
1000
1001         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, 0, 0, &mx, &my, &blaw);
1002
1003         offs = menu->flags.standalone ? 0 : 1;
1004
1005         W_MoveView(view, mx + offs, y);
1006         if (view->size.width != menu->view->size.width) {
1007                 W_ResizeView(view, menu->view->size.width - 2 * offs, menu->itemHeight);
1008                 W_ResizeView(item->view, menu->view->size.width - 2 * offs, menu->itemHeight);
1009         }
1010 }
1011
1012 static void handleItemDrop(WEditMenu * menu, WEditMenuItem * item, int x, int y)
1013 {
1014         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1015         Window blaw;
1016         int mx, my;
1017         int index;
1018
1019         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, 0, 0, &mx, &my, &blaw);
1020
1021         index = y - my;
1022         if (menu->flags.isTitled) {
1023                 index -= menu->titleHeight;
1024         }
1025         index = (index + menu->itemHeight / 2) / menu->itemHeight;
1026         if (index < 0)
1027                 index = 0;
1028
1029         if (menu->flags.isTitled) {
1030                 index++;
1031         }
1032
1033         if (index > WMGetArrayItemCount(menu->items)) {
1034                 WMAddToArray(menu->items, item);
1035         } else {
1036                 WMInsertInArray(menu->items, index, item);
1037         }
1038
1039         W_ReparentView(item->view, menu->view, 0, index * menu->itemHeight);
1040
1041         item->parent = menu;
1042         if (item->submenu) {
1043                 item->submenu->parent = menu;
1044         }
1045
1046         updateMenuContents(menu);
1047 }
1048
1049 static void dragMenu(WEditMenu * menu)
1050 {
1051         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1052         XEvent ev;
1053         Bool done = False;
1054         int dx, dy;
1055         unsigned blau;
1056         Window blaw;
1057
1058         XGetGeometry(scr->display, W_VIEW_DRAWABLE(menu->view), &blaw, &dx, &dy, &blau, &blau, &blau, &blau);
1059
1060         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, dx, dy, &dx, &dy, &blaw);
1061
1062         dx = menu->dragX - dx;
1063         dy = menu->dragY - dy;
1064
1065         XGrabPointer(scr->display, scr->rootWin, False,
1066                      ButtonReleaseMask | ButtonMotionMask,
1067                      GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
1068
1069         if (menu->parent)
1070                 WTearOffEditMenu(menu->parent, menu);
1071
1072         while (!done) {
1073                 WMNextEvent(scr->display, &ev);
1074
1075                 switch (ev.type) {
1076                 case ButtonRelease:
1077                         done = True;
1078                         break;
1079
1080                 case MotionNotify:
1081                         while (XCheckMaskEvent(scr->display, ButtonMotionMask, &ev)) ;
1082
1083                         WMMoveWidget(menu, ev.xmotion.x_root - dx, ev.xmotion.y_root - dy);
1084                         break;
1085
1086                 default:
1087                         WMHandleEvent(&ev);
1088                         break;
1089                 }
1090         }
1091
1092         XUngrabPointer(scr->display, CurrentTime);
1093 }
1094
1095 static WEditMenuItem *duplicateItem(WEditMenuItem * item)
1096 {
1097         WEditMenuItem *nitem;
1098
1099         nitem = WCreateEditMenuItem(item->parent, item->label, False);
1100         if (item->pixmap)
1101                 nitem->pixmap = WMRetainPixmap(item->pixmap);
1102
1103         return nitem;
1104 }
1105
1106 static WEditMenu *duplicateMenu(WEditMenu * menu)
1107 {
1108         WEditMenu *nmenu;
1109         WEditMenuItem *item;
1110         WMArrayIterator iter;
1111         Bool first = menu->flags.isTitled;
1112
1113         nmenu = WCreateEditMenu(WMWidgetScreen(menu), WGetEditMenuTitle(menu));
1114
1115         memcpy(&nmenu->flags, &menu->flags, sizeof(menu->flags));
1116         nmenu->delegate = menu->delegate;
1117
1118         WM_ITERATE_ARRAY(menu->items, item, iter) {
1119                 WEditMenuItem *nitem;
1120
1121                 if (first) {
1122                         first = False;
1123                         continue;
1124                 }
1125
1126                 nitem = WAddMenuItemWithTitle(nmenu, item->label);
1127                 if (item->pixmap)
1128                         WSetEditMenuItemImage(nitem, item->pixmap);
1129
1130                 if (menu->delegate && menu->delegate->itemCloned) {
1131                         (*menu->delegate->itemCloned) (menu->delegate, menu, item, nitem);
1132                 }
1133         }
1134
1135         WMRealizeWidget(nmenu);
1136
1137         return nmenu;
1138 }
1139
1140 static void dragItem(WEditMenu * menu, WEditMenuItem * item, Bool copy)
1141 {
1142         static XColor black = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 };
1143         static XColor green = { 0x0045b045, 0x4500, 0xb000, 0x4500, DoRed | DoGreen | DoBlue, 0 };
1144         static XColor back = { 0, 0xffff, 0xffff, 0xffff, DoRed | DoGreen | DoBlue, 0 };
1145         Display *dpy = W_VIEW_DISPLAY(menu->view);
1146         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1147         int x, y;
1148         int dx, dy;
1149         Bool done = False;
1150         Window blaw;
1151         int blai;
1152         unsigned blau;
1153         Window win;
1154         WMView *dview;
1155         int orix, oriy;
1156         Bool enteredMenu = False;
1157         WMSize oldSize = item->view->size;
1158         WEditMenuItem *dritem = item;
1159         WEditMenu *dmenu = NULL;
1160
1161         if (item->flags.isTitle) {
1162                 WMRaiseWidget(menu);
1163
1164                 dragMenu(menu);
1165
1166                 return;
1167         }
1168
1169         selectItem(menu, NULL);
1170
1171         win = scr->rootWin;
1172
1173         XTranslateCoordinates(dpy, W_VIEW_DRAWABLE(item->view), win, 0, 0, &orix, &oriy, &blaw);
1174
1175         dview = W_CreateUnmanagedTopView(scr);
1176         W_SetViewBackgroundColor(dview, scr->black);
1177         W_ResizeView(dview, W_VIEW_WIDTH(item->view), W_VIEW_HEIGHT(item->view));
1178         W_MoveView(dview, orix, oriy);
1179         W_RealizeView(dview);
1180
1181         if (menu->flags.isFactory || copy) {
1182                 dritem = duplicateItem(item);
1183
1184                 W_ReparentView(dritem->view, dview, 0, 0);
1185                 WMResizeWidget(dritem, oldSize.width, oldSize.height);
1186                 WMRealizeWidget(dritem);
1187                 WMMapWidget(dritem);
1188         } else {
1189                 W_ReparentView(item->view, dview, 0, 0);
1190         }
1191
1192         W_MapView(dview);
1193
1194         dx = menu->dragX - orix;
1195         dy = menu->dragY - oriy;
1196
1197         XGrabPointer(dpy, scr->rootWin, False,
1198                      ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
1199                      GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
1200
1201         if (menu->flags.acceptsDrop)
1202                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1203
1204         while (!done) {
1205                 XEvent ev;
1206
1207                 WMNextEvent(dpy, &ev);
1208
1209                 switch (ev.type) {
1210                 case MotionNotify:
1211                         while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
1212
1213                         XQueryPointer(dpy, win, &blaw, &blaw, &blai, &blai, &x, &y, &blau);
1214
1215                         dmenu = findMenuInWindow(dpy, win, x, y);
1216
1217                         if (dmenu) {
1218                                 handleDragOver(dmenu, dview, dritem, x - dx, y - dy);
1219                                 if (!enteredMenu) {
1220                                         enteredMenu = True;
1221                                         XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1222                                 }
1223                         } else {
1224                                 if (enteredMenu) {
1225                                         W_ResizeView(dview, oldSize.width, oldSize.height);
1226                                         W_ResizeView(dritem->view, oldSize.width, oldSize.height);
1227                                         enteredMenu = False;
1228                                         XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1229                                 }
1230                                 W_MoveView(dview, x - dx, y - dy);
1231                         }
1232
1233                         break;
1234
1235                 case ButtonRelease:
1236                         done = True;
1237                         break;
1238
1239                 default:
1240                         WMHandleEvent(&ev);
1241                         break;
1242                 }
1243         }
1244         XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1245
1246         XUngrabPointer(dpy, CurrentTime);
1247
1248         if (!enteredMenu) {
1249                 Bool rem = True;
1250
1251                 if (!menu->flags.isFactory && !copy) {
1252                         W_UnmapView(dview);
1253                         if (menu->delegate && menu->delegate->shouldRemoveItem) {
1254                                 rem = (*menu->delegate->shouldRemoveItem) (menu->delegate, menu, item);
1255                         }
1256                         W_MapView(dview);
1257                 }
1258
1259                 if (!rem || menu->flags.isFactory || copy) {
1260                         slideWindow(dpy, W_VIEW_DRAWABLE(dview), x - dx, y - dy, orix, oriy);
1261
1262                         if (!menu->flags.isFactory && !copy) {
1263                                 WRemoveEditMenuItem(menu, dritem);
1264                                 handleItemDrop(dmenu ? dmenu : menu, dritem, orix, oriy);
1265                         }
1266                 } else {
1267                         WRemoveEditMenuItem(menu, dritem);
1268                 }
1269         } else {
1270                 WRemoveEditMenuItem(menu, dritem);
1271
1272                 if (menu->delegate && menu->delegate->itemCloned && (menu->flags.isFactory || copy)) {
1273                         (*menu->delegate->itemCloned) (menu->delegate, menu, item, dritem);
1274                 }
1275
1276                 handleItemDrop(dmenu, dritem, x - dy, y - dy);
1277
1278                 if (item->submenu && (menu->flags.isFactory || copy)) {
1279                         WEditMenu *submenu;
1280
1281                         submenu = duplicateMenu(item->submenu);
1282                         WSetEditMenuSubmenu(dmenu, dritem, submenu);
1283                 }
1284         }
1285
1286         /* can't destroy now because we're being called from
1287          * the event handler of the item. and destroying now,
1288          * would mean destroying the item too in some cases.
1289          */
1290         WMAddIdleHandler((WMCallback *) W_DestroyView, dview);
1291 }
1292
1293 static void handleItemClick(XEvent * event, void *data)
1294 {
1295         WEditMenuItem *item = (WEditMenuItem *) data;
1296         WEditMenu *menu = item->parent;
1297
1298         switch (event->type) {
1299         case ButtonPress:
1300                 selectItem(menu, item);
1301
1302                 if (WMIsDoubleClick(event)) {
1303                         editItemLabel(item);
1304                 }
1305
1306                 menu->flags.isDragging = 1;
1307                 menu->dragX = event->xbutton.x_root;
1308                 menu->dragY = event->xbutton.y_root;
1309                 break;
1310
1311         case ButtonRelease:
1312                 menu->flags.isDragging = 0;
1313                 break;
1314
1315         case MotionNotify:
1316                 if (menu->flags.isDragging) {
1317                         if (abs(event->xbutton.x_root - menu->dragX) > 5
1318                             || abs(event->xbutton.y_root - menu->dragY) > 5) {
1319                                 menu->flags.isDragging = 0;
1320                                 dragItem(menu, item, event->xbutton.state & ControlMask);
1321                         }
1322                 }
1323                 break;
1324         }
1325 }
1326
1327 static void destroyEditMenu(WEditMenu * mPtr)
1328 {
1329         WMRemoveNotificationObserver(mPtr);
1330
1331         WMFreeArray(mPtr->items);
1332
1333         wfree(mPtr->tdelegate);
1334
1335         wfree(mPtr);
1336 }