← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/tcm/intrepid

« back to all changes in this revision

Viewing changes to src/dg/diagramwindow.c

  • Committer: Bazaar Package Importer
  • Author(s): Otavio Salvador
  • Date: 2003-07-03 20:08:21 UTC
  • Revision ID: james.westby@ubuntu.com-20030703200821-se4xtqx25e5miczi
Tags: upstream-2.20
Import upstream version 2.20

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dg/diagramwindow.c
 
1
////////////////////////////////////////////////////////////////////////////////
 
2
//
 
3
// This file is part of Toolkit for Conceptual Modeling (TCM).
 
4
// (c) copyright 1995, Vrije Universiteit Amsterdam.
 
5
// Author: Frank Dehne (frank@cs.vu.nl).
 
6
//
 
7
// TCM 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
// TCM 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 TCM; if not, write to the Free Software
 
19
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
20
// 02111-1307, USA.
 
21
////////////////////////////////////////////////////////////////////////////////
 
22
#include "diagramwindow.h"
 
23
#include "assoclist.h"
 
24
#include "textalign.h"
 
25
#include "printer.h"
 
26
#include "diagram.h"
 
27
#include "diagramviewer.h"
 
28
#include "diagramstubs.h"
 
29
#include "xgrafport.h"
 
30
#include "liteclue.h"
 
31
#include "graph.h"
 
32
#include "menu.h"
 
33
#include "config.h"
 
34
#include "mstring.h"
 
35
#include <ctype.h>
 
36
#include <stdlib.h>
 
37
#include <math.h>
 
38
#include <Xm/XmAll.h>
 
39
#include "Curve.xbm"
 
40
#include "LineStyleSolid.xbm"
 
41
#include "LineStyleDashed.xbm"
 
42
#include "LineStyleDotted.xbm"
 
43
const Bitmap DiagramWindow::CURVE_ICON = 
 
44
        {Curve_width, Curve_height, Curve_bits};
 
45
const Bitmap DiagramWindow::SOLID_LINE_ICON = 
 
46
        {LineStyleSolid_width, LineStyleSolid_height, LineStyleSolid_bits};
 
47
const Bitmap DiagramWindow::DASHED_LINE_ICON = 
 
48
        {LineStyleDashed_width, LineStyleDashed_height, LineStyleDashed_bits};
 
49
const Bitmap DiagramWindow::DOTTED_LINE_ICON = 
 
50
        {LineStyleDotted_width, LineStyleDotted_height, LineStyleDotted_bits};
 
51
 
 
52
DiagramWindow::DiagramWindow(const char *n): DrawWindow(n) {
 
53
        nodeLineStyleItems = 0;
 
54
        edgeLineStyleItems = 0;
 
55
        showLineStyleOptionMenu = False;
 
56
        diagramAlignItems = 0;
 
57
        defPropertiesItems = 0;
 
58
        gridItems = 0;
 
59
        updateNodeShapeTypeItems = 0;
 
60
        iconColumns = 2;
 
61
}
 
62
 
 
63
DiagramWindow::~DiagramWindow() {
 
64
        if (defPropertiesItems)
 
65
                delete defPropertiesItems;
 
66
        if (diagramAlignItems)
 
67
                delete diagramAlignItems;
 
68
        if (gridItems)
 
69
                delete gridItems;
 
70
        if (nodeLineStyleItems)
 
71
                delete nodeLineStyleItems;
 
72
        if (edgeLineStyleItems)
 
73
                delete edgeLineStyleItems;
 
74
        if (updateNodeShapeTypeItems)
 
75
                delete updateNodeShapeTypeItems;
 
76
}
 
77
 
 
78
void DiagramWindow::WriteUsage(const char *prog) {
 
79
        DrawWindow::WriteUsage(prog);
 
80
}
 
81
 
 
82
void DiagramWindow::ParseUserOptions(int argc, char **argv) {
 
83
        DrawWindow::ParseUserOptions(argc, argv);
 
84
        if (GetArgsLeft() == 1) {
 
85
                // for loading existing file or opening a new file
 
86
                const char* file = argv[argc-1];
 
87
                if (file[0] != '-') {
 
88
                        SetDoLoad(True);
 
89
                        SetLoadFile(file);
 
90
                }
 
91
                else {
 
92
                        WriteUsage(argv[0]);
 
93
                        exit(1);
 
94
                }
 
95
        }
 
96
        else if (GetArgsLeft() != 0) {
 
97
                WriteUsage(argv[0]);
 
98
                exit(1);
 
99
        }
 
100
}
 
101
 
 
102
void DiagramWindow::CreateDocument() {
 
103
        // create new diagram, viewer and graph object (tool specific)
 
104
        DetermineIcons();
 
105
        Graph *graph = CreateGraph();
 
106
        viewer = CreateViewer(GetConfig());
 
107
        Diagram *d = CreateDiagram(GetConfig(), viewer, graph);
 
108
        viewer->SetDiagram(d);
 
109
        SetDocument(d);
 
110
        graph->InitConnections();
 
111
}
 
112
 
 
113
void DiagramWindow::Finalize() {
 
114
        CreateDrawingArea();
 
115
        viewer->SetPrinter(GetPrinter());
 
116
        GetPrinter()->SetViewer(viewer);
 
117
        GetDrawingArea()->SetViewer(viewer);    
 
118
        viewer->SetGrafport(GetDrawingArea()->GetGrafport());
 
119
        GetDocument()->Initialize();
 
120
        viewer->Redraw();
 
121
        DrawWindow::Finalize();
 
122
}
 
123
 
 
124
void DiagramWindow::CreateComponents(Widget parent) {
 
125
        if (!check(parent))
 
126
                return;
 
127
        SetLogo(CreateLogo(parent));
 
128
        SetArrowButtons(CreateArrowButtonSquare(parent));
 
129
        SetMenuBar(CreateMenuBar(parent));
 
130
        SetDocumentArea(CreateDocumentArea(parent));
 
131
        tiles = CreateTiles(parent);
 
132
        SetControlArea(CreateControlArea(parent));
 
133
        SetStatusArea(CreateStatusArea(parent));
 
134
        SetScrolledWindow(CreateScrolledWindow(parent));
 
135
        SetScaleValue(CreateScaleValue(parent));
 
136
        XtVaSetValues(GetStatusArea(),
 
137
                XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 
138
                XmNleftWidget, GetScrolledWindow(), 0);
 
139
        XtVaSetValues(GetScrolledWindow(),
 
140
                XmNleftAttachment, XmATTACH_WIDGET,
 
141
                XmNleftWidget, tiles,
 
142
                XmNbottomAttachment, XmATTACH_WIDGET,
 
143
                XmNbottomWidget, GetArrowButtons(), 0);
 
144
        // XtVaSetValues(tiles,
 
145
        //      XmNbottomAttachment, XmATTACH_WIDGET,
 
146
        //      XmNbottomWidget, GetArrowButtons(), 0);
 
147
}
 
148
 
 
149
Widget DiagramWindow::CreateTiles(Widget parent) {
 
150
        // the tile widget is a rowcolumn consisting of two
 
151
        // rowcolumns of radio-buttons (which are to be labeled
 
152
        // with drawn buttons): one for nodes and one for edges 
 
153
        // (the last including a toggle for curved or straight edges)
 
154
        Widget t = XtVaCreateWidget("Tiles",
 
155
                xmRowColumnWidgetClass, parent,
 
156
                XmNtopAttachment, XmATTACH_WIDGET,
 
157
                XmNtopWidget, GetDocumentArea(),
 
158
                XmNleftAttachment, XmATTACH_FORM,
 
159
                XmNadjustLast, True,
 
160
                0);
 
161
        CalcIconColumns();
 
162
        CreateNodeIcons(t);
 
163
        CreateEdgeIcons(t);
 
164
        XtManageChild(t);
 
165
        if (ShowIndexToggle())
 
166
                CreateIndexToggle(GetNodeIconsRC());
 
167
        if (showLineStyleOptionMenu) {
 
168
                CreateLineStyleOptionMenu(nodeIconsRC, True, iconColumns>2);
 
169
                XtManageChild(nodeIconsRC);
 
170
                CreateLineStyleOptionMenu(edgeIconsRC, False, iconColumns>2);
 
171
                XtManageChild(edgeIconsRC);
 
172
        }
 
173
        XtManageChild(t);
 
174
        return t;
 
175
}
 
176
 
 
177
 
 
178
void DiagramWindow::CalcIconColumns() {
 
179
        int icons = nrNodes + nrEdges;
 
180
        if (showLineStyleOptionMenu)
 
181
                icons += 4;
 
182
        if (ShowIndexToggle())
 
183
                icons += 2;
 
184
        if ((GetScreenType() <= VGA) || 
 
185
            (GetScreenType() <= SVGA && icons > 7) ||
 
186
            (GetScreenType() <= XVGA && icons > 10) || 
 
187
            (icons >= 13))
 
188
                iconColumns = 2;
 
189
        if ((GetScreenType() > XVGA && icons < 7))
 
190
                iconColumns = 1;
 
191
        if (icons >= 20 || (GetScreenType() <= XVGA && icons > 18) ||
 
192
                (GetScreenType() <= SVGA && icons > 15))
 
193
                iconColumns = 3;
 
194
}
 
195
 
 
196
void DiagramWindow::CreateNodeIcons(Widget t) {
 
197
        Arg args[9];
 
198
        int i = 0;
 
199
        Widget pb;
 
200
        Widget scrolledWin = 0;
 
201
        Pixmap pixmap;
 
202
        // create a frame: for nodes
 
203
        Widget frame = XtVaCreateWidget("TilesFrame1",
 
204
                xmFrameWidgetClass, t,
 
205
                XmNshadowType, XmSHADOW_ETCHED_IN, 0);
 
206
 
 
207
        // create a rowcolumn for nodes
 
208
        nodeIconsRC = XtVaCreateWidget("NodeIconsRC", xmRowColumnWidgetClass, 
 
209
                frame, XmNentryAlignment, 
 
210
                XmALIGNMENT_CENTER, 0);
 
211
 
 
212
        // make scrollbars when there are many icons.
 
213
        if (iconColumns > 2) {
 
214
                scrolledWin = XtVaCreateManagedWidget("ScrolledWindow",
 
215
                        xmScrolledWindowWidgetClass, nodeIconsRC,
 
216
                        XmNborderWidth, 0,
 
217
                        XmNshadowThickness, 0,
 
218
                        XmNspacing, 0,
 
219
                        XmNwidth, iconColumns*68, 
 
220
                        XmNheight, 
 
221
                                GetIconsScrollHeight((nrNodes-1)/iconColumns + 1),
 
222
                        XmNscrollingPolicy, XmAUTOMATIC,
 
223
                        XmNscrollBarDisplayPolicy, XmAS_NEEDED, 0);
 
224
 
 
225
                Widget clipWindow;
 
226
                XtVaGetValues(scrolledWin, XmNclipWindow, &clipWindow, 0);
 
227
                XtVaSetValues(clipWindow, XmNborderWidth, 0, 0);
 
228
        }
 
229
 
 
230
        XtVaCreateManagedWidget("nodes",
 
231
                        xmLabelWidgetClass, frame,
 
232
                        XmNchildType, XmFRAME_TITLE_CHILD, 0);
 
233
        XtSetArg(args[i], XmNradioAlwaysOne, True); i++;
 
234
        XtSetArg(args[i], XmNnumColumns, iconColumns); i++;
 
235
        XtSetArg(args[i], XmNadjustLast, False); i++;
 
236
 
 
237
        // create a radiobox for the nodes
 
238
        char wname[8] = "Nodes";
 
239
        Widget rb = XmCreateRadioBox(
 
240
                        scrolledWin?scrolledWin:nodeIconsRC, 
 
241
                        wname, args, i);
 
242
        // create all node buttons and their pixmaps in a loop
 
243
        for (i=0; i < nrNodes; i++) {
 
244
                pb = XtVaCreateWidget(nodeNames[i],
 
245
                        xmToggleButtonWidgetClass, rb,
 
246
                           // the first button is set by default
 
247
                        XmNset, i == 0? True: False, 
 
248
                        XmNhighlightThickness, 0,
 
249
                        XmNalignment, XmALIGNMENT_CENTER, 0);
 
250
                pixmap = nodeIcons[i].CreatePixmap(pb, GetDisplay());
 
251
                XtVaSetValues(pb,
 
252
                        XmNlabelType, XmPIXMAP,
 
253
                        XmNlabelPixmap, pixmap, 
 
254
                        XmNuserData, (XtPointer)(i+1),
 
255
                                        // determines widget for which the
 
256
                                        // callback is involved.
 
257
                        0);
 
258
                XtAddCallback(pb, XmNvalueChangedCallback, 
 
259
                        DiagramStubs::SetNodeCB, (XtPointer)GetDocument());
 
260
                AddLiteClue(pb, (char *)nodeNames[i]);
 
261
                XtManageChild(pb);
 
262
        }
 
263
        XtManageChild(rb);
 
264
        XtManageChild(nodeIconsRC);
 
265
        if (scrolledWin)
 
266
                XtManageChild(scrolledWin);
 
267
        XtManageChild(frame);
 
268
}
 
269
 
 
270
void DiagramWindow::CreateEdgeIcons(Widget t) {
 
271
        Arg args[9];
 
272
        int i = 0;
 
273
        Widget pb;
 
274
        Pixmap pixmap;
 
275
        // create a frame: for edges
 
276
        Widget frame = XtVaCreateWidget("TilesFrame2",
 
277
                xmFrameWidgetClass, t,
 
278
                XmNshadowType, XmSHADOW_ETCHED_IN, 0);
 
279
        // create a rowcolumn of edges
 
280
        edgeIconsRC = XtVaCreateWidget("EdgeIconsRC", xmRowColumnWidgetClass, 
 
281
                frame, XmNentryAlignment, XmALIGNMENT_CENTER,
 
282
                0);
 
283
        // create a label for edges
 
284
        XtVaCreateManagedWidget("edges",
 
285
                        xmLabelWidgetClass, frame,
 
286
                        XmNchildType, XmFRAME_TITLE_CHILD, 0);
 
287
        
 
288
        XtSetArg(args[i], XmNradioAlwaysOne, True); i++;
 
289
        XtSetArg(args[i], XmNnumColumns, iconColumns); i++;
 
290
        XtSetArg(args[i], XmNadjustLast, False); i++;
 
291
 
 
292
        // create a radiobox for the edges
 
293
        char wname[8] = "Edges";
 
294
        Widget rb = XmCreateRadioBox(edgeIconsRC, wname, args, i);
 
295
        // realize them in a loop ...
 
296
        for (i=0; i < nrEdges; i++) {
 
297
                pb = XtVaCreateWidget(edgeNames[i],
 
298
                        xmToggleButtonWidgetClass, rb,
 
299
                        XmNset, i == 0? True: False,
 
300
                        XmNhighlightThickness, 0,
 
301
                        XmNalignment, XmALIGNMENT_CENTER, 0);
 
302
                pixmap = edgeIcons[i].CreatePixmap(pb, GetDisplay());
 
303
                XtVaSetValues(pb,
 
304
                        XmNlabelType, XmPIXMAP,
 
305
                        XmNlabelPixmap, pixmap, 
 
306
                        XmNuserData, (XtPointer)(i+1),
 
307
                        0);
 
308
                XtAddCallback(pb, XmNvalueChangedCallback, 
 
309
                        DiagramStubs::SetEdgeCB, (XtPointer)GetDocument());
 
310
                AddLiteClue(pb, (char *)edgeNames[i]);
 
311
                XtManageChild(pb);
 
312
        }
 
313
        XtManageChild(rb);
 
314
        if (!Toolkit::EditorWithoutCurves(GetTool())) {
 
315
                i=0;
 
316
                strcpy(wname, "rb3");
 
317
                rb = XmCreateSimpleCheckBox(edgeIconsRC, wname, args, i);
 
318
                // create a button for the curve toggle
 
319
                pb = XtVaCreateWidget("create curve", xmToggleButtonWidgetClass, rb,
 
320
                        XmNhighlightThickness, 0,
 
321
                        XmNalignment, XmALIGNMENT_CENTER, 0);
 
322
                XtAddCallback(pb, XmNvalueChangedCallback, 
 
323
                        DiagramStubs::SetCurveCB, (XtPointer)GetDocument());
 
324
                AddLiteClue(pb, "When on, curved edges are created");
 
325
                XtManageChild(pb);
 
326
                XtManageChild(rb);
 
327
        }
 
328
        XtManageChild(edgeIconsRC);
 
329
        XtManageChild(frame);
 
330
}
 
331
 
 
332
 
 
333
void DiagramWindow::CreateLineStyleOptionMenu(Widget w, bool nodes, 
 
334
                                                bool minimize) {
 
335
        Widget frame1 = XtVaCreateManagedWidget("LineStyleFrame",
 
336
                        xmFrameWidgetClass, w, 0);
 
337
        Menu *menu;
 
338
        string label;
 
339
 
 
340
        if (nodes) {
 
341
                if (minimize) {
 
342
                        menu = new Menu(frame1, Menu::OPTION, 
 
343
                                        "line style", 0, nodeLineStyleItems);
 
344
                }
 
345
                else {
 
346
                        menu = new Menu(frame1, Menu::OPTION, 
 
347
                                        "NodeLineStyleMenu", 0, nodeLineStyleItems);
 
348
                        label = "line style";
 
349
                        XtVaCreateManagedWidget(label.getstr(),
 
350
                                xmLabelWidgetClass, frame1,
 
351
                                XmNchildType, XmFRAME_TITLE_CHILD, 0);
 
352
                }
 
353
        }
 
354
        else {  // edges
 
355
                if (minimize) {
 
356
                        menu = new Menu(frame1, Menu::OPTION, 
 
357
                                        "line style", 0, edgeLineStyleItems);
 
358
                }
 
359
                else {
 
360
                        menu = new Menu(frame1, Menu::OPTION, 
 
361
                                        "EdgeLineStyleMenu", 0, edgeLineStyleItems);
 
362
                        label = "line style";
 
363
                        XtVaCreateManagedWidget(label.getstr(),
 
364
                                xmLabelWidgetClass, frame1,
 
365
                                XmNchildType, XmFRAME_TITLE_CHILD, 0);
 
366
                }
 
367
        }
 
368
        XtManageChild(menu->GetWidget());
 
369
        XtManageChild(w);
 
370
}
 
371
 
 
372
Widget DiagramWindow::CreateMenuBar(Widget parent) {
 
373
        // create the main menubar at the top of the parent
 
374
        Arg  args[9];
 
375
        int i = 0;
 
376
        XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM); i++;
 
377
        XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM); i++;
 
378
        if (GetLogo()) {
 
379
                XtSetArg(args[i], XmNrightAttachment, XmATTACH_WIDGET); i++;
 
380
                XtSetArg(args[i], XmNrightWidget, GetLogo()); i++;
 
381
        }
 
382
        else {
 
383
                XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM); i++;
 
384
        }
 
385
        InitMenuItems();
 
386
        // create a menubar that contains the following menus:
 
387
        char wname[10] = "MenuBar";
 
388
        Widget bar = XmCreateMenuBar(parent, wname, args, i);
 
389
        fileMenu = new Menu(bar, Menu::PULLDOWN, "File", 0, fileItems);
 
390
        editMenu = new Menu(bar, Menu::PULLDOWN, "Edit", 0, editItems);
 
391
        viewMenu = BuildViewMenu(bar);
 
392
        printMenu = new Menu(bar, Menu::PULLDOWN, "Print", 0, printItems);
 
393
        scaleMenu = new Menu(bar, Menu::PULLDOWN, "Scale", 0, scaleItems);
 
394
        pageMenu = new Menu(bar, Menu::PULLDOWN, "Page", 0, pageItems);
 
395
        propertiesMenu = new Menu(bar, Menu::PULLDOWN, "Properties", 0, 
 
396
                propertiesItems);
 
397
        searchMenu = new Menu(bar, Menu::PULLDOWN, "Search", 0, searchItems);
 
398
        documentMenu = new Menu(bar, Menu::PULLDOWN, "Document", 0, 
 
399
                documentItems);
 
400
        helpMenu = new Menu(bar, Menu::PULLDOWN, "Help", 0, helpItems);
 
401
        // tell bar which bar which button is the help menu
 
402
        XtVaSetValues(bar, XmNmenuHelpWidget, helpMenu->GetWidget(), 0);
 
403
        // Bar is done -- manage it
 
404
        XtManageChild(bar);
 
405
        return bar;
 
406
}
 
407
 
 
408
Menu *DiagramWindow::BuildViewMenu(Widget parent) {
 
409
        return new Menu(parent, Menu::PULLDOWN, "View", 0, viewItems);
 
410
}
 
411
 
 
412
void DiagramWindow::GetNodeName(int i, string *n) {
 
413
        if (i >= 0 && i < nrNodes)
 
414
                *n = nodeNames[i];
 
415
        else
 
416
                *n = "";
 
417
}
 
418
 
 
419
void DiagramWindow::GetEdgeName(int i, string *n) {
 
420
        if (i >= 0 && i < nrEdges)
 
421
                *n = edgeNames[i];
 
422
        else
 
423
                *n = "";
 
424
}
 
425
 
 
426
void DiagramWindow::SetNodeName(int n) {
 
427
        string status; 
 
428
        GetNodeName(n-1, &status);
 
429
        status += ": on";
 
430
        SetStatus(&status);
 
431
}
 
432
 
 
433
void DiagramWindow::SetEdgeName(int n) {
 
434
        string status;
 
435
        GetEdgeName(n-1, &status);
 
436
        status += ": on";
 
437
        SetStatus(&status);
 
438
}
 
439
 
 
440
void DiagramWindow::InitMenuItems() {
 
441
        int i;
 
442
        DrawWindow::InitMenuItems();
 
443
 
 
444
        diagramAlignItems = new MenuItem[10]; i=0;
 
445
        diagramAlignItems[i] = MenuItem(
 
446
                 "Align Top", MenuItem::PUSHBUTTON, 'T', 0, 0, 
 
447
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 
 
448
                (XtPointer)NodeAlign::TOP, 0, 1); i++;
 
449
        diagramAlignItems[i] = MenuItem(
 
450
                 "Align Bottom", MenuItem::PUSHBUTTON, 'B', 0, 0, 
 
451
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 
 
452
                (XtPointer)NodeAlign::BOTTOM, 0, 1); i++;
 
453
        diagramAlignItems[i] = MenuItem(
 
454
                 "Align Left", MenuItem::PUSHBUTTON, 'L', 0, 0, 
 
455
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 
 
456
                (XtPointer)NodeAlign::LEFT, 0, 1); i++;
 
457
        diagramAlignItems[i] = MenuItem(
 
458
                 "Align Right", MenuItem::PUSHBUTTON, 'R', 0, 0, 
 
459
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 
 
460
                (XtPointer)NodeAlign::RIGHT, 0, 1); i++;
 
461
        diagramAlignItems[i] = MenuItem(
 
462
                 "Align Horizontal", MenuItem::PUSHBUTTON, 'H', 0, 0, 
 
463
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 
 
464
                (XtPointer)NodeAlign::HORIZONTAL, 0, 1); i++;
 
465
        diagramAlignItems[i] = MenuItem(
 
466
                 "Align Vertical", MenuItem::PUSHBUTTON, 'V', 0, 0, 
 
467
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer,
 
468
                (XtPointer)NodeAlign::VERTICAL, 0, 1); i++;
 
469
        diagramAlignItems[i] = MenuItem::NUL;
 
470
        
 
471
        popupEditItems = new MenuItem[28]; i=0;
 
472
        popupEditItems[i] = MenuItem(
 
473
                 "Edit Commands", MenuItem::LABEL, 0, 0, 0, 
 
474
                0, 0, 0, 0, 1); i++;
 
475
        popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
476
        popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
477
        popupEditItems[i] = MenuItem(
 
478
                "Undo", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>U", "Ctrl+U", 
 
479
                DiagramStubs::UndoCB, (XtPointer)viewer, 
 
480
                (XtPointer)1, 0, 0); i++;
 
481
        popupEditItems[i] = MenuItem(
 
482
                "Redo", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>R", "Ctrl+R", 
 
483
                DiagramStubs::RedoCB, (XtPointer)viewer, 
 
484
                (XtPointer)1, 0, 0); i++;
 
485
        popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
486
        popupEditItems[i] = MenuItem(
 
487
                 "Cut", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>X", "Ctrl+X",
 
488
                DiagramStubs::CutCB, (XtPointer)viewer, 0, 0, 1); i++;
 
489
        popupEditItems[i] = MenuItem(
 
490
                 "Copy", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>C", "Ctrl+C",
 
491
                DiagramStubs::CopyCB, (XtPointer)viewer, 0, 0, 1); i++;
 
492
        popupEditItems[i] = MenuItem(
 
493
                 "Paste", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>Y", "Ctrl+Y",
 
494
                DiagramStubs::PasteCB, (XtPointer)viewer, 0, 0, 1); i++;
 
495
        if ( ! Toolkit::EditorWithoutDuplicates(GetTool()) ) {
 
496
                popupEditItems[i] = MenuItem(
 
497
                        "Duplicate", MenuItem::PUSHBUTTON, '\0', 0, 0, 
 
498
                        DiagramStubs::DuplicateCB, (XtPointer)viewer, 0, 0, 1);
 
499
                        i++;
 
500
        }
 
501
        popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
502
        popupEditItems[i] = MenuItem(
 
503
                 "Delete", MenuItem::PUSHBUTTON, '\0', "Ctrl<Key>D", "Ctrl+D", 
 
504
                DiagramStubs::DeleteCB, (XtPointer)viewer, 0, 0, 1); i++;
 
505
        popupEditItems[i] = MenuItem(
 
506
                 "Delete All", MenuItem::PUSHBUTTON, '\0', 0, 0, 
 
507
                DiagramStubs::DeleteAllCB, (XtPointer)viewer, 0, 0, 1); i++;
 
508
        popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
509
        popupEditItems[i] = MenuItem(
 
510
                 "Select All", MenuItem::PUSHBUTTON, '\0', 0, 0, 
 
511
                DiagramStubs::SelectAllCB, (XtPointer)viewer, 0, 0, 1); i++;
 
512
        popupEditItems[i] = MenuItem(
 
513
                 "Same Size", MenuItem::PUSHBUTTON, '\0', 0, 0, 
 
514
                DiagramStubs::SameSizeCB, (XtPointer)viewer, 0, 0, 1); i++;
 
515
        popupEditItems[i] = MenuItem(
 
516
                 "Align Nodes...", MenuItem::PUSHBUTTON, '\0', 0, 0, 
 
517
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 0, 0, 1); i++;
 
518
        if (ShowIndexToggle()) {
 
519
                popupEditItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
520
                popupEditItems[i] = MenuItem(
 
521
                 "Renumber Indexes", MenuItem::PUSHBUTTON, '\0', 0, 0,
 
522
                 DiagramStubs::ReindexCB, 
 
523
                (XtPointer)GetDocument(), 0, 0, 1); i++;
 
524
        }
 
525
        if (!Toolkit::EditorWithoutCurves(GetTool())) {
 
526
                popupEditItems[i] = MenuItem(
 
527
                        "Convert From/To Curves", MenuItem::PUSHBUTTON, '\0', 0, 0,
 
528
                        DiagramStubs::UpdateCurveCB, (XtPointer)viewer, 0, 0, 1); i++;
 
529
        }
 
530
        popupEditItems[i] = MenuItem::NUL;
 
531
 
 
532
        editItems = new MenuItem[28]; i=0;
 
533
        editItems[i] = MenuItem(
 
534
                "Undo", MenuItem::PUSHBUTTON, 'U', "Ctrl<Key>U", "Ctrl+U", 
 
535
                DiagramStubs::UndoCB, (XtPointer)viewer, 
 
536
                (XtPointer)0, 0, 0); i++;
 
537
        editItems[i] = MenuItem(
 
538
                "Redo", MenuItem::PUSHBUTTON, 'R', "Ctrl<Key>R", "Ctrl+R", 
 
539
                DiagramStubs::RedoCB, (XtPointer)viewer, 
 
540
                (XtPointer)0, 0, 0); i++;
 
541
        editItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
542
        editItems[i] = MenuItem(
 
543
                "Cut", MenuItem::PUSHBUTTON, 'C', "Ctrl<Key>X", "Ctrl+X", 
 
544
                DiagramStubs::CutCB, (XtPointer)viewer, 0, 0, 1); i++;
 
545
        editItems[i] = MenuItem(
 
546
                "Copy", MenuItem::PUSHBUTTON, 'o', "Ctrl<Key>C", "Ctrl+C", 
 
547
                DiagramStubs::CopyCB, (XtPointer)viewer, 0, 0, 1); i++;
 
548
        editItems[i] = MenuItem(
 
549
                 "Paste", MenuItem::PUSHBUTTON, 'P', "Ctrl<Key>Y", "Ctrl+Y", 
 
550
                DiagramStubs::PasteCB, (XtPointer)viewer, 0, 0, 1); i++;
 
551
        if ( ! Toolkit::EditorWithoutDuplicates(GetTool()) ) {
 
552
                editItems[i] = MenuItem(
 
553
                        "Duplicate", MenuItem::PUSHBUTTON, 'l', 0, 0,
 
554
                        DiagramStubs::DuplicateCB, (XtPointer)viewer, 0, 0, 1);
 
555
                i++;
 
556
        }
 
557
        editItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
558
        editItems[i] = MenuItem(
 
559
                 "Delete", MenuItem::PUSHBUTTON, 'D', "Ctrl<Key>D", "Ctrl+D", 
 
560
                DiagramStubs::DeleteCB, (XtPointer)viewer, 0, 0, 1); i++;
 
561
        editItems[i] = MenuItem(
 
562
                 "Delete All", MenuItem::PUSHBUTTON, 'e', 0, 0, 
 
563
                DiagramStubs::DeleteAllCB, (XtPointer)viewer, 0, 0, 1); i++;
 
564
        editItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
565
        editItems[i] = MenuItem(
 
566
                 "Select All", MenuItem::PUSHBUTTON, 'S', 0, 0, 
 
567
                DiagramStubs::SelectAllCB, (XtPointer)viewer, 0, 0, 1); i++;
 
568
        editItems[i] = MenuItem(
 
569
                 "Same Size", MenuItem::PUSHBUTTON, 'm', 0, 0, 
 
570
                DiagramStubs::SameSizeCB, (XtPointer)viewer, 0, 0, 1); i++;
 
571
        editItems[i] = MenuItem(
 
572
                 "Align Nodes...", MenuItem::PUSHBUTTON, 'A', 0, 0,
 
573
                DiagramStubs::AlignNodeShapesCB, (XtPointer)viewer, 0, 0, 1); i++;
 
574
        if (ShowIndexToggle()) {
 
575
                editItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
576
                editItems[i] = MenuItem("Renumber Indexes", 
 
577
                MenuItem::PUSHBUTTON, 'i', 0, 0, DiagramStubs::ReindexCB, 
 
578
                (XtPointer)GetDocument(), 0, 0, 1); i++;
 
579
        }
 
580
        if (!Toolkit::EditorWithoutCurves(GetTool())) {
 
581
                editItems[i] = MenuItem(
 
582
                        "Convert From/To Curves", MenuItem::PUSHBUTTON, 'o', 0, 0,
 
583
                        DiagramStubs::UpdateCurveCB, (XtPointer)viewer, 0, 0, 1); i++;
 
584
        }
 
585
        editItems[i] = MenuItem::NUL;
 
586
 
 
587
        gridItems = new MenuItem[10]; i=0;
 
588
        gridItems[i] = MenuItem(
 
589
                "Show Grid", MenuItem::CHECKBUTTON, 'S', 0, 0, 
 
590
                DiagramStubs::ShowGridCB, (XtPointer)viewer->GetGrid(), 
 
591
                (XtPointer)(GetConfig()->GetShowGrid()), 0, 1); i++;
 
592
        gridItems[i] = MenuItem(
 
593
                "Grid Size ...", MenuItem::PUSHBUTTON, 'G', 0, 0, 
 
594
                DiagramStubs::GridSizeCB, 
 
595
                (XtPointer)viewer->GetGrid(), 0, 0, 1); i++;
 
596
        gridItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
597
        gridItems[i] = MenuItem(
 
598
                "Point Snapping", MenuItem::CHECKBUTTON, 'P', 0, 0, 
 
599
                DiagramStubs::PointSnappingCB, (XtPointer)viewer->GetGrid(), 
 
600
                (XtPointer)(GetConfig()->GetPointSnapping()), 0, 1); i++;
 
601
        gridItems[i] = MenuItem(
 
602
                "Point Distance ...", MenuItem::PUSHBUTTON, 'D', 0, 0, 
 
603
                DiagramStubs::PointDistanceCB, 
 
604
                (XtPointer)viewer->GetGrid(), 0, 0, 1); i++;
 
605
        gridItems[i] = MenuItem::NUL;
 
606
 
 
607
        viewItems = new MenuItem[28]; i=0;
 
608
        viewItems[i] = MenuItem(
 
609
                "Refresh", MenuItem::PUSHBUTTON, 'R', "Ctrl<Key>V", "Ctrl+V", 
 
610
                DiagramStubs::RefreshCB, (XtPointer)viewer, 0, 0, 1); i++;
 
611
        viewItems[i] = MenuItem(
 
612
                 "Grid", MenuItem::SUBMENU, 'G', 0, 0, 0, 
 
613
                0, 0, gridItems, 1); i++;
 
614
        if (Toolkit::HierarchicEditor(GetTool())) {
 
615
                /* These commands are insensitive by now. When they are
 
616
                   eventually made sensitive, ensure that they become
 
617
                   insensitive for non-hierarchic documents again. */
 
618
                viewItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
619
                viewItems[i] = MenuItem(
 
620
                        "Zoom In", MenuItem::PUSHBUTTON, 'I', 
 
621
                        "Ctrl<Key>I", "Ctrl+I", 
 
622
                        DiagramStubs::ZoomInCB, 
 
623
                        (XtPointer)viewer, 0, 0, 0); i++;
 
624
                viewItems[i] = MenuItem(
 
625
                        "Zoom Out", MenuItem::PUSHBUTTON, 'O', 
 
626
                        "Ctrl<Key>O", "Ctrl+O", 
 
627
                        DiagramStubs::ZoomOutCB, (XtPointer)viewer, 
 
628
                        0, 0, 0); i++;
 
629
                viewItems[i] = MenuItem(
 
630
                        "Top Level", MenuItem::PUSHBUTTON, 'T', 
 
631
                        "Ctrl<Key>T", "Ctrl+T", 
 
632
                        DiagramStubs::TopLevelCB, 
 
633
                        (XtPointer)viewer, 0, 0, 0); i++;
 
634
        }
 
635
        viewItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
636
        viewItems[i] = MenuItem(
 
637
                "Autoresizing", MenuItem::CHECKBUTTON, 'A', 0, 0, 
 
638
                DiagramStubs::SetAutoResizeCB, (XtPointer)viewer, 
 
639
                (XtPointer)(GetConfig()->GetAutoResizing()), 0, 1); i++;
 
640
        viewItems[i] = MenuItem(
 
641
                "In-line Editor", MenuItem::CHECKBUTTON, 'I', 0, 0, 
 
642
                DiagramStubs::SetInlineEditCB, (XtPointer)viewer, 
 
643
                (XtPointer)(GetConfig()->GetInlineEditor()), 0, 1); i++;
 
644
        viewItems[i] = MenuItem::NUL;
 
645
 
 
646
        defPropertiesItems = new MenuItem[25]; i=0;
 
647
        defPropertiesItems[i] = MenuItem(
 
648
                "Default Line Width...", MenuItem::PUSHBUTTON, 'W', 0, 0, 
 
649
                DiagramStubs::DefaultLineWidthCB, (XtPointer)viewer,
 
650
                0, 0, 1); i++;
 
651
        defPropertiesItems[i] = MenuItem(
 
652
                "Default Text Font...", MenuItem::PUSHBUTTON, 'F', 0, 0, 
 
653
                DiagramStubs::DefaultFontCB, (XtPointer)viewer, 
 
654
                0, 0, 1); i++;
 
655
        defPropertiesItems[i] = MenuItem(
 
656
                "Default Text Alignment...", MenuItem::PUSHBUTTON, 'A', 0, 0, 
 
657
                DiagramStubs::DefaultTextAlignmentCB, (XtPointer)viewer, 
 
658
                0, 0, 1); i++;
 
659
        defPropertiesItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
660
        defPropertiesItems[i] = MenuItem(
 
661
                "Default Line Color...", MenuItem::PUSHBUTTON, 'L', 0, 0, 
 
662
                DiagramStubs::DefaultLineColorCB, (XtPointer)viewer, 
 
663
                0, 0, 1); i++;
 
664
        defPropertiesItems[i] = MenuItem(
 
665
                "Default Text Color...", MenuItem::PUSHBUTTON, 'T', 0, 0, 
 
666
                DiagramStubs::DefaultTextColorCB, (XtPointer)viewer, 
 
667
                0, 0, 1); i++;
 
668
        defPropertiesItems[i] = MenuItem(
 
669
                "Default Fill Color...", MenuItem::PUSHBUTTON, 'C', 0, 0, 
 
670
                DiagramStubs::DefaultFillColorCB, (XtPointer)viewer, 
 
671
                0, 0, 1); i++;
 
672
        defPropertiesItems[i] = MenuItem::NUL;
 
673
 
 
674
        propertiesItems = new MenuItem[25]; i=0;
 
675
        if (Toolkit::GenericEditor(GetTool())) {
 
676
                propertiesItems[i] = MenuItem(
 
677
                "Update Line Style...", MenuItem::PUSHBUTTON, 'S', 0, 0, 
 
678
                DiagramStubs::UpdateLineStyleCB, (XtPointer)viewer,
 
679
                0, 0, 1); i++;
 
680
        }
 
681
        propertiesItems[i] = MenuItem(
 
682
                "Update Line Width...", MenuItem::PUSHBUTTON, 'W', 0, 0, 
 
683
                DiagramStubs::UpdateLineWidthCB, (XtPointer)viewer,
 
684
                0, 0, 1); i++;
 
685
        if (Toolkit::GenericEditor(GetTool())) {
 
686
                propertiesItems[i] = MenuItem(
 
687
                "Update Line Ends...", MenuItem::PUSHBUTTON, 'E', 0, 0, 
 
688
                DiagramStubs::UpdateLineEndCB, (XtPointer)viewer,
 
689
                0, 0, 1); i++;
 
690
        }
 
691
        propertiesItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
692
        propertiesItems[i] = MenuItem(
 
693
                "Update Text Font...", MenuItem::PUSHBUTTON, 'F', 0, 0, 
 
694
                DiagramStubs::UpdateFontCB, (XtPointer)viewer, 
 
695
                0, 0, 1); i++;
 
696
        propertiesItems[i] = MenuItem(
 
697
                "Update Text Alignment...", MenuItem::PUSHBUTTON, 'A', 0, 0, 
 
698
                DiagramStubs::UpdateTextAlignmentCB, (XtPointer)viewer, 
 
699
                0, 0, 1); i++;
 
700
        propertiesItems[i] = MenuItem(
 
701
                "Set/Unset Text Underlining", MenuItem::PUSHBUTTON, 'U', 0, 0, 
 
702
                DiagramStubs::UpdateTextUnderlineCB, (XtPointer)viewer, 
 
703
                0, 0, 1); i++;
 
704
        propertiesItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
705
        propertiesItems[i] = MenuItem(
 
706
                "Update Line Color...", MenuItem::PUSHBUTTON, 'L', 0, 0, 
 
707
                DiagramStubs::UpdateLineColorCB, (XtPointer)viewer, 
 
708
                0, 0, 1); i++;
 
709
        propertiesItems[i] = MenuItem(
 
710
                "Update Text Color...", MenuItem::PUSHBUTTON, 'T', 0, 0, 
 
711
                DiagramStubs::UpdateTextColorCB, (XtPointer)viewer, 
 
712
                0, 0, 1); i++;
 
713
        propertiesItems[i] = MenuItem(
 
714
                "Update Fill Color...", MenuItem::PUSHBUTTON, 'C', 0, 0, 
 
715
                DiagramStubs::UpdateFillColorCB, (XtPointer)viewer, 
 
716
                0, 0, 1); i++;
 
717
        propertiesItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
718
        propertiesItems[i] = MenuItem(
 
719
                "Default Properties", MenuItem::SUBMENU, 'D', 0, 0, 
 
720
                0, 0, 0, defPropertiesItems, 1); i++;
 
721
        propertiesItems[i] = MenuItem("", MenuItem::SEPARATOR); i++;
 
722
        propertiesItems[i] = MenuItem(
 
723
                "Node/Edge Annotation ...", MenuItem::PUSHBUTTON, 'N', 0,0,
 
724
                DiagramStubs::AnnotateCB, (XtPointer)viewer, 0, 0, 1); i++;
 
725
        propertiesItems[i] = MenuItem::NUL;
 
726
 
 
727
        nodeLineStyleItems = new MenuItem[25]; i=0;
 
728
        nodeLineStyleItems[i] = MenuItem(
 
729
                "Solid", &SOLID_LINE_ICON, MenuItem::RADIOBUTTON, 'S', 0, 0,
 
730
                DiagramStubs::DefaultNodeLineStyleCB, (XtPointer)viewer,
 
731
                (XtPointer)1, 0, 1); i++;
 
732
        nodeLineStyleItems[i] = MenuItem(
 
733
                "Dashed", &DASHED_LINE_ICON, MenuItem::RADIOBUTTON, 'D', 0, 0,
 
734
                DiagramStubs::DefaultNodeLineStyleCB, (XtPointer)viewer,
 
735
                (XtPointer)2, 0, 1); i++;
 
736
        nodeLineStyleItems[i] = MenuItem(
 
737
                "Dotted", &DOTTED_LINE_ICON, MenuItem::RADIOBUTTON, 'o', 0, 0,
 
738
                DiagramStubs::DefaultNodeLineStyleCB, (XtPointer)viewer,
 
739
                (XtPointer)4, 0, 1); i++;
 
740
 
 
741
        edgeLineStyleItems = new MenuItem[25]; i=0;
 
742
        edgeLineStyleItems[i] = MenuItem(
 
743
                "Solid", &SOLID_LINE_ICON, MenuItem::RADIOBUTTON, 'S', 0, 0,
 
744
                DiagramStubs::DefaultEdgeLineStyleCB, (XtPointer)viewer,
 
745
                (XtPointer)1, 0, 1); i++;
 
746
        edgeLineStyleItems[i] = MenuItem(
 
747
                "Dashed", &DASHED_LINE_ICON, MenuItem::RADIOBUTTON, 'D', 0, 0,
 
748
                DiagramStubs::DefaultEdgeLineStyleCB, (XtPointer)viewer,
 
749
                (XtPointer)2, 0, 1); i++;
 
750
        edgeLineStyleItems[i] = MenuItem(
 
751
                "Dotted", &DOTTED_LINE_ICON, MenuItem::RADIOBUTTON, 'o', 0, 0,
 
752
                DiagramStubs::DefaultEdgeLineStyleCB, (XtPointer)viewer,
 
753
                (XtPointer)4, 0, 1); i++;
 
754
}
 
755
 
 
756
void DiagramWindow::CreateIndexToggle(Widget parent) {
 
757
        char wname[10] = "Indexes";
 
758
        Widget rb = XmCreateSimpleCheckBox(parent, wname, 0, 0);
 
759
        Widget pb = XtVaCreateWidget("create/edit index", 
 
760
                                        xmToggleButtonWidgetClass, rb,
 
761
                XmNhighlightThickness, 0,
 
762
                XmNset, viewer->IsShowIndexes(),
 
763
                XmNalignment, XmALIGNMENT_CENTER, 0);
 
764
        XtAddCallback(pb, XmNvalueChangedCallback,
 
765
                        DiagramStubs::ShowIndexesCB, (XtPointer)viewer);
 
766
        AddLiteClue(pb, "When on, new nodes get an index");
 
767
        XtManageChild(pb);
 
768
        XtManageChild(rb);
 
769
}
 
770
 
 
771
int DiagramWindow::GetIconsScrollHeight(int rows) {
 
772
        ScreenType st = GetScreenType();
 
773
        int sr = rows;
 
774
        if (st == EGA)
 
775
                sr = 3;
 
776
        else if (st == VGA)
 
777
                sr = 3;
 
778
        else if (st == SVGA)
 
779
                sr = 4;
 
780
        else if (st == XVGA)
 
781
                sr = 5;
 
782
        else if (st == NCD19B)
 
783
                sr = 6;
 
784
        else if (st == SUN17)
 
785
                sr = 8;
 
786
        else if (st == NCD16)
 
787
                sr = 9;
 
788
        else if (st == HP19)
 
789
                sr = 9;
 
790
        return min(rows, sr)*40;
 
791
}
 
792
 
 
793
 
 
794
/* virtual */ void DiagramWindow::SetHierarchic(bool s) {
 
795
        DrawWindow::SetHierarchic(s);
 
796
        Widget w1 = editMenu->GetMenuItem("Duplicate");
 
797
        if ( w1 )
 
798
                XtVaSetValues(w1, XmNsensitive, ! s, 0);
 
799
        GetDrawingArea()->Enable("Duplicate", ! s);
 
800
}