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, const 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         /* 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(scr);
 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(WEditMenu * mPtr, 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         WMAddIdleHandler(WMDestroyWidget, menu->closeB);
 578         menu->closeB = NULL;
 579
 580         WEditMenuHide(menu);
 581 }
 582
 583 void WTearOffEditMenu(WEditMenu * menu, WEditMenu * submenu)
 584 {
 585         WEditMenuItem *item;
 586
 587         submenu->flags.isTornOff = 1;
 588
 589         item = (WEditMenuItem *) WMGetFromArray(submenu->items, 0);
 590
 591         submenu->closeB = WMCreateCommandButton(item);
 592         WMResizeWidget(submenu->closeB, 15, 15);
 593         WMMoveWidget(submenu->closeB, W_VIEW(submenu)->size.width - 20, 3);
 594         WMRealizeWidget(submenu->closeB);
 595         WMSetButtonText(submenu->closeB, "X");
 596         WMSetButtonAction(submenu->closeB, closeMenuAction, submenu);
 597         WMMapWidget(submenu->closeB);
 598
 599         if (menu->selectedItem && menu->selectedItem->submenu == submenu)
 600                 deselectItem(menu);
 601 }
 602
 603 Bool WEditMenuIsTornOff(WEditMenu * mPtr)
 604 {
 605         return mPtr->flags.isTornOff;
 606 }
 607
 608 void WEditMenuHide(WEditMenu * mPtr)
 609 {
 610         WEditMenuItem *item;
 611         int i = 0;
 612
 613         if (WMWidgetIsMapped(mPtr)) {
 614                 WMUnmapWidget(mPtr);
 615                 mPtr->flags.wasMapped = 1;
 616         } else {
 617                 mPtr->flags.wasMapped = 0;
 618         }
 619         while ((item = WGetEditMenuItem(mPtr, i++))) {
 620                 WEditMenu *submenu;
 621
 622                 submenu = WGetEditMenuSubmenu(mPtr, item);
 623                 if (submenu) {
 624                         WEditMenuHide(submenu);
 625                 }
 626         }
 627 }
 628
 629 void WEditMenuUnhide(WEditMenu * mPtr)
 630 {
 631         WEditMenuItem *item;
 632         int i = 0;
 633
 634         if (mPtr->flags.wasMapped) {
 635                 WMMapWidget(mPtr);
 636         }
 637         while ((item = WGetEditMenuItem(mPtr, i++))) {
 638                 WEditMenu *submenu;
 639
 640                 submenu = WGetEditMenuSubmenu(mPtr, item);
 641                 if (submenu) {
 642                         WEditMenuUnhide(submenu);
 643                 }
 644         }
 645 }
 646
 647 void WEditMenuShowAt(WEditMenu * menu, int x, int y)
 648 {
 649         XSizeHints *hints;
 650
 651         hints = XAllocSizeHints();
 652
 653         hints->flags = USPosition;
 654         hints->x = x;
 655         hints->y = y;
 656
 657         WMMoveWidget(menu, x, y);
 658         XSetWMNormalHints(W_VIEW_DISPLAY(menu->view), W_VIEW_DRAWABLE(menu->view), hints);
 659         XFree(hints);
 660
 661         WMMapWidget(menu);
 662 }
 663
 664 static void updateMenuContents(WEditMenu * mPtr)
 665 {
 666         int newW, newH;
 667         int w;
 668         int i;
 669         int iheight = mPtr->itemHeight;
 670         int offs = 1;
 671         WMArrayIterator iter;
 672         WEditMenuItem *item;
 673
 674         newW = 0;
 675         newH = offs;
 676
 677         i = 0;
 678         WM_ITERATE_ARRAY(mPtr->items, item, iter) {
 679                 w = getItemTextWidth(item);
 680
 681                 newW = WMAX(w, newW);
 682
 683                 WMMoveWidget(item, offs, newH);
 684                 if (i == 0 && mPtr->flags.isTitled) {
 685                         newH += mPtr->titleHeight;
 686                 } else {
 687                         newH += iheight;
 688                 }
 689                 i = 1;
 690         }
 691
 692         newW += iheight + 10;
 693         newH--;
 694
 695         if (mPtr->minSize.width)
 696                 newW = WMAX(newW, mPtr->minSize.width);
 697         if (mPtr->maxSize.width)
 698                 newW = WMIN(newW, mPtr->maxSize.width);
 699
 700         if (mPtr->minSize.height)
 701                 newH = WMAX(newH, mPtr->minSize.height);
 702         if (mPtr->maxSize.height)
 703                 newH = WMIN(newH, mPtr->maxSize.height);
 704
 705         if (W_VIEW(mPtr)->size.width == newW && mPtr->view->size.height == newH + 1)
 706                 return;
 707
 708         W_ResizeView(mPtr->view, newW, newH + 1);
 709
 710         if (mPtr->closeB)
 711                 WMMoveWidget(mPtr->closeB, newW - 20, 3);
 712
 713         newW -= 2 * offs;
 714
 715         i = 0;
 716         WM_ITERATE_ARRAY(mPtr->items, item, iter) {
 717                 if (i == 0 && mPtr->flags.isTitled) {
 718                         WMResizeWidget(item, newW, mPtr->titleHeight);
 719                 } else {
 720                         WMResizeWidget(item, newW, iheight);
 721                 }
 722                 i = 1;
 723         }
 724 }
 725
 726 static void deselectItem(WEditMenu * menu)
 727 {
 728         WEditMenu *submenu;
 729         WEditMenuItem *item = menu->selectedItem;
 730
 731         highlightItem(item, False);
 732
 733         if (menu->delegate && menu->delegate->itemDeselected) {
 734                 (*menu->delegate->itemDeselected) (menu->delegate, menu, item);
 735         }
 736         submenu = item->submenu;
 737
 738         if (submenu && !WEditMenuIsTornOff(submenu)) {
 739                 WEditMenuHide(submenu);
 740         }
 741
 742         menu->selectedItem = NULL;
 743 }
 744
 745 static void selectItem(WEditMenu * menu, WEditMenuItem * item)
 746 {
 747         if (!menu->flags.isSelectable || menu->selectedItem == item) {
 748                 return;
 749         }
 750         if (menu->selectedItem) {
 751                 deselectItem(menu);
 752         }
 753
 754         if (menu->flags.isEditing) {
 755                 stopEditItem(menu, False);
 756         }
 757
 758         if (item && !item->flags.isTitle) {
 759                 highlightItem(item, True);
 760
 761                 if (item->submenu && !W_VIEW_MAPPED(item->submenu->view)) {
 762                         WMPoint pt;
 763
 764                         pt = WGetEditMenuLocationForSubmenu(menu, item->submenu);
 765
 766                         WEditMenuShowAt(item->submenu, pt.x, pt.y);
 767
 768                         item->submenu->flags.isTornOff = 0;
 769                 }
 770
 771                 WMPostNotificationName("EditMenuItemSelected", menu, NULL);
 772
 773                 if (menu->delegate && menu->delegate->itemSelected) {
 774                         (*menu->delegate->itemSelected) (menu->delegate, menu, item);
 775                 }
 776         }
 777
 778         menu->selectedItem = item;
 779 }
 780
 781 static void paintMenu(WEditMenu * mPtr)
 782 {
 783         W_View *view = mPtr->view;
 784
 785         W_DrawRelief(W_VIEW_SCREEN(view), W_VIEW_DRAWABLE(view), 0, 0,
 786                      W_VIEW_WIDTH(view), W_VIEW_HEIGHT(view), WRSimple);
 787 }
 788
 789 static void handleEvents(XEvent * event, void *data)
 790 {
 791         WEditMenu *mPtr = (WEditMenu *) data;
 792
 793         switch (event->type) {
 794         case DestroyNotify:
 795                 destroyEditMenu(mPtr);
 796                 break;
 797
 798         case Expose:
 799                 if (event->xexpose.count == 0)
 800                         paintMenu(mPtr);
 801                 break;
 802         }
 803 }
 804
 805 /* -------------------------- Menu Label Editing ------------------------ */
 806
 807 static void stopEditItem(WEditMenu * menu, Bool apply)
 808 {
 809         char *text;
 810
 811         if (apply) {
 812                 text = WMGetTextFieldText(menu->tfield);
 813
 814                 wfree(menu->selectedItem->label);
 815                 menu->selectedItem->label = wstrdup(text);
 816
 817                 updateMenuContents(menu);
 818
 819                 if (menu->delegate && menu->delegate->itemEdited) {
 820                         (*menu->delegate->itemEdited) (menu->delegate, menu, menu->selectedItem);
 821                 }
 822
 823         }
 824         WMUnmapWidget(menu->tfield);
 825         menu->flags.isEditing = 0;
 826 }
 827
 828 static void textEndedEditing(struct WMTextFieldDelegate *self, WMNotification * notif)
 829 {
 830         WEditMenu *menu = (WEditMenu *) self->data;
 831         uintptr_t reason;
 832         int i;
 833         WEditMenuItem *item;
 834
 835         if (!menu->flags.isEditing)
 836                 return;
 837
 838         reason = (uintptr_t)WMGetNotificationClientData(notif);
 839
 840         switch (reason) {
 841         case WMEscapeTextMovement:
 842                 stopEditItem(menu, False);
 843                 break;
 844
 845         case WMReturnTextMovement:
 846                 stopEditItem(menu, True);
 847                 break;
 848
 849         case WMTabTextMovement:
 850                 stopEditItem(menu, True);
 851
 852                 i = WMGetFirstInArray(menu->items, menu->selectedItem);
 853                 item = WMGetFromArray(menu->items, i + 1);
 854                 if (item != NULL) {
 855                         selectItem(menu, item);
 856                         editItemLabel(item);
 857                 }
 858                 break;
 859
 860         case WMBacktabTextMovement:
 861                 stopEditItem(menu, True);
 862
 863                 i = WMGetFirstInArray(menu->items, menu->selectedItem);
 864                 item = WMGetFromArray(menu->items, i - 1);
 865                 if (item != NULL) {
 866                         selectItem(menu, item);
 867                         editItemLabel(item);
 868                 }
 869                 break;
 870         }
 871 }
 872
 873 static WMTextFieldDelegate textFieldDelegate = {
 874         NULL,
 875         NULL,
 876         NULL,
 877         textEndedEditing,
 878         NULL,
 879         NULL
 880 };
 881
 882 static void editItemLabel(WEditMenuItem * item)
 883 {
 884         WEditMenu *mPtr = item->parent;
 885         WMTextField *tf;
 886
 887         if (!mPtr->flags.isEditable) {
 888                 return;
 889         }
 890
 891         if (!mPtr->tfield) {
 892                 mPtr->tfield = WMCreateTextField(mPtr);
 893                 WMSetTextFieldBeveled(mPtr->tfield, False);
 894                 WMRealizeWidget(mPtr->tfield);
 895
 896                 mPtr->tdelegate = wmalloc(sizeof(WMTextFieldDelegate));
 897                 memcpy(mPtr->tdelegate, &textFieldDelegate, sizeof(WMTextFieldDelegate));
 898
 899                 mPtr->tdelegate->data = mPtr;
 900
 901                 WMSetTextFieldDelegate(mPtr->tfield, mPtr->tdelegate);
 902         }
 903         tf = mPtr->tfield;
 904
 905         WMSetTextFieldText(tf, item->label);
 906         WMSelectTextFieldRange(tf, wmkrange(0, strlen(item->label)));
 907         WMResizeWidget(tf, mPtr->view->size.width, mPtr->itemHeight);
 908         WMMoveWidget(tf, 0, item->view->pos.y);
 909         WMMapWidget(tf);
 910         WMSetFocusToWidget(tf);
 911
 912         mPtr->flags.isEditing = 1;
 913 }
 914
 915 /* -------------------------------------------------- */
 916
 917 static void slideWindow(Display * dpy, Window win, int srcX, int srcY, int dstX, int dstY)
 918 {
 919         double x, y, dx, dy;
 920         int i;
 921         int iterations;
 922
 923         iterations = WMIN(25, WMAX(abs(dstX - srcX), abs(dstY - srcY)));
 924
 925         x = srcX;
 926         y = srcY;
 927
 928         dx = (double)(dstX - srcX) / iterations;
 929         dy = (double)(dstY - srcY) / iterations;
 930
 931         for (i = 0; i <= iterations; i++) {
 932                 XMoveWindow(dpy, win, x, y);
 933                 XFlush(dpy);
 934
 935                 wusleep(800);
 936
 937                 x += dx;
 938                 y += dy;
 939         }
 940 }
 941
 942 static int errorHandler(Display * d, XErrorEvent * ev)
 943 {
 944         /* Parameter not used, but tell the compiler that it is ok */
 945         (void) d;
 946         (void) ev;
 947
 948         /* just ignore */
 949         return 0;
 950 }
 951
 952 static WEditMenu *findMenuInWindow(Display * dpy, Window toplevel, int x, int y)
 953 {
 954         Window foo, bar;
 955         Window *children;
 956         unsigned nchildren;
 957         int i;
 958         WEditMenu *menu;
 959         WMView *view;
 960         int (*oldHandler) (Display *, XErrorEvent *);
 961
 962         view = W_GetViewForXWindow(dpy, toplevel);
 963         if (view && view->self && WMWidgetClass(view->self) == EditMenuClass) {
 964                 menu = (WEditMenu *) view->self;
 965                 if (menu->flags.acceptsDrop) {
 966                         return menu;
 967                 }
 968         }
 969
 970         if (!XQueryTree(dpy, toplevel, &foo, &bar, &children, &nchildren) || children == NULL) {
 971                 return NULL;
 972         }
 973
 974         oldHandler = XSetErrorHandler(errorHandler);
 975
 976         /* first window that contains the point is the one */
 977         for (i = nchildren - 1; i >= 0; i--) {
 978                 XWindowAttributes attr;
 979
 980                 if (XGetWindowAttributes(dpy, children[i], &attr)
 981                     && attr.map_state == IsViewable
 982                     && x >= attr.x && y >= attr.y && x < attr.x + attr.width && y < attr.y + attr.height) {
 983                         Window tmp;
 984
 985                         tmp = children[i];
 986
 987                         menu = findMenuInWindow(dpy, tmp, x - attr.x, y - attr.y);
 988                         if (menu) {
 989                                 XFree(children);
 990                                 return menu;
 991                         }
 992                 }
 993         }
 994
 995         XSetErrorHandler(oldHandler);
 996
 997         XFree(children);
 998         return NULL;
 999 }
1000
1001 static void handleDragOver(WEditMenu * menu, WMView * view, WEditMenuItem * item, int x, int y)
1002 {
1003         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1004         Window blaw;
1005         int mx, my;
1006         int offs;
1007
1008         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, 0, 0, &mx, &my, &blaw);
1009
1010         offs = menu->flags.standalone ? 0 : 1;
1011
1012         W_MoveView(view, mx + offs, y);
1013         if (view->size.width != menu->view->size.width) {
1014                 W_ResizeView(view, menu->view->size.width - 2 * offs, menu->itemHeight);
1015                 W_ResizeView(item->view, menu->view->size.width - 2 * offs, menu->itemHeight);
1016         }
1017 }
1018
1019 static void handleItemDrop(WEditMenu * menu, WEditMenuItem * item, int x, int y)
1020 {
1021         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1022         Window blaw;
1023         int mx, my;
1024         int index;
1025
1026         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, 0, 0, &mx, &my, &blaw);
1027
1028         index = y - my;
1029         if (menu->flags.isTitled) {
1030                 index -= menu->titleHeight;
1031         }
1032         index = (index + menu->itemHeight / 2) / menu->itemHeight;
1033         if (index < 0)
1034                 index = 0;
1035
1036         if (menu->flags.isTitled) {
1037                 index++;
1038         }
1039
1040         if (index > WMGetArrayItemCount(menu->items)) {
1041                 WMAddToArray(menu->items, item);
1042         } else {
1043                 WMInsertInArray(menu->items, index, item);
1044         }
1045
1046         W_ReparentView(item->view, menu->view, 0, index * menu->itemHeight);
1047
1048         item->parent = menu;
1049         if (item->submenu) {
1050                 item->submenu->parent = menu;
1051         }
1052
1053         updateMenuContents(menu);
1054 }
1055
1056 static void dragMenu(WEditMenu * menu)
1057 {
1058         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1059         XEvent ev;
1060         Bool done = False;
1061         int dx, dy;
1062         unsigned blau;
1063         Window blaw;
1064
1065         XGetGeometry(scr->display, W_VIEW_DRAWABLE(menu->view), &blaw, &dx, &dy, &blau, &blau, &blau, &blau);
1066
1067         XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(menu->view), scr->rootWin, dx, dy, &dx, &dy, &blaw);
1068
1069         dx = menu->dragX - dx;
1070         dy = menu->dragY - dy;
1071
1072         XGrabPointer(scr->display, scr->rootWin, False,
1073                      ButtonReleaseMask | ButtonMotionMask,
1074                      GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
1075
1076         if (menu->parent)
1077                 WTearOffEditMenu(menu->parent, menu);
1078
1079         while (!done) {
1080                 WMNextEvent(scr->display, &ev);
1081
1082                 switch (ev.type) {
1083                 case ButtonRelease:
1084                         done = True;
1085                         break;
1086
1087                 case MotionNotify:
1088                         while (XCheckMaskEvent(scr->display, ButtonMotionMask, &ev)) ;
1089
1090                         WMMoveWidget(menu, ev.xmotion.x_root - dx, ev.xmotion.y_root - dy);
1091                         break;
1092
1093                 default:
1094                         WMHandleEvent(&ev);
1095                         break;
1096                 }
1097         }
1098
1099         XUngrabPointer(scr->display, CurrentTime);
1100 }
1101
1102 static WEditMenuItem *duplicateItem(WEditMenuItem * item)
1103 {
1104         WEditMenuItem *nitem;
1105
1106         nitem = WCreateEditMenuItem(item->parent, item->label, False);
1107         if (item->pixmap)
1108                 nitem->pixmap = WMRetainPixmap(item->pixmap);
1109
1110         return nitem;
1111 }
1112
1113 static WEditMenu *duplicateMenu(WEditMenu * menu)
1114 {
1115         WEditMenu *nmenu;
1116         WEditMenuItem *item;
1117         WMArrayIterator iter;
1118         Bool first = menu->flags.isTitled;
1119
1120         nmenu = WCreateEditMenu(WMWidgetScreen(menu), WGetEditMenuTitle(menu));
1121
1122         memcpy(&nmenu->flags, &menu->flags, sizeof(menu->flags));
1123         nmenu->delegate = menu->delegate;
1124
1125         WM_ITERATE_ARRAY(menu->items, item, iter) {
1126                 WEditMenuItem *nitem;
1127
1128                 if (first) {
1129                         first = False;
1130                         continue;
1131                 }
1132
1133                 nitem = WAddMenuItemWithTitle(nmenu, item->label);
1134                 if (item->pixmap)
1135                         WSetEditMenuItemImage(nitem, item->pixmap);
1136
1137                 if (menu->delegate && menu->delegate->itemCloned) {
1138                         (*menu->delegate->itemCloned) (menu->delegate, menu, item, nitem);
1139                 }
1140         }
1141
1142         WMRealizeWidget(nmenu);
1143
1144         return nmenu;
1145 }
1146
1147 static void dragItem(WEditMenu * menu, WEditMenuItem * item, Bool copy)
1148 {
1149         static XColor black = { 0, 0, 0, 0, DoRed | DoGreen | DoBlue, 0 };
1150         static XColor green = { 0x0045b045, 0x4500, 0xb000, 0x4500, DoRed | DoGreen | DoBlue, 0 };
1151         static XColor back = { 0, 0xffff, 0xffff, 0xffff, DoRed | DoGreen | DoBlue, 0 };
1152         Display *dpy = W_VIEW_DISPLAY(menu->view);
1153         WMScreen *scr = W_VIEW_SCREEN(menu->view);
1154         int x, y;
1155         int dx, dy;
1156         Bool done = False;
1157         Window blaw;
1158         int blai;
1159         unsigned blau;
1160         Window win;
1161         WMView *dview;
1162         int orix, oriy;
1163         Bool enteredMenu = False;
1164         WMSize oldSize = item->view->size;
1165         WEditMenuItem *dritem = item;
1166         WEditMenu *dmenu = NULL;
1167
1168         if (item->flags.isTitle) {
1169                 WMRaiseWidget(menu);
1170
1171                 dragMenu(menu);
1172
1173                 return;
1174         }
1175
1176         selectItem(menu, NULL);
1177
1178         win = scr->rootWin;
1179
1180         XTranslateCoordinates(dpy, W_VIEW_DRAWABLE(item->view), win, 0, 0, &orix, &oriy, &blaw);
1181
1182         dview = W_CreateUnmanagedTopView(scr);
1183         W_SetViewBackgroundColor(dview, scr->black);
1184         W_ResizeView(dview, W_VIEW_WIDTH(item->view), W_VIEW_HEIGHT(item->view));
1185         W_MoveView(dview, orix, oriy);
1186         W_RealizeView(dview);
1187
1188         if (menu->flags.isFactory || copy) {
1189                 dritem = duplicateItem(item);
1190
1191                 W_ReparentView(dritem->view, dview, 0, 0);
1192                 WMResizeWidget(dritem, oldSize.width, oldSize.height);
1193                 WMRealizeWidget(dritem);
1194                 WMMapWidget(dritem);
1195         } else {
1196                 W_ReparentView(item->view, dview, 0, 0);
1197         }
1198
1199         W_MapView(dview);
1200
1201         dx = menu->dragX - orix;
1202         dy = menu->dragY - oriy;
1203
1204         XGrabPointer(dpy, scr->rootWin, False,
1205                      ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
1206                      GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
1207
1208         if (menu->flags.acceptsDrop)
1209                 XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1210
1211         while (!done) {
1212                 XEvent ev;
1213
1214                 WMNextEvent(dpy, &ev);
1215
1216                 switch (ev.type) {
1217                 case MotionNotify:
1218                         while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
1219
1220                         XQueryPointer(dpy, win, &blaw, &blaw, &blai, &blai, &x, &y, &blau);
1221
1222                         dmenu = findMenuInWindow(dpy, win, x, y);
1223
1224                         if (dmenu) {
1225                                 handleDragOver(dmenu, dview, dritem, x - dx, y - dy);
1226                                 if (!enteredMenu) {
1227                                         enteredMenu = True;
1228                                         XRecolorCursor(dpy, scr->defaultCursor, &green, &back);
1229                                 }
1230                         } else {
1231                                 if (enteredMenu) {
1232                                         W_ResizeView(dview, oldSize.width, oldSize.height);
1233                                         W_ResizeView(dritem->view, oldSize.width, oldSize.height);
1234                                         enteredMenu = False;
1235                                         XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1236                                 }
1237                                 W_MoveView(dview, x - dx, y - dy);
1238                         }
1239
1240                         break;
1241
1242                 case ButtonRelease:
1243                         done = True;
1244                         break;
1245
1246                 default:
1247                         WMHandleEvent(&ev);
1248                         break;
1249                 }
1250         }
1251         XRecolorCursor(dpy, scr->defaultCursor, &black, &back);
1252
1253         XUngrabPointer(dpy, CurrentTime);
1254
1255         if (!enteredMenu) {
1256                 Bool rem = True;
1257
1258                 if (!menu->flags.isFactory && !copy) {
1259                         W_UnmapView(dview);
1260                         if (menu->delegate && menu->delegate->shouldRemoveItem) {
1261                                 rem = (*menu->delegate->shouldRemoveItem) (menu->delegate, menu, item);
1262                         }
1263                         W_MapView(dview);
1264                 }
1265
1266                 if (!rem || menu->flags.isFactory || copy) {
1267                         slideWindow(dpy, W_VIEW_DRAWABLE(dview), x - dx, y - dy, orix, oriy);
1268
1269                         if (!menu->flags.isFactory && !copy) {
1270                                 WRemoveEditMenuItem(menu, dritem);
1271                                 handleItemDrop(dmenu ? dmenu : menu, dritem, orix, oriy);
1272                         }
1273                 } else {
1274                         WRemoveEditMenuItem(menu, dritem);
1275                 }
1276         } else {
1277                 WRemoveEditMenuItem(menu, dritem);
1278
1279                 if (menu->delegate && menu->delegate->itemCloned && (menu->flags.isFactory || copy)) {
1280                         (*menu->delegate->itemCloned) (menu->delegate, menu, item, dritem);
1281                 }
1282
1283                 handleItemDrop(dmenu, dritem, x - dy, y - dy);
1284
1285                 if (item->submenu && (menu->flags.isFactory || copy)) {
1286                         WEditMenu *submenu;
1287
1288                         submenu = duplicateMenu(item->submenu);
1289                         WSetEditMenuSubmenu(dmenu, dritem, submenu);
1290                 }
1291         }
1292
1293         /* can't destroy now because we're being called from
1294          * the event handler of the item. and destroying now,
1295          * would mean destroying the item too in some cases.
1296          */
1297         WMAddIdleHandler((WMCallback *) W_DestroyView, dview);
1298 }
1299
1300 static void handleItemClick(XEvent * event, void *data)
1301 {
1302         WEditMenuItem *item = (WEditMenuItem *) data;
1303         WEditMenu *menu = item->parent;
1304
1305         switch (event->type) {
1306         case ButtonPress:
1307                 selectItem(menu, item);
1308
1309                 if (WMIsDoubleClick(event)) {
1310                         editItemLabel(item);
1311                 }
1312
1313                 menu->flags.isDragging = 1;
1314                 menu->dragX = event->xbutton.x_root;
1315                 menu->dragY = event->xbutton.y_root;
1316                 break;
1317
1318         case ButtonRelease:
1319                 menu->flags.isDragging = 0;
1320                 break;
1321
1322         case MotionNotify:
1323                 if (menu->flags.isDragging) {
1324                         if (abs(event->xbutton.x_root - menu->dragX) > 5
1325                             || abs(event->xbutton.y_root - menu->dragY) > 5) {
1326                                 menu->flags.isDragging = 0;
1327                                 dragItem(menu, item, event->xbutton.state & ControlMask);
1328                         }
1329                 }
1330                 break;
1331         }
1332 }
1333
1334 static void destroyEditMenu(WEditMenu * mPtr)
1335 {
1336         WMRemoveNotificationObserver(mPtr);
1337
1338         WMFreeArray(mPtr->items);
1339
1340         wfree(mPtr->tdelegate);
1341
1342         wfree(mPtr);
1343 }