WPrefs.app/editmenu.c

   1 /* editmenu.c - editable menus
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1999 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #if 0
  24 #include <WINGsP.h>
  25 #include <WUtil.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <ctype.h>
  29
  30 #include "editmenu.h"
  31
  32 typedef struct W_EditMenuItem {
  33     W_Class widgetClass;
  34     WMView *view;
  35
  36     struct W_EditMenu *menu;
  37
  38     char *label;
  39
  40     WMTextField *textField;
  41
  42     struct W_EditMenu *submenu;        /* if it's a cascade, NULL otherwise */
  43 } EditMenuItem;
  44
  45
  46 typedef struct W_EditMenu {
  47     W_Class widgetClass;
  48     WMView *view;
  49
  50     struct W_EditMenu *parent;
  51
  52     char *label;
  53
  54     int itemCount;
  55     int itemsAlloced;
  56     struct W_EditMenuItem **items;
  57
  58     int titleHeight;
  59     int itemHeight;
  60
  61     struct W_EditMenu *next;
  62     struct W_EditMenu *prev;
  63
  64     /* item dragging */
  65     int draggedItem;
  66     int dragX, dragY;
  67 } EditMenu;
  68
  69
  70
  71 /******************** WEditMenuItem ********************/
  72
  73 static void destroyEditMenuItem(WEditMenuItem *iPtr);
  74 static void paintEditMenuItem(WEditMenuItem *iPtr);
  75
  76 static void handleItemEvents(XEvent *event, void *data);
  77 static void handleItemActionEvents(XEvent *event, void *data);
  78
  79
  80 static W_ViewProcedureTable WEditMenuItemViewProcedures = {
  81         NULL,
  82         NULL,
  83         NULL
  84 };
  85
  86
  87 static W_Class EditMenuItemClass = 0;
  88
  89
  90 W_Class
  91 InitEditMenuItem(WMScreen *scr)
  92 {
  93     /* register our widget with WINGs and get our widget class ID */
  94     if (!EditMenuItemClass) {
  95         EditMenuItemClass = W_RegisterUserWidget(&WEditMenuItemViewProcedures);
  96     }
  97
  98     return EditMenuItemClass;
  99 }
 100
 101
 102 WEditMenuItem*
 103 WCreateEditMenuItem(WMWidget *parent, char *title)
 104 {
 105     WEditMenuItem *iPtr;
 106
 107     if (!EditMenuItemClass)
 108         InitEditMenuItem(WMWidgetScreen(parent));
 109
 110
 111     iPtr = wmalloc(sizeof(WEditMenuItem));
 112
 113     memset(iPtr, 0, sizeof(WEditMenuItem));
 114
 115     iPtr->widgetClass = EditMenuItemClass;
 116
 117     iPtr->view = W_CreateView(W_VIEW(parent));
 118     if (!iPtr->view) {
 119         free(iPtr);
 120         return NULL;
 121     }
 122     iPtr->view->self = iPtr;
 123
 124     iPtr->label = wstrdup(title);
 125
 126     WMCreateEventHandler(iPtr->view, ExposureMask|StructureNotifyMask,
 127                          handleItemEvents, iPtr);
 128
 129     WMCreateEventHandler(iPtr->view, ButtonPressMask, handleItemActionEvents,
 130                          iPtr);
 131
 132     return iPtr;
 133 }
 134
 135
 136
 137 static void
 138 paintEditMenuItem(WEditMenuItem *iPtr)
 139 {
 140     WMScreen *scr = WMWidgetScreen(iPtr);
 141     WMColor *black = scr->black;
 142     Window win = W_VIEW(iPtr)->window;
 143     int w = W_VIEW(iPtr)->size.width;
 144     int h = WMFontHeight(scr->normalFont) + 6;
 145
 146     if (!iPtr->view->flags.realized)
 147         return;
 148
 149     XClearWindow(scr->display, win);
 150
 151     W_DrawRelief(scr, win, 0, 0, w+1, h, WRRaised);
 152
 153     WMDrawString(scr, win, WMColorGC(black), scr->normalFont, 5, 3, iPtr->label,
 154                  strlen(iPtr->label));
 155 }
 156
 157
 158 static void
 159 handleItemEvents(XEvent *event, void *data)
 160 {
 161     WEditMenuItem *iPtr = (WEditMenuItem*)data;
 162
 163
 164     switch (event->type) {
 165      case Expose:
 166         if (event->xexpose.count!=0)
 167             break;
 168         paintEditMenuItem(iPtr);
 169         break;
 170
 171      case DestroyNotify:
 172         destroyEditMenuItem(iPtr);
 173         break;
 174
 175     }
 176 }
 177
 178
 179 static void
 180 handleItemActionEvents(XEvent *event, void *data)
 181 {
 182     WEditMenuItem *iPtr = (WEditMenuItem*)data;
 183
 184     switch (event->type) {
 185      case ButtonPress:
 186         break;
 187     }
 188 }
 189
 190
 191
 192 static void
 193 destroyEditMenuItem(WEditMenuItem *iPtr)
 194 {
 195     if (iPtr->label)
 196         free(iPtr->label);
 197
 198     free(iPtr);
 199 }
 200
 201
 202
 203 /******************** WEditMenu *******************/
 204
 205
 206 static WEditMenu *EditMenuList = NULL;
 207
 208 static void destroyEditMenu(WEditMenu *mPtr);
 209 static void paintEditMenu(WEditMenu *mPtr, int y);
 210
 211 static void updateMenuContents(WEditMenu *mPtr);
 212
 213 static void handleEvents(XEvent *event, void *data);
 214 static void handleActionEvents(XEvent *event, void *data);
 215
 216 static void handleItemDrag(XEvent *event, void *data);
 217
 218
 219 static W_ViewProcedureTable WEditMenuViewProcedures = {
 220         NULL,
 221         NULL,
 222         NULL
 223 };
 224
 225
 226 static W_Class EditMenuClass = 0;
 227
 228
 229 W_Class
 230 InitEditMenu(WMScreen *scr)
 231 {
 232     /* register our widget with WINGs and get our widget class ID */
 233     if (!EditMenuClass) {
 234
 235         EditMenuClass = W_RegisterUserWidget(&WEditMenuViewProcedures);
 236     }
 237
 238     return EditMenuClass;
 239 }
 240
 241
 242
 243 typedef struct {
 244     int flags;
 245     int window_style;
 246     int window_level;
 247     int reserved;
 248     Pixmap miniaturize_pixmap;         /* pixmap for miniaturize button */
 249     Pixmap close_pixmap;               /* pixmap for close button */
 250     Pixmap miniaturize_mask;           /* miniaturize pixmap mask */
 251     Pixmap close_mask;                 /* close pixmap mask */
 252     int extra_flags;
 253 } GNUstepWMAttributes;
 254
 255
 256 #define GSWindowStyleAttr       (1<<0)
 257 #define GSWindowLevelAttr       (1<<1)
 258
 259
 260 static void
 261 writeGNUstepWMAttr(WMScreen *scr, Window window, GNUstepWMAttributes *attr)
 262 {
 263     unsigned long data[9];
 264
 265     /* handle idiot compilers where array of CARD32 != struct of CARD32 */
 266     data[0] = attr->flags;
 267     data[1] = attr->window_style;
 268     data[2] = attr->window_level;
 269     data[3] = 0;                       /* reserved */
 270     /* The X protocol says XIDs are 32bit */
 271     data[4] = attr->miniaturize_pixmap;
 272     data[5] = attr->close_pixmap;
 273     data[6] = attr->miniaturize_mask;
 274     data[7] = attr->close_mask;
 275     data[8] = attr->extra_flags;
 276     XChangeProperty(scr->display, window, scr->attribsAtom, scr->attribsAtom,
 277                     32, PropModeReplace,  (unsigned char *)data, 9);
 278 }
 279
 280
 281 static void
 282 realizeObserver(void *self, WMNotification *not)
 283 {
 284     WEditMenu *menu = (WEditMenu*)self;
 285     GNUstepWMAttributes attribs;
 286
 287     memset(&attribs, 0, sizeof(GNUstepWMAttributes));
 288     attribs.flags = GSWindowStyleAttr|GSWindowLevelAttr;
 289     attribs.window_style = WMBorderlessWindowMask;
 290     attribs.window_level = WMSubmenuWindowLevel;
 291
 292     writeGNUstepWMAttr(WMWidgetScreen(menu), menu->view->window, &attribs);
 293 }
 294
 295
 296 WEditMenu*
 297 WCreateEditMenu(WMScreen *scr, char *title)
 298 {
 299     WEditMenu *mPtr;
 300
 301     if (!EditMenuClass)
 302         InitEditMenu(scr);
 303
 304
 305     mPtr = wmalloc(sizeof(WEditMenu));
 306
 307     memset(mPtr, 0, sizeof(WEditMenu));
 308
 309     mPtr->widgetClass = EditMenuClass;
 310
 311     mPtr->view = W_CreateTopView(scr);
 312     if (!mPtr->view) {
 313         free(mPtr);
 314         return NULL;
 315     }
 316     mPtr->view->self = mPtr;
 317
 318     WMAddNotificationObserver(realizeObserver, mPtr,
 319                               WMViewRealizedNotification, mPtr->view);
 320
 321     W_SetViewBackgroundColor(mPtr->view, mPtr->view->screen->darkGray);
 322
 323     mPtr->label = wstrdup(title);
 324
 325     mPtr->itemsAlloced = 10;
 326     mPtr->items = wmalloc(sizeof(WEditMenuItem*)*mPtr->itemsAlloced);
 327
 328     WMCreateEventHandler(mPtr->view, ExposureMask|StructureNotifyMask,
 329                          handleEvents, mPtr);
 330
 331     WMCreateEventHandler(mPtr->view, ButtonPressMask,handleActionEvents, mPtr);
 332
 333     updateMenuContents(mPtr);
 334
 335
 336     mPtr->itemHeight = WMFontHeight(scr->normalFont) + 6;
 337     mPtr->titleHeight = WMFontHeight(scr->boldFont) + 8;
 338
 339     mPtr->draggedItem = -1;
 340
 341     mPtr->next = EditMenuList;
 342     if (EditMenuList)
 343         EditMenuList->prev = mPtr;
 344     EditMenuList = mPtr;
 345
 346     return mPtr;
 347 }
 348
 349
 350 WEditMenuItem*
 351 WInsertMenuItemWithTitle(WEditMenu *mPtr, char *title, int index)
 352 {
 353     WEditMenuItem *item;
 354
 355     item = WCreateEditMenuItem(mPtr, title);
 356     item->menu = mPtr;
 357
 358     WMCreateEventHandler(item->view, ButtonPressMask|ButtonReleaseMask
 359                          |Button1MotionMask, handleItemDrag, item);
 360
 361     WMMapWidget(item);
 362
 363     if (index < 0)
 364         index = 0;
 365     else if (index > mPtr->itemCount)
 366         index = mPtr->itemCount;
 367
 368     if (mPtr->itemCount == mPtr->itemsAlloced) {
 369         WEditMenuItem **newList;
 370
 371         newList = wmalloc(sizeof(WEditMenuItem*)*(mPtr->itemsAlloced+10));
 372         memset(newList, 0, sizeof(WEditMenuItem*)*(mPtr->itemsAlloced+10));
 373
 374         memcpy(newList, mPtr->items, mPtr->itemsAlloced*sizeof(WEditMenuItem*));
 375
 376         mPtr->itemsAlloced += 10;
 377
 378         free(mPtr->items);
 379
 380         mPtr->items = newList;
 381     }
 382
 383     if (index < mPtr->itemCount) {
 384         memmove(&mPtr->items[index+1], &mPtr->items[index],
 385                 sizeof(WEditMenuItem*));
 386         mPtr->items[index] = item;
 387         mPtr->itemCount++;
 388     } else {
 389         mPtr->items[mPtr->itemCount++] = item;
 390     }
 391
 392     updateMenuContents(mPtr);
 393
 394     return item;
 395 }
 396
 397
 398 void
 399 WSetMenuSubmenu(WEditMenu *mPtr, WEditMenu *submenu, WEditMenuItem *item)
 400 {
 401     item->submenu = submenu;
 402     submenu->parent = mPtr;
 403
 404     paintEditMenuItem(item);
 405 }
 406
 407
 408 void
 409 WRemoveMenuItem(WEditMenu *mPtr, WEditMenuItem *item)
 410 {
 411
 412 }
 413
 414
 415 static void
 416 updateMenuContents(WEditMenu *mPtr)
 417 {
 418     WMScreen *scr = WMWidgetScreen(mPtr);
 419     int i;
 420     int newW, newH;
 421     int w;
 422     int iheight = mPtr->itemHeight;
 423
 424     newW = WMWidthOfString(scr->boldFont, mPtr->label,
 425                            strlen(mPtr->label)) + 12 + iheight;
 426
 427     newH = mPtr->titleHeight;
 428
 429     for (i = 0; i < mPtr->itemCount; i++) {
 430         w = WMWidthOfString(scr->normalFont, mPtr->items[i]->label,
 431                             strlen(mPtr->items[i]->label)) + 5;
 432         if (w > newW)
 433             newW = w;
 434
 435         W_MoveView(mPtr->items[i]->view, 0, newH);
 436         newH += iheight;
 437     }
 438
 439     newH--;
 440
 441     W_ResizeView(mPtr->view, newW, newH);
 442
 443     for (i = 0; i < mPtr->itemCount; i++) {
 444         W_ResizeView(mPtr->items[i]->view, newW, iheight);
 445     }
 446
 447     paintEditMenu(mPtr, -1);
 448 }
 449
 450
 451 static void
 452 paintMenuTitle(WEditMenu *mPtr)
 453 {
 454     WMScreen *scr = WMWidgetScreen(mPtr);
 455     WMColor *black = scr->black;
 456     WMColor *white = scr->white;
 457     Window win = W_VIEW(mPtr)->window;
 458     int w = W_VIEW(mPtr)->size.width;
 459     int h = mPtr->titleHeight;
 460
 461     XFillRectangle(scr->display, win, WMColorGC(black), 0, 0, w, h);
 462
 463     W_DrawRelief(scr, win, 0, 0, w+1, h, WRRaised);
 464
 465     WMDrawString(scr, win, WMColorGC(white), scr->boldFont, 5, 4, mPtr->label,
 466                  strlen(mPtr->label));
 467 }
 468
 469
 470 static void
 471 paintEditMenu(WEditMenu *mPtr, int y)
 472 {
 473     if (!mPtr->view->flags.realized)
 474         return;
 475
 476     if (y < mPtr->titleHeight || y < 0)
 477         paintMenuTitle(mPtr);
 478 }
 479
 480
 481
 482 static void
 483 handleEvents(XEvent *event, void *data)
 484 {
 485     WEditMenu *mPtr = (WEditMenu*)data;
 486
 487
 488     switch (event->type) {
 489      case Expose:
 490         paintEditMenu(mPtr, event->xexpose.y);
 491         break;
 492
 493      case DestroyNotify:
 494         destroyEditMenu(mPtr);
 495         break;
 496
 497     }
 498 }
 499
 500
 501
 502
 503 static void
 504 handleActionEvents(XEvent *event, void *data)
 505 {
 506     WEditMenu *mPtr = (WEditMenu*)data;
 507
 508     switch (event->type) {
 509      case ButtonPress:
 510         break;
 511     }
 512 }
 513
 514
 515 static void
 516 editItemLabel(WEditMenuItem *iPtr)
 517 {
 518     WMTextField *tPtr;
 519
 520     tPtr = WMCreateTextField(iPtr);
 521     WMResizeWidget(tPtr, iPtr->view->size.width - 20,
 522                    iPtr->view->size.height - 3);
 523     WMMoveWidget(tPtr, 4, 1);
 524     WMSetTextFieldBeveled(tPtr, False);
 525     WMMapWidget(tPtr);
 526
 527     WMRealizeWidget(tPtr);
 528
 529     iPtr->textField = tPtr;
 530 }
 531
 532
 533 static void
 534 handleItemDrag(XEvent *event, void *data)
 535 {
 536     WEditMenuItem *iPtr = (WEditMenuItem*)data;
 537     WEditMenu *mPtr = iPtr->menu;
 538     WMScreen *scr = WMWidgetScreen(mPtr);
 539     Bool done = False;
 540     int y;
 541     int i;
 542     int newIdx, oldIdx;
 543     int newY;
 544
 545     switch (event->type) {
 546      case ButtonPress:
 547         if (WMIsDoubleClick(event)) {
 548
 549             editItemLabel(iPtr);
 550
 551         } else if (event->xbutton.button == Button1) {
 552             mPtr->draggedItem = 1;
 553             mPtr->dragX = event->xbutton.x;
 554             mPtr->dragY = event->xbutton.y;
 555         }
 556         return;
 557      case ButtonRelease:
 558         if (event->xbutton.button == Button1) {
 559             mPtr->draggedItem = -1;
 560         }
 561         return;
 562      case MotionNotify:
 563         if (mPtr->draggedItem >= 0) {
 564             if (abs(event->xmotion.y - mPtr->dragY) > 3
 565                 || abs(event->xmotion.x - mPtr->dragX) > 3) {
 566                 mPtr->draggedItem = -1;
 567             } else {
 568                 return;
 569             }
 570         } else {
 571             return;
 572         }
 573         break;
 574      default:
 575         return;
 576     }
 577
 578     XRaiseWindow(scr->display, iPtr->view->window);
 579
 580     XGrabPointer(scr->display, mPtr->view->window, False,
 581                  PointerMotionMask|ButtonReleaseMask|ButtonPressMask
 582                  |ButtonPressMask,
 583                  GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
 584
 585     y = iPtr->view->pos.y;
 586
 587     while (!done) {
 588         XEvent ev;
 589
 590         WMMaskEvent(scr->display, ButtonReleaseMask|PointerMotionMask
 591                     |ExposureMask, &ev);
 592
 593         switch (ev.type) {
 594          case ButtonRelease:
 595             if (ev.xbutton.button == Button1)
 596                 done = True;
 597             break;
 598
 599          case MotionNotify:
 600             y = ev.xbutton.y - mPtr->dragY;
 601
 602             if (y < mPtr->titleHeight)
 603                 y = mPtr->titleHeight;
 604             else if (y > mPtr->view->size.height - mPtr->itemHeight + 1)
 605                 y = mPtr->view->size.height - mPtr->itemHeight + 1;
 606
 607             W_MoveView(iPtr->view, 0, y);
 608             break;
 609
 610          default:
 611             WMHandleEvent(&ev);
 612             break;
 613         }
 614     }
 615     XUngrabPointer(scr->display, CurrentTime);
 616
 617     for (oldIdx = 0; oldIdx < mPtr->itemCount; oldIdx++) {
 618         if (mPtr->items[oldIdx] == iPtr) {
 619             break;
 620         }
 621     }
 622     assert(oldIdx < mPtr->itemCount);
 623
 624     newIdx = (y - mPtr->titleHeight + mPtr->itemHeight/2) / mPtr->itemHeight;
 625
 626     if (newIdx < 0)
 627         newIdx = 0;
 628     else if (newIdx >= mPtr->itemCount)
 629         newIdx = mPtr->itemCount - 1;
 630
 631     newY = mPtr->titleHeight + newIdx * mPtr->itemHeight;
 632     for (i = 0; i <= 15; i++) {
 633         W_MoveView(iPtr->view, 0, ((newY*i)/15 + (y - (y*i)/15)));
 634         XFlush(scr->display);
 635     }
 636
 637     if (oldIdx != newIdx) {
 638         WEditMenuItem *item;
 639
 640         item = mPtr->items[oldIdx];
 641         mPtr->items[oldIdx] = mPtr->items[newIdx];
 642         mPtr->items[newIdx] = item;
 643
 644         updateMenuContents(mPtr);
 645     }
 646 }
 647
 648
 649 static void
 650 destroyEditMenu(WEditMenu *mPtr)
 651 {
 652     WMRemoveNotificationObserver(mPtr);
 653
 654     if (mPtr->next)
 655         mPtr->next->prev = mPtr->prev;
 656     if (mPtr->prev)
 657         mPtr->prev->next = mPtr->next;
 658     if (EditMenuList == mPtr)
 659         EditMenuList = mPtr->next;
 660
 661     if (mPtr->label)
 662         free(mPtr->label);
 663
 664     if (mPtr->items)
 665         free(mPtr->items);
 666
 667     free(mPtr);
 668 }
 669 #endif