« back to all changes in this revision
Viewing changes to test006/Handler.H
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Paul Bame
- Date: 2003-03-12 14:05:33 UTC
- Revision ID: james.westby@ubuntu.com-20030312140533-moud629bi4ryp48y
Tags: 2.2-3
tweek for running under buildd and whenever pmccabe not installed
and . not in $PATH
and . not in $PATH
- files added:
- .bzr-builddeb
- debian
- test006
added
removed
test006/Handler.H
1
2
3
4
/************************************************************************\
5
classes used by GraphHandler
6
\************************************************************************/
7
8
class ActionHandler; /* public IlvManagerViewInteractor */
9
10
class MotionHandler; /* public ActionHandler */
11
class Selector; /* public MotionHandler */
12
class SweepSelector; /* public Selector */
13
class SubgraphSelector; /* public Selector */
14
class ArcHandler; /* public MotionHandler */
15
class ArcMaker; /* public ArcHandler */
16
class ArcChanger; /* public ArcHandler */
17
class NodeMaker; /* public MotionHandler */
18
19
class ItemMover; /* public ActionHandler */
20
class NodeMover; /* public ItemMover */
21
class SelectionMover; /* public ItemMover */
22
23
24
class MenuHandler; /* public ActionHandler */
25
26
/************************************************************************\
27
GraphHandler declaration and implementation
28
\************************************************************************/
29
30
31
#define GraphHandlerParent IlvManagerViewInteractor
32
#define GraphHandlerParentPtr IlvManagerViewInteractor*
33
class GraphHandler: public GraphHandlerParent {
34
protected:
35
IlvGraphic* _target;
36
37
SweepSelector* _sweepSelector;
38
SubgraphSelector* _subgraphSelector;
39
Selector* _toggleSelector;
40
Selector* _selector;
41
42
NodeMover* _nodeMover;
43
SelectionMover* _selectionMover;
44
45
ArcMaker* _arcMaker;
46
ArcChanger* _arcChanger;
47
NodeMaker* _nodeMaker;
48
49
MenuHandler* _menuHandler;
50
51
public:
52
GraphHandler(GrapherPtr graph, GraphViewPtr view);
53
~GraphHandler();
54
55
virtual void handleEvent(IlvEvent& event);
56
virtual void doIt(IlvGraphic* graphic,const IlvPoint&);
57
};
58
59
60
#define ActionHandlerParent IlvManagerViewInteractor
61
#define ActionHandlerParentPtr IlvManagerViewInteractor*
62
class ActionHandler: public ActionHandlerParent
63
{
64
protected:
65
GraphHandler* _caller;
66
IlvGraphic* _target;
67
68
void returnControl()
69
{
70
if (_caller) {
71
getManager()->setInteractor(_caller, getView());
72
} else {
73
getManager()->removeInteractor(getView());
74
}
75
}
76
77
ActionHandler(GraphHandler* caller, GrapherPtr manager, IlvView* view)
78
: ActionHandlerParent(manager, view), _caller(caller), _target(nil)
79
{
80
}
81
82
public:
83
void target(IlvGraphic* t) { _target = t; }
84
IlvGraphic* target() { return _target; }
85
IlvBoolean targetted() { return (_target) ? IlvTrue : IlvFalse; }
86
87
virtual void handleEvent(IlvEvent& event);
88
89
virtual void init() {
90
ActionHandlerParent::init();
91
target(nil);
92
}
93
94
void takeCharge(IlvEvent& event, IlvGraphic* under = nil)
95
{
96
getManager()->setInteractor(this);
97
target(under);
98
handleEvent(event);
99
}
100
101
void abort() {
102
ActionHandlerParent::abort();
103
target(nil);
104
}
105
};
106
107
108
#define MotionHandlerParent ActionHandler
109
#define MotionHandlerParentPtr ActionHandler*
110
class MotionHandler: public MotionHandlerParent
111
{
112
protected:
113
// for rubber-banding
114
IlvPoint _first;
115
IlvPoint _current;
116
117
virtual void initializeData(IlvEvent& event)
118
{
119
_first.move(event.x(), event.y());
120
}
121
122
virtual void updateData(IlvEvent& event, IlvView*, IlvManager*)
123
{
124
_current.move(event.x(), event.y());
125
}
126
127
virtual void startMotion(IlvEvent& event) {
128
initializeData(event);
129
drawGhost();
130
updateMotion(event);
131
}
132
virtual void updateMotion(IlvEvent& event) {
133
drawGhost();
134
updateData(event, getView(), getManager());
135
ensureVisible(IlvPoint(event.x(), event.y()));
136
drawGhost();
137
}
138
virtual void endMotion(IlvEvent& event) {
139
updateData(event, getView(), getManager());
140
drawGhost();
141
doIt();
142
returnControl();
143
}
144
145
virtual void drawGhost() { }
146
virtual void doIt() { }
147
148
MotionHandler(GraphHandler* caller, GrapherPtr manager, IlvView* view)
149
: MotionHandlerParent(caller, manager, view)
150
{
151
}
152
153
public:
154
155
virtual IlvBoolean isInitialEvent(IlvEvent&) { return IlvTrue; }
156
virtual IlvBoolean isOkInitialTarget(IlvGraphic*) { return IlvTrue; }
157
virtual IlvBoolean isOkFinalTarget(IlvGraphic*) { return IlvTrue; }
158
virtual void handleEvent(IlvEvent& event);
159
160
};
161
162
163
#define ArcHandlerParent MotionHandler
164
#define ArcHandlerParentPtr MotionHandler*
165
class ArcHandler: public ArcHandlerParent
166
{
167
protected:
168
169
IlvCursor* originalCursor;
170
IlvCursor* initialTargetCursor;
171
IlvCursor* noTargetCursor;
172
IlvCursor* finalTargetCursor;
173
174
void indicateInitialTarget() {
175
IlvDisplay* display = getView()->getDisplay();
176
originalCursor = display->defaultCursor();
177
display->setCursor(getView(), initialTargetCursor);
178
// setCursor(originalCursor);
179
}
180
void indicateNoTarget() {
181
getView()->getDisplay()->setCursor(getView(), noTargetCursor);
182
// setCursor(originalCursor);
183
}
184
void indicateFinalTarget() {
185
getView()->getDisplay()->setCursor(getView(), finalTargetCursor);
186
// setCursor(originalCursor);
187
}
188
void indicatePreviousCursor() {
189
getView()->getDisplay()->setCursor(getView(), originalCursor);
190
}
191
192
virtual void drawGhost()
193
{
194
if ((_current.x() != _first.x()) ||
195
(_current.y() != _first.y())) {
196
IlvPoint tf = _first;
197
IlvTransformer* t = getTransformer();
198
if (t) {
199
t->apply(tf);
200
}
201
202
getManager()->getDisplay()->drawLine(getView(),
203
getManager()->getPalette(),
204
tf, _current);
205
}
206
}
207
208
virtual IlvBoolean isInitialEvent(IlvEvent& event)
209
{
210
return (IlvBoolean) (event.modifiers() & IlvCtrlModifier);
211
}
212
213
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t)
214
{
215
return (t) ? IlvTrue : IlvFalse;
216
}
217
virtual IlvBoolean isOkFinalTarget(IlvGraphic* t)
218
{
219
return (t) ? IlvTrue : IlvFalse;
220
}
221
222
void initCursors();
223
void deleteCursors();
224
225
226
/* protected constructor... cannot instantiate one of these */
227
ArcHandler(GraphHandler* caller, GrapherPtr manager, IlvView* view)
228
: ArcHandlerParent(caller, manager, view)
229
{
230
initCursors();
231
}
232
~ArcHandler()
233
{
234
deleteCursors();
235
}
236
237
public:
238
239
};
240
241
242
#define ArcMakerParent ArcHandler
243
#define ArcMakerParentPtr ArcHandler*
244
class ArcMaker: public ArcMakerParent
245
{
246
protected:
247
IlvBoolean exitedTarget;
248
IlvGraphic* finalTarget;
249
250
virtual void initializeData(IlvEvent& event)
251
{
252
IlvRect bbox;
253
target()->boundingBox(bbox);
254
_first.move(bbox.centerx(), bbox.centery());
255
_current.move(event.x(), event.y());
256
257
exitedTarget = IlvFalse;
258
finalTarget = nil;
259
}
260
virtual void startMotion(IlvEvent& event) {
261
if (!targetted()) {
262
returnControl();
263
} else {
264
initializeData(event);
265
drawGhost();
266
indicateInitialTarget();
267
updateMotion(event);
268
}
269
}
270
271
virtual void updateMotion(IlvEvent& event)
272
{
273
drawGhost();
274
IlvPoint p(event.x(), event.y());
275
IlvManager* mgr = getManager();
276
IlvView* view = getView();
277
updateData(event, view, mgr);
278
if (!exitedTarget) {
279
if (mgr->lastContains(p, view) != target()) {
280
exitedTarget = IlvTrue;
281
}
282
}
283
if (exitedTarget) {
284
IlvGraphic* newTarget = mgr->lastContains(p, view);
285
if (finalTarget) {
286
if (newTarget != finalTarget) {
287
if (isOkFinalTarget(newTarget)) {
288
finalTarget = newTarget;
289
} else {
290
finalTarget = nil;
291
}
292
}
293
} else { // no previous final target
294
if (isOkFinalTarget(newTarget)) {
295
finalTarget = newTarget;
296
}
297
}
298
}
299
if (finalTarget) {
300
indicateFinalTarget();
301
} else if (exitedTarget) {
302
indicateNoTarget();
303
} // else leave as it was...
304
305
ensureVisible(IlvPoint(event.x(), event.y()));
306
drawGhost();
307
}
308
309
virtual void endMotion(IlvEvent& event)
310
{
311
updateData(event, getView(), getManager());
312
indicatePreviousCursor();
313
drawGhost();
314
315
if (targetted() && exitedTarget && (finalTarget != nil)) {
316
doIt();
317
}
318
returnControl();
319
}
320
321
virtual void doIt()
322
{
323
XeNodePtr tail = ((LabelledNodePtr) target())->xeNode();
324
XeNodePtr head = ((LabelledNodePtr) finalTarget)->xeNode();
325
XeGraphPtr graph = ((GrapherPtr)getManager())->xegraph();
326
327
// This will need to be replaced with a call to XeGraph::notify(ArcCreate
328
)
329
XeArcPtr arc = new XeArc(head, tail, "New Arc", True);
330
}
331
332
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t)
333
{
334
return (t != nil) && ((GrapherPtr)getManager())->isNode(t);
335
}
336
virtual IlvBoolean isOkFinalTarget(IlvGraphic* t)
337
{
338
return isOkInitialTarget(t);
339
}
340
341
public:
342
ArcMaker(GraphHandler* caller, GrapherPtr manager, IlvView* view)
343
: ArcMakerParent(caller, manager, view)
344
{
345
}
346
};
347
348
349
#define ArcChangerParent ArcHandler
350
#define ArcChangerParentPtr ArcHandler*
351
class ArcChanger: public ArcChangerParent
352
{
353
protected:
354
IlvGraphic* finalTarget;
355
356
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t)
357
{
358
return (t != nil) && ((GrapherPtr)getManager())->isLink(t);
359
}
360
virtual IlvBoolean isOkFinalTarget(IlvGraphic* t)
361
{
362
return (t != nil) && ((GrapherPtr)getManager())->isNode(t);
363
}
364
365
virtual void initializeData(IlvEvent& event) {
366
// decide which end was the initial target. For now,
367
// only allow change of head
368
IlvLinkImage* arc = (IlvLinkImage*) target();
369
IlvGraphic* node = arc->getFrom();
370
target(node);
371
IlvRect bbox;
372
node->boundingBox(bbox);
373
_first.move(bbox.centerx(), bbox.centery());
374
_current.move(event.x(), event.y());
375
finalTarget = nil;
376
}
377
378
virtual void startMotion(IlvEvent& event) {
379
if (!targetted()) {
380
returnControl();
381
} else {
382
initializeData(event);
383
drawGhost();
384
385
// this will change to indicate appropriate target.
386
indicateNoTarget();
387
updateMotion(event);
388
}
389
}
390
391
virtual void updateMotion(IlvEvent& event)
392
{
393
drawGhost();
394
IlvPoint p(event.x(), event.y());
395
IlvManager* mgr = getManager();
396
IlvView* view = getView();
397
updateData(event, view, mgr);
398
IlvGraphic* newTarget = mgr->lastContains(p, view);
399
if (finalTarget) {
400
if (newTarget != finalTarget) {
401
if (isOkFinalTarget(newTarget)) {
402
finalTarget = newTarget;
403
} else {
404
finalTarget = nil;
405
}
406
}
407
} else { // no previous final target
408
if (isOkFinalTarget(newTarget)) {
409
finalTarget = newTarget;
410
}
411
}
412
if (finalTarget) {
413
indicateFinalTarget();
414
} else {
415
indicateNoTarget();
416
}
417
418
ensureVisible(IlvPoint(event.x(), event.y()));
419
drawGhost();
420
}
421
422
virtual void endMotion(IlvEvent& event)
423
{
424
updateData(event, getView(), getManager());
425
indicatePreviousCursor();
426
drawGhost();
427
428
if (targetted() && (finalTarget != nil)) {
429
doIt();
430
}
431
returnControl();
432
}
433
virtual void doIt();
434
435
public:
436
ArcChanger(GraphHandler* caller, GrapherPtr manager, IlvView* view)
437
: ArcChangerParent(caller, manager, view)
438
{
439
}
440
};
441
442
443
444
#define NodeMakerParent MotionHandler
445
#define NodeMakerParentPtr MotionHandler*
446
class NodeMaker: public NodeMakerParent
447
{
448
protected:
449
IlvRect _xor_rectangle;
450
451
virtual void drawGhost()
452
{
453
if (_xor_rectangle.w()) {
454
getManager()->getDisplay()->drawRectangle(getView(),
455
getManager()->getPalette(),
456
_xor_rectangle);
457
}
458
}
459
virtual IlvBoolean isInitialEvent(IlvEvent& event)
460
{
461
return (IlvBoolean) (event.modifiers() & IlvCtrlModifier);
462
}
463
464
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t)
465
{
466
return (t) ? IlvFalse : IlvTrue;
467
}
468
469
virtual void initializeData(IlvEvent& event)
470
{
471
_xor_rectangle.move(event.x(), event.y());
472
_xor_rectangle.resize(100, 40);
473
}
474
virtual void updateData(IlvEvent& event, IlvView* view, IlvManager* mgr)
475
{
476
NodeMakerParent::updateData(event, view, mgr);
477
_xor_rectangle.move(event.x(), event.y());
478
}
479
virtual void doIt();
480
481
public:
482
NodeMaker(GraphHandler* caller, GrapherPtr manager, IlvView* view)
483
: NodeMakerParent(caller, manager, view)
484
{
485
}
486
};
487
488
const int ObjectLayer = 0;
489
const int HighlightLayer = 1;
490
491
typedef enum {
492
NewSelection,
493
AddSelection,
494
ToggleSelection
495
} SelectionType;
496
497
498
#define SelectorParent MotionHandler
499
#define SelectorParentPtr MotionHandler*
500
class Selector: public SelectorParent
501
{
502
protected:
503
// used to determine actions in various modes
504
SelectionType _type;
505
IlvPoint _p;
506
IlvPoint _tp;
507
IlvRegion _region;
508
509
// for manipulating an individual object
510
IlvBoolean _wasSelected;
511
512
// for outlining individual graphical objects
513
Outliner* _outliner;
514
515
void deselect() {
516
getManager()->deSelectAll();
517
}
518
519
virtual void updateData(IlvEvent& event, IlvView* view, IlvManager* mgr)
520
{
521
SelectorParent::updateData(event, view, mgr);
522
_p.move(event.x(), event.y());
523
_tp = _p;
524
IlvTransformer* xform = getTransformer();
525
if (xform) {
526
xform->apply(_tp);
527
}
528
}
529
530
virtual IlvBoolean isInitialEvent(IlvEvent& event)
531
{
532
return (IlvBoolean) ((!event.modifiers()) ||
533
(event.modifiers() & IlvCtrlModifier));
534
}
535
536
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t)
537
{
538
return (IlvBoolean)(t != nil);
539
// && ((GrapherPtr) getManager())->isNode(target()));
540
}
541
542
public:
543
Selector(GraphHandler* caller, GrapherPtr manager, IlvView* view)
544
: SelectorParent(caller, manager, view)
545
, _type(NewSelection)
546
, _wasSelected(IlvFalse)
547
, _outliner(nil)
548
{
549
}
550
551
virtual void init();
552
553
virtual void startMotion(IlvEvent& event);
554
virtual void updateMotion(IlvEvent& event);
555
virtual void endMotion(IlvEvent& event);
556
557
};
558
559
560
#define SweepSelectorParent Selector
561
#define SweepSelectorParentPtr Selector*
562
class SweepSelector: public SweepSelectorParent
563
{
564
protected:
565
// for sweeping out rectangles for selection
566
IlvRect _xor_rectangle;
567
IlvPos _firstx;
568
IlvPos _firsty;
569
570
void updateData(IlvEvent& event, IlvView* view, IlvManager* mgr)
571
{
572
SweepSelectorParent::updateData(event, view, mgr);
573
_xor_rectangle.move(IlvMin(_firstx, event.x()),
574
IlvMin(_firsty, event.y()));
575
_xor_rectangle.resize((IlvDim)(IlvMax(_firstx, event.x()) -
576
_xor_rectangle.x()),
577
(IlvDim)(IlvMax(_firsty, event.y()) -
578
_xor_rectangle.y()));
579
}
580
581
virtual void startMotion(IlvEvent& event) {
582
if (targetted()) {
583
returnControl();
584
} else {
585
_firstx = event.x();
586
_firsty = event.y();
587
_xor_rectangle.w(0);
588
#if 0
589
deselect();
590
#endif
591
updateMotion(event);
592
}
593
}
594
595
virtual void updateMotion(IlvEvent& event) {
596
if (_xor_rectangle.w()) drawGhost();
597
598
updateData(event, getView(), getManager());
599
ensureVisible(IlvPoint(event.x(), event.y()));
600
drawGhost();
601
}
602
603
virtual void endMotion(IlvEvent& event) {
604
deselect();
605
updateData(event, getView(), getManager());
606
if (_xor_rectangle.w()) {
607
drawGhost();
608
doIt();
609
_xor_rectangle.w(0);
610
}
611
returnControl();
612
}
613
614
virtual void doIt();
615
616
virtual void drawGhost()
617
{
618
if (_xor_rectangle.w()) {
619
getManager()->getDisplay()->drawRectangle(getView(),
620
getManager()->getPalette(),
621
_xor_rectangle);
622
}
623
}
624
625
IlvBoolean isInitialEvent(IlvEvent& event)
626
{
627
return (IlvBoolean) !event.modifiers();
628
}
629
630
IlvBoolean isOkInitialTarget(IlvGraphic* t)
631
{
632
return (IlvBoolean)(t == nil);
633
}
634
635
public:
636
SweepSelector(GraphHandler* caller, GrapherPtr manager, IlvView* view)
637
: SweepSelectorParent(caller, manager, view)
638
{
639
}
640
641
};
642
643
644
#define SubgraphSelectorParent Selector
645
#define SubgraphSelectorParentPtr Selector*
646
class SubgraphSelector: public SubgraphSelectorParent
647
{
648
protected:
649
// for selecting subgraph -- _target holds topmost node...
650
IlvUInt _nSubgraphNodes;
651
LabelledNodePtr* _subgraph;
652
Outliner** _subgraphOutliners;
653
654
virtual void startMotion(IlvEvent& event);
655
656
virtual void updateMotion(IlvEvent& event);
657
virtual void endMotion(IlvEvent& event);
658
IlvBoolean isInitialEvent(IlvEvent& event)
659
{
660
return (IlvBoolean) (event.modifiers() & IlvShiftModifier);
661
}
662
663
IlvBoolean isOkInitialTarget(IlvGraphic* t)
664
{
665
return (IlvBoolean)(t && ((GrapherPtr) getManager())->isNode(target()));
666
}
667
668
public:
669
SubgraphSelector(GraphHandler* caller, GrapherPtr manager, IlvView* view)
670
: SubgraphSelectorParent(caller, manager, view)
671
{
672
}
673
};
674
675
676
#define ItemMoverParent ActionHandler
677
#define ItemMoverParentPtr ActionHandler*
678
class ItemMover: public ItemMoverParent
679
{
680
protected:
681
virtual void startMove(IlvEvent&) { }
682
virtual void updateMove(IlvEvent&) { }
683
virtual void endMove(IlvEvent&) { }
684
685
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t) {
686
return (t != nil) && ((GrapherPtr) getManager())->isNode(t);
687
}
688
public:
689
ItemMover(GraphHandler* caller, GrapherPtr manager, IlvView* view)
690
: ItemMoverParent(caller, manager, view)
691
{
692
}
693
694
void handleEvent(IlvEvent& event);
695
696
};
697
698
699
#define NodeMoverParent ItemMover
700
#define NodeMoverParentPtr ItemMover*
701
class NodeMover: public NodeMoverParent
702
{
703
protected:
704
IlvPos _deltax, _deltay;
705
706
void startMove(IlvEvent& event) {
707
IlvRect bbox;
708
target()->boundingBox(bbox, getTransformer());
709
_deltax = event.x() - bbox.x();
710
_deltay = event.y() - bbox.y();
711
}
712
virtual void updateMove(IlvEvent& event) {
713
IlvRect bbox;
714
target()->boundingBox(bbox, getTransformer());
715
IlvPoint newOrigin(event.x() - _deltax,
716
event.y() - _deltay);
717
if(getTransformer()) getTransformer()->inverse(newOrigin);
718
target()->boundingBox(bbox);
719
IlvDeltaPoint dp((IlvDeltaPos)(newOrigin.x()-bbox.x()),
720
(IlvDeltaPos)(newOrigin.y()-bbox.y()));
721
doIt(target(), dp);
722
}
723
virtual void endMove(IlvEvent&) {
724
target(nil);
725
}
726
virtual void doIt(IlvGraphic* graphic,const IlvDeltaPoint& p);
727
public:
728
NodeMover(GraphHandler* caller, GrapherPtr manager, IlvView* view)
729
: NodeMoverParent(caller, manager, view)
730
{
731
}
732
};
733
734
735
#define SelectionMoverParent NodeMover
736
#define SelectionMoverParentPtr NodeMover*
737
class SelectionMover: public SelectionMoverParent
738
{
739
protected:
740
virtual IlvBoolean isOkInitialTarget(IlvGraphic* t) {
741
return (IlvBoolean) (t && getManager()->isSelected(t) &&
742
((GrapherPtr)getManager())->isNode(t));
743
}
744
virtual void doIt(IlvGraphic* graphic, const IlvDeltaPoint& p);
745
public:
746
SelectionMover(GraphHandler* caller, GrapherPtr manager, IlvView* view)
747
: SelectionMoverParent(caller, manager, view)
748
{
749
}
750
};
751
752
753
#define MenuHandlerParent ActionHandler
754
#define MenuHandlerParentPtr ActionHandler*
755
class MenuHandler : public MenuHandlerParent
756
{
757
public:
758
MenuHandler(GraphHandler* caller, GrapherPtr manager, IlvView* view)
759
: MenuHandlerParent(caller, manager, view)
760
{
761
}
762
void handleEvent(IlvEvent& event);
763
};
764
765
extern void PopupMenu(XegPopupMenuPtr menu, Widget w, IlvEvent* event);
766
767
768
769
770
Loggerhead is a web-based interface for Breezy
Version: 2.0.1