← Back to branch summary

~profzoom/ubuntu/quantal/wmaker/bug-1079925

« back to all changes in this revision

Viewing changes to WPrefs.app/editmenu.c

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo E. Magallon
  • Date: 2004-11-10 14:05:30 UTC
  • Revision ID: james.westby@ubuntu.com-20041110140530-qpd66b5lm38x7apk
Tags: upstream-0.91.0
Import upstream version 0.91.0

Show diffs side-by-side

added added

removed removed

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