projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0022885: Bugfix: else clause applies to the wrong if statement because of missing...
[occt.git] / src / AIS2D / AIS2D_InteractiveContext.cxx
CommitLineData
7fd59977 1#define IMP140901 //GG 14/09/01 goback to avoid a regression
2// See V2d_Viewer
3
4// SAV 14/11/01 - modification for detection/highlighting/selection elements of
5// SetOf<>. Fully used for SetOfMarkers.
6
7#define OCC197 // jfa 01/03/2002 // for multiple selection of elements
8#define OCC146 // jfa 01/03/2002 // for single selection two times
9#define OCC154 // jfa 06/03/2002 // for correct erasing
10#define OCC389 // vro 19/06/2002 // for Display(obj,dispMode...) setting a view for the IO
11
12#include <Standard_Stream.hxx>
13
14#include <AIS2D_InteractiveContext.ixx>
15#include <Aspect_ColorMap.hxx>
16#include <Aspect_GenericColorMap.hxx>
17#include <Aspect_FontMap.hxx>
18#include <Aspect_MarkMap.hxx>
19#include <Aspect_TypeMap.hxx>
20#include <Aspect_WidthMap.hxx>
21#include <Aspect_FontStyle.hxx>
22#include <Aspect_LineStyle.hxx>
23#include <Aspect_TypeOfMarker.hxx>
24#include <Aspect_TypeOfLine.hxx>
25#include <Aspect_WidthOfLine.hxx>
26#include <Aspect_ColorMapEntry.hxx>
27#include <Aspect_TypeMapEntry.hxx>
28#include <Aspect_WidthMapEntry.hxx>
29#include <Aspect_FontMapEntry.hxx>
30#include <Aspect_MarkMapEntry.hxx>
31#include <gp_GTrsf2d.hxx>
32#include <gp_Trsf2d.hxx>
33
34#include <Graphic2d_Primitive.hxx>
35#include <Graphic2d_SequenceOfPrimitives.hxx>
36
37#include <Graphic2d_View.hxx>
38#include <Graphic2d_DisplayList.hxx>
39#include <V2d_View.hxx>
40#include <Prs2d_Point.hxx>
41#include <Prs2d_Drawer.hxx>
42#include <Prs2d_AspectLine.hxx>
43
44#include <TColStd_ListIteratorOfListOfInteger.hxx>
45#include <TColStd_MapIteratorOfMapOfTransient.hxx>
46#include <TColStd_MapOfTransient.hxx>
47#include <TColStd_HSequenceOfInteger.hxx>
48#include <AIS2D_DataMapIteratorOfDataMapOfLC.hxx>
49#include <AIS2D_DataMapIteratorOfDataMapOfIOStatus.hxx>
50#include <AIS2D_ListIteratorOfListOfIO.hxx>
51#include <AIS2D_PrimitiveArchit.hxx>
52#include <AIS2D_HSequenceOfPrimArchit.hxx>
53#include <AIS2D_GlobalStatus.hxx>
54#include <AIS2D_LocalStatus.hxx>
55#include <AIS2D_LocalContext.hxx>
56#include <AIS2D_ProjShape.hxx>
57
58//SAV
59#include <TColStd_MapOfInteger.hxx>
60#include <TColStd_MapIteratorOfMapOfInteger.hxx>
61
62static TColStd_ListIteratorOfListOfInteger ItL;
63static Standard_Boolean RectMoveTo = Standard_False;
64
65AIS2D_InteractiveContext::AIS2D_InteractiveContext(const Handle(V2d_Viewer)& MainViewer):
66
67 myMainVwr( MainViewer ),
68 myDetectPrecision( 4 ),
69 myResetDetect( Standard_True ),
70 myLastPicked(),
71 myLastinMain(),
72 myLastinColl(),
73 mySeqOfDetIO( new AIS2D_HSequenceOfIO() ),
74 mySeqOfSelIO( new AIS2D_HSequenceOfIO() ),
75 myCurDetectMode( AIS2D_TOD_NONE ),
76 myWasLastMain(),
77 myPickMode( Graphic2d_PM_INCLUDE ),
78 myHighlightColor( Quantity_NOC_CYAN1 ),
79 mySelectionColor( Quantity_NOC_GRAY80 ),
80 mySubIntensity( Quantity_NOC_GRAY40 ),
81 myDisplayMode( 0 ),
82 myLocalContexts( ),
83 myCurLocalIndex( 0 ),
84 myLastMoveView() ,
85 myCurSelected( 0 ),
86 myMaxSelected( 0 )
87{
88
89 myMainVwr->View()->SetDefaultOverrideColor( myMainVwr->InitializeColor( mySelectionColor ) );
90}
91
92AIS2D_InteractiveContext::AIS2D_InteractiveContext(const Handle(V2d_Viewer)& MainViewer,const Handle(V2d_Viewer)& aCollector):
93
94 myMainVwr( MainViewer ),
95
96 myCollectorVwr( aCollector ),
97 myIsCollClosed( Standard_False ),
98 myDetectPrecision( 4 ),
99 myResetDetect( Standard_True ),
100 myLastPicked(),
101 myLastinMain(),
102 myLastinColl(),
103 mySeqOfDetIO( new AIS2D_HSequenceOfIO() ),
104 mySeqOfSelIO( new AIS2D_HSequenceOfIO() ),
105 myCurDetectMode( AIS2D_TOD_NONE ),
106 myWasLastMain(),
107 myPickMode( Graphic2d_PM_INCLUDE ),
108 myHighlightColor( Quantity_NOC_CYAN1 ),
109 mySelectionColor( Quantity_NOC_GRAY80 ),
110 mySubIntensity( Quantity_NOC_GRAY40 ),
111 myDisplayMode( 0 ),
112 myLocalContexts( ),
113 myCurLocalIndex( 0 ),
114 myLastMoveView()
115{
116 myMainVwr->View()->SetDefaultOverrideColor( myMainVwr->InitializeColor( mySelectionColor ) );
117 myCollectorVwr->View()->SetDefaultOverrideColor( myMainVwr->InitializeColor( mySelectionColor ) );
118}
119
120
121 //*************************************************************
122 // Management of the Trash Bin Viewer
123 // *************************************************************
124
125 void AIS2D_InteractiveContext::OpenCollector() {
126 myIsCollClosed = Standard_False;
127 }
128
129
130 // *************************************************************
131 // Editing general Display Services
132 // *************************************************************
133
134void AIS2D_InteractiveContext::Display( const Handle(AIS2D_InteractiveObject)& anIObj,
135 const Standard_Boolean UpdateVwr ) {
136
137 if ( anIObj.IsNull() ) return;
138
139 Standard_Integer DispMode, SelMode;
140 AIS2D_TypeOfDetection HiMod;
141 Standard_Boolean UpdateCol;
142 Handle( AIS2D_GlobalStatus ) GStatus;
143
144 GetDefModes( anIObj, DispMode, HiMod, SelMode );
145
146 if ( !anIObj->HasInteractiveContext() )
147 anIObj->SetContext( this );
148
149 anIObj->SetView( myMainVwr->View() );
150
151 if ( !HasOpenedContext() ) {
152
153 if ( IsDisplayed( anIObj ) ) return;
154 UpdateCol = Standard_False;
155
156 if ( !myObjects.IsBound( anIObj ) ) {
157
158 GStatus = new AIS2D_GlobalStatus( AIS2D_DS_Displayed, DispMode, 0);
159 myObjects.Bind( anIObj, GStatus );
160 DrawObject( anIObj, DispMode ) ;
161
162 } else {
163
164 GStatus = myObjects( anIObj );
165 switch ( GStatus->GraphicStatus() ) {
166
167 case AIS2D_DS_Erased: {
168
169 if ( GStatus->IsHighlight() )
170 UpdateCol = UpdateVwr ;
171 }
172 case AIS2D_DS_FullErased: {
173
174 for ( ItL.Initialize( * GStatus -> DisplayedModes()); ItL.More(); ItL.Next())
175 if ( GStatus->IsSubIntensityOn() ) {
176 // Standard_Integer indCol = myMainVwr->InitializeColor(mySubIntensity);
177 // myMainPM->SetHighlightColor(indCol);
178 // myMainPM->ColorHighlight( anIObj, indCol, ItL.Value() );
179 }
180
181 for ( ItL.Initialize( * GStatus -> SelectionModes() ); ItL.More();ItL.Next() )
182 // mySelectorMgr->Activate( anIObj, ItL.Value(), myMainSelector );
183 GStatus->SetGraphicStatus( AIS2D_DS_Displayed );
184 if ( GStatus->IsHighlight() )
185 Highlight( anIObj, HiMod );
186 break;
187 }
188 default:
189 break;
190 } // end switch
191 } //endif !myObjects.IsBound
192
193 anIObj->Display();
194
195 if ( UpdateCol && !myCollectorVwr.IsNull() ) myCollectorVwr->UpdateNew();
196
197 } else {
198
199 myLocalContexts( myCurLocalIndex )->Display( anIObj, DispMode, Standard_True,SelMode );
200
201 }//endif !HasOpenedContext
202
203 if ( UpdateVwr ) myMainVwr->UpdateNew();
204
205}
206
207void AIS2D_InteractiveContext::Display(
208 const Handle(AIS2D_InteractiveObject)& anIObj,
209 const Standard_Integer aDispMode,
210 const Standard_Integer aSelectMode,
211 const Standard_Boolean UpdateVwr,
212 const Standard_Boolean AllowDecomp) {
213
214 if ( anIObj.IsNull() ) return;
215 if ( !anIObj->HasInteractiveContext() ) anIObj->SetContext(this);
216
217#ifdef OCC389
218 anIObj->SetView(myMainVwr->View());
219#endif
220
221 if ( !HasOpenedContext() ) {
222
223 if ( !anIObj->HasDisplayMode() )
224 anIObj->SetDisplayMode(aDispMode);
225
226 if ( !myObjects.IsBound(anIObj) ) {
227 Handle(AIS2D_GlobalStatus) GStatus=
228 new AIS2D_GlobalStatus( AIS2D_DS_Displayed, aDispMode, aSelectMode );
229 myObjects.Bind( anIObj, GStatus );
230 DrawObject( anIObj, aDispMode );
231
232 if ( aSelectMode != -1 ) {
233 //if ( !mySelectorMgr->Contains( anIObj ) )
234 // mySelectorMgr->Load( anIObj, myMainSelector,aSelectMode );
235 //mySelectorMgr->Activate( anIObj, aSelectMode, myMainSelector );
236 }
237
238 anIObj->SetSelectionMode(aSelectMode);
239
240 } else {
241
242 Handle(AIS2D_GlobalStatus) GStatus = myObjects( anIObj );
243 if ( !GStatus->IsDModeIn( aDispMode ) ) {
244 DrawObject( anIObj, aDispMode );
245 GStatus->AddDisplayMode( aDispMode );
246 if ( GStatus->IsSubIntensityOn() ) {
247#ifdef DEB
248 Standard_Integer indCol = myMainVwr->InitializeColor(mySubIntensity);
249 //myMainPM->SetHighlightColor( indCol );
250 //myMainPM->ColorHighlight( anIObj, indCol, aDispMode );
251#endif
252 }
253 }
254 if ( aSelectMode != -1 ) {
255 GStatus->AddSelectionMode( aSelectMode );
256 //mySelectorMgr->Activate( anIObj, aSelectMode, myMainSelector );
257 }
258
259 }
260 anIObj->Display();
261 } else
262
263 myLocalContexts(myCurLocalIndex)->Display( anIObj, aDispMode, AllowDecomp, aSelectMode);
264
265 if (UpdateVwr) myMainVwr->Update();
266
267}
268
269void AIS2D_InteractiveContext::Redisplay( const Handle(AIS2D_InteractiveObject)& anIObj,
270 const Standard_Boolean updateVwr,
271 const Standard_Boolean /*allModes*/ ) {
272
273 if ( anIObj.IsNull() ) return;
274 //anIObj->Update(allModes);
275
276 if ( updateVwr ) {
277 if ( HasOpenedContext() )
278 myMainVwr->Update();
279 else {
280 if ( myObjects.IsBound( anIObj ) ) {
281 switch ( myObjects(anIObj)->GraphicStatus() ) {
282 case AIS2D_DS_Displayed:
283 DrawObject( anIObj, 0 );
284 myMainVwr->Update();
285 break;
286 case AIS2D_DS_Erased:
287 if ( !myCollectorVwr.IsNull() )
288 myCollectorVwr->Update();
289 default:
290 break;
291 }
292 }
293 }
294 }
295
296}
297
298void AIS2D_InteractiveContext::Load(
299 const Handle(AIS2D_InteractiveObject)& anIObj,
300 const Standard_Integer SelMode,
301 const Standard_Boolean AllowDecomp) {
302
303 if ( anIObj.IsNull() ) return;
304 if ( !anIObj->HasInteractiveContext() ) anIObj->SetContext( this );
305
306 if ( !HasOpenedContext() ) {
307 if ( SelMode == -1 && !AllowDecomp ) {
308 Standard_Integer DispMode;
309 AIS2D_TypeOfDetection HiMod;
310 Standard_Integer selMode = SelMode;
311
312 GetDefModes( anIObj, DispMode, HiMod, selMode );
313 Handle(AIS2D_GlobalStatus) GStatus=
314 new AIS2D_GlobalStatus( AIS2D_DS_FullErased, DispMode, selMode );
315 myObjects.Bind( anIObj,GStatus );
316 return;
317 }
318 }
319 //endif !HasOpenedContext
320 myLocalContexts(myCurLocalIndex)->Load( anIObj, AllowDecomp, SelMode);
321}
322
323void AIS2D_InteractiveContext::Erase(
324 const Handle(AIS2D_InteractiveObject)& anIObj,
325 const Standard_Boolean UpdateVwr,
326 const Standard_Boolean /*PutInCollector*/) {
327
328 if ( anIObj.IsNull() ) return;
329
330 if ( !HasOpenedContext() )
331#ifdef OCC154
332 {
333 anIObj->Erase();
334 if (myObjects.IsBound(anIObj))
335 myObjects(anIObj)->SetGraphicStatus(AIS2D_DS_Erased);
336 }
337#else
338 anIObj->Remove();
339#endif
340 if ( UpdateVwr ) myMainVwr->UpdateNew();
341
342}
343
7fd59977 344void AIS2D_InteractiveContext::EraseAll (const Standard_Boolean /*PutInCollector*/,
345 const Standard_Boolean UpdateVwr)
346{
347 if ( !HasOpenedContext() )
348#ifdef OCC154
349 {
350 myMainVwr->View()->Erase();
351 AIS2D_DataMapIteratorOfDataMapOfIOStatus anItr (myObjects);
352 for (; anItr.More(); anItr.Next())
353 {
354 anItr.Value()->SetGraphicStatus(AIS2D_DS_Erased);
355 }
356 }
357#else
358 myMainVwr->View()->Remove();
359#endif
360 if ( UpdateVwr ) myMainVwr->Update();
361}
362
363void AIS2D_InteractiveContext::DisplayAll (const Standard_Boolean /*OnlyFromCollector*/,
364 const Standard_Boolean /*updateVwr*/) {
365
366}
367
368void AIS2D_InteractiveContext::EraseSelected (const Standard_Boolean PutInCollector,
369 const Standard_Boolean UpdateVwr) {
370 if ( !HasOpenedContext() ) {
371 Standard_Boolean found = Standard_False;
372 if ( mySeqOfSelIO->IsEmpty() ) return;
373 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
374 Erase( mySeqOfSelIO->Value(i), Standard_False, PutInCollector );
375 found = Standard_True;
376 if ( found && UpdateVwr ) {
377 myMainVwr->Update();
378 if ( PutInCollector && !myCollectorVwr.IsNull() )
379 myCollectorVwr->Update();
380 }
381 }
382
383}
384
385void AIS2D_InteractiveContext::DisplaySelected( const Standard_Boolean updateVwr ) {
386
387 if ( !HasOpenedContext() ) {
388 Standard_Boolean found = Standard_False;
389 if ( mySeqOfSelIO->IsEmpty() ) return;
390 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
391 Display( mySeqOfSelIO->Value(i), Standard_False );
392 found = Standard_True;
393 }
394 if ( found && updateVwr ) {
395 myMainVwr->Update();
396 if ( !(myIsCollClosed && myCollectorVwr.IsNull()) )
397 myCollectorVwr->Update();
398 }
399 }
400
401}
402
403Standard_Boolean AIS2D_InteractiveContext::KeepTemporary( const Handle(AIS2D_InteractiveObject)& anIObj,
404 const Standard_Integer WhichContext ) {
405
406 if ( anIObj.IsNull() ) return Standard_False;
407
408 if ( !HasOpenedContext() ) return Standard_False;
409 if ( myObjects.IsBound(anIObj) ) return Standard_False;
410 if ( WhichContext != -1 && !myLocalContexts.IsBound(WhichContext) ) return Standard_False;
411
412 Standard_Integer IsItInLocal = myCurLocalIndex;
413 Standard_Boolean Found( Standard_False );
414
415 while ( IsItInLocal > 0 && !Found ) {
416 if ( !myLocalContexts.IsBound( IsItInLocal ) )
417 IsItInLocal--;
418 else if ( myLocalContexts(IsItInLocal)->IsIn( anIObj ) )
419 Found = Standard_True;
420 else
421 IsItInLocal--;
422 }
423
424 if ( !Found ) return Standard_False;
425
426 Handle(AIS2D_LocalStatus) LS = myLocalContexts(IsItInLocal)->Status(anIObj);
427
428
429 if ( LS->IsTemporary() ){
430 Standard_Integer DM,SM;
431 AIS2D_TypeOfDetection HM;
432 GetDefModes( anIObj, DM, HM, SM );
433
434 SM = LS->SelectionModes()->IsEmpty() ? SM : LS->SelectionModes()->First();
435 if (LS->DisplayMode() != DM ) {
436 Standard_Integer LSM = LS->SelectionModes()->IsEmpty() ? -1 : LS->SelectionModes()->First();
437 myLocalContexts(IsItInLocal)->Display(anIObj,DM,LS->Decomposed(),LSM);
438 }
439
440 Handle(AIS2D_GlobalStatus) GS = new AIS2D_GlobalStatus( AIS2D_DS_Displayed,
441 DM, SM, Standard_False);
442 myObjects.Bind( anIObj, GS );
443
444 LS->SetTemporary(Standard_False);
445 }
446 return Standard_True;
447}
448
449Standard_Boolean AIS2D_InteractiveContext::IsSelected(const Handle(AIS2D_InteractiveObject)& anIObj) const {
450
451 if ( anIObj.IsNull() ) return Standard_False;
452 if ( !HasOpenedContext() )
453 return ( anIObj->State() == 1 );
454 else
455 return myLocalContexts(myCurLocalIndex)->IsSelected(anIObj);
456}
457
458Standard_Boolean AIS2D_InteractiveContext::IsCurrent(const Handle(AIS2D_InteractiveObject)& anIObj) const {
459
460 if ( anIObj.IsNull() ) return Standard_False;
461 return ( anIObj->State() );
462}
463
464Standard_Integer AIS2D_InteractiveContext::OpenLocalContext( const Standard_Boolean UseDispObj,
465 const Standard_Boolean AllowDecomposit,
466 const Standard_Boolean AcceptEraseOfObj ) {
467 if ( !IsCurrent( myLastPicked ) )
468 if ( !myLastPicked.IsNull() ) {
469#ifdef DEB
470 AIS2D_TypeOfDetection HiMod = myLastPicked -> HasHighlightMode() ?
471 myLastPicked->HighlightMode() : myLastPicked->DefaultHighlightMode();
472#endif
473 myLastPicked->Unhighlight();
474 }
475
476 if ( !myLastMoveView.IsNull() )
477 if ( myCurLocalIndex > 0 )
478 myLocalContexts( myCurLocalIndex )->UnhighLastDetect( myLastMoveView );
479
480 myLastinMain.Nullify();
481 myLastinColl.Nullify();
482 myLastPicked.Nullify();
483 myWasLastMain = Standard_True;
484
485// Standard_Integer untilNow = myCurLocalIndex;
486
487 myCurLocalIndex = HighestIndex() + 1;
488
489 Handle(AIS2D_LocalContext) NewLocal= new AIS2D_LocalContext(this,
490 myCurLocalIndex,
491 UseDispObj,
492 AllowDecomposit,
493 AcceptEraseOfObj );
494
495 myLocalContexts.Bind( myCurLocalIndex, NewLocal );
496
497 if ( UseDispObj ) {
498 if ( AllowDecomposit )
499 cout<<"\t\tDecomposition Authorized for Loaded Shapes"<<endl;
500 else
501 cout<<"\t\tNo Decomposition Authorized for Loaded Shapes"<<endl;
502 } else
503 cout<<"\t\tNo Objects Were Loaded "<<endl;
504
505 return myCurLocalIndex;
506
507}
508
509void AIS2D_InteractiveContext::CloseLocalContext( const Standard_Integer ind,
510 const Standard_Boolean updateVwr ) {
511
512 Standard_Integer GoodIndex = ( ind == -1 ) ? myCurLocalIndex : ind;
513 if ( !HasOpenedContext() ) return;
514 if ( !myLocalContexts.IsBound(GoodIndex) ) return;
515
516 if ( myLocalContexts.Extent() == 1 && GoodIndex == myCurLocalIndex ) {
517
518 myLocalContexts(myCurLocalIndex)->Terminate();
519 myLocalContexts.UnBind(myCurLocalIndex);
520 myCurLocalIndex = 0;
521
522 ResetOriginalState(Standard_False);
523
524 } else {
525
526 myLocalContexts(GoodIndex)->Terminate();
527 myLocalContexts.UnBind(GoodIndex);
528
529 if ( GoodIndex == myCurLocalIndex ) {
530 myCurLocalIndex = HighestIndex();
531#ifdef DEB
532 const Handle(AIS2D_LocalContext)& LocCtx = myLocalContexts(myCurLocalIndex);
533#endif
534 }
535
536 }
537
538 if ( updateVwr ) myMainVwr->Update();
539
540}
541
542Standard_Integer AIS2D_InteractiveContext::IndexOfCurrentLocal() const {
543 return myCurLocalIndex;
544}
545
546void AIS2D_InteractiveContext::CloseAllContext( const Standard_Boolean /*updateVwr*/ ) {
547
548
549
550}
551
552void AIS2D_InteractiveContext::SetCurrentObject( const Handle(AIS2D_InteractiveObject)& anIObj,
553 const Standard_Boolean UpdateVwr ) {
554
555 if ( anIObj.IsNull() ) return;
556
557 /*if ( NbCurrents() == 1 && anIObj->State() == 1 ) {
558 Quantity_NameOfColor HiCol;
559 Standard_Boolean HasHiCol;
560 if ( IsHighlighted( anIObj, HasHiCol, HiCol ) )
561 if ( HasHiCol && HiCol != mySelectionColor )
562 Highlight( anIObj, UpdateVwr );
563 return;
564 }
565 */
566 if ( !HasOpenedContext() ) {
567 if ( !myObjects.IsBound(anIObj) )
568 HighlightWithColor( anIObj, mySelectionColor, Standard_False );
569
570 anIObj->SetState(1);
571 Quantity_NameOfColor HiCol;
572 Standard_Boolean HasHiCol;
573 if ( IsHighlighted( anIObj, HasHiCol, HiCol ) ) {
574 if ( HasHiCol && HiCol != mySelectionColor )
575 Highlight( anIObj,UpdateVwr );
576 } else {
577 Highlight( anIObj, UpdateVwr );
578 }
579 //if (UpdateVwr)
580 // UpdateCurrentViewer();
581 }
582
583}
584
585void AIS2D_InteractiveContext::AddOrRemoveCurObject( const Handle(AIS2D_InteractiveObject)& anIObj,
586 const Standard_Boolean UpdateVwr ) {
587
588
589 if ( !HasOpenedContext() ) {
590 if ( anIObj.IsNull() ) return;
591
592 switch ( anIObj->HighlightMode() ) {
593 default:
594 case AIS2D_TOD_OBJECT: {
595 if ( IsIOSelected( anIObj ) ) {
596 Unhighlight( anIObj, Standard_False );
597 anIObj->SetState( 0 );
598 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
599 if ( mySeqOfSelIO->Value(i) == anIObj ) {
600 mySeqOfSelIO->Remove(i);
601 break;
602 }
603 } else {
604 anIObj->SetState( 1 );
605 Highlight( anIObj, Standard_False );
606 mySeqOfSelIO->Append(anIObj);
607 }
608 }
609 break;
610 case AIS2D_TOD_PRIMITIVE: {
611 Standard_Boolean found = Standard_False;
612 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
613 Handle(Graphic2d_Primitive) thePrim = anIObj->Primitive(anIObj->PickedIndex());
614 thePA = anIObj->GetSelectedSeqPrim();
615 for ( int i = 1; i <= thePA->Length(); ++i )
616 if ( thePA->Value(i)->GetPrimitive() == thePrim ) {
617 //thePrim->Unhighlight();
618 Unhighlight( anIObj, Standard_False );
619 thePA->Remove(i);
620 found = Standard_True;
621 break;
622 }
623 if ( !found ) {
624 Highlight( anIObj, Standard_False );
625 thePrim->Highlight();
626 anIObj->AddSelectPrim( thePrim, 0 );
627 if ( ! IsIOSelected( anIObj ) ) {
628 mySeqOfSelIO->Append(anIObj);
629 anIObj->SetState( 1 );
630 }
631 }
632 }
633 break;
634 case AIS2D_TOD_ELEMENT:{
635 Standard_Boolean found = Standard_False;
636 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
637 Handle(Graphic2d_Primitive) thePrim = anIObj->Primitive(anIObj->PickedIndex());
638 Standard_Integer ind = thePrim->PickedIndex();
639 thePA = anIObj->GetSelectedSeqPrim();
640 for ( int i = 1; i <= thePA->Length(); ++i )
641 if ( thePA->Value(i)->GetPrimitive() == thePrim &&
642 thePA->Value(i)->GetIndex() == ind ) {
643#ifdef OCC197
644 // unhighlight the element
645 // thePrim->Unhighlight(ind);
646 Handle(TColStd_HSequenceOfInteger) aHiInds = thePrim->HighlightIndices();
647 for (int k = 1; k <= aHiInds->Length(); k++)
648 {
649 if (aHiInds->Value(k) == ind)
650 {
651 aHiInds->Remove(k);
652 break;
653 }
654 }
655 // unhighlight entire object only if we remove last selected element of it
656 if (thePA->Length() == 1)
657#endif
658 Unhighlight( anIObj, Standard_False );
659 thePA->Remove(i);
660 found = Standard_True;
661 break;
662 }
663 if ( !found ) {
664 Highlight( anIObj, Standard_False );
665 thePrim->Highlight( ind );
666 anIObj->AddSelectPrim( thePrim, ind );
667 if ( ! IsIOSelected( anIObj ) ) {
668 mySeqOfSelIO->Append(anIObj);
669 anIObj->SetState( 1 );
670 }
671 }
672 }
673 break;
674 case AIS2D_TOD_VERTEX: {
675 Standard_Boolean found = Standard_False;
676 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
677 Handle(Graphic2d_Primitive) thePrim = anIObj->Primitive(anIObj->PickedIndex());
678 Standard_Integer ind = thePrim->PickedIndex();
679 thePA = anIObj->GetSelectedSeqPrim();
680 for ( int i = 1; i <= thePA->Length(); ++i )
681 if ( thePA->Value(i)->GetPrimitive() == thePrim &&
682 thePA->Value(i)->GetIndex() == ind ) {
683#ifdef OCC197
684 // unhighlight the vertex
685 // thePrim->Unhighlight(ind);
686 Handle(TColStd_HSequenceOfInteger) aHiInds = thePrim->HighlightIndices();
687 for (int k = 1; k <= aHiInds->Length(); k++)
688 {
689 if (aHiInds->Value(k) == ind)
690 {
691 aHiInds->Remove(k);
692 break;
693 }
694 }
695 // unhighlight entire object only if we remove last selected vertex of it
696 if (thePA->Length() == 1)
697#endif
698 Unhighlight( anIObj, Standard_False );
699 thePA->Remove(i);
700 found = Standard_True;
701 break;
702 }
703 if ( !found ) {
704 Highlight( anIObj, Standard_False );
705 thePrim->Highlight( ind );
706 anIObj->AddSelectPrim( thePrim, ind );
707 if ( ! IsIOSelected( anIObj ) ) {
708 mySeqOfSelIO->Append(anIObj);
709 anIObj->SetState( 1 );
710 }
711 }
712 }
713 break;
714
715 } // end switch
716
717#ifdef OCC197
718 if ( UpdateVwr ) myWasLastMain ? myMainVwr->Update() : UpdateCollector();
719#else
720 if ( UpdateVwr ) UpdateCurrentViewer();
721#endif
722 } else {
723
724// cout<<"Nothing Done : Opened Local Context"<<endl;
725 }
726
727}
728
729void AIS2D_InteractiveContext::UpdateCurrent() {
730
731
732}
733
734void AIS2D_InteractiveContext::SetOkCurrent() {
735
736}
737
738/*Handle(AIS2D_InteractiveObject) AIS2D_InteractiveContext::FirstCurrentObject() {
739 Handle(AIS2D_InteractiveObject) IO ;
740 InitCurrent();
741 if ( MoreCurrent() )
742 return Current();
743 return IO;
744}
745*/
746void AIS2D_InteractiveContext::HighlightCurrent(const Standard_Boolean UpdateVwr) {
747 if ( mySeqOfSelIO->IsEmpty() ) return;
748 Handle(AIS2D_InteractiveObject) IO;
749 AIS2D_TypeOfDetection theTOD;
750 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
751 IO = mySeqOfSelIO->Value(i);
752 theTOD = IO->HighlightMode();
753 if ( theTOD == AIS2D_TOD_OBJECT )
754 Highlight(IO,Standard_False);
755 else if ( theTOD == AIS2D_TOD_PRIMITIVE ||
756 theTOD == AIS2D_TOD_ELEMENT ||
757 theTOD == AIS2D_TOD_VERTEX ) {
758 Standard_Integer pLength = IO->PickList()->Length();
759 if ( pLength ) {
760 IO->Highlight(myMainVwr->InitializeColor( mySelectionColor ));
761 IO->Unhighlight();
762 for ( int j = 1; j <= pLength; j++ )
763 IO->Primitive(IO->PickList()->Value(j))->Highlight();
764 }
765 }
766 } // end for
767 if ( UpdateVwr )
768 UpdateCurrentViewer();
769
770}
771
772void AIS2D_InteractiveContext::UnhighlightCurrent(const Standard_Boolean UpdateVwr) {
773 if ( mySeqOfSelIO->IsEmpty() ) return;
774 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
775 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
776 mySeqOfSelIO->Value(i)->SetState(0);
777 }
778 if ( UpdateVwr )
779 UpdateCurrentViewer();
780}
781
782
783void AIS2D_InteractiveContext::ClearCurrent(const Standard_Boolean UpdateVwr) {
784 if ( mySeqOfSelIO->IsEmpty() ) return;
785 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
786 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
787
788 if ( UpdateVwr )
789 UpdateCurrentViewer();
790}
791
792void AIS2D_InteractiveContext::SetSelectedCurrent() {
793
794}
795
796// SAV - just appending object
797void AIS2D_InteractiveContext::SetSelected( const Handle(AIS2D_InteractiveObject)& obj,
798 const Standard_Boolean update )
799{
800 mySeqOfSelIO->Append( obj );
801 for( Standard_Integer i = 1; i <= obj->Length(); i++ )
802 obj->AddSelectPrim( obj->Primitive( i ), i );
803}
804
805void AIS2D_InteractiveContext::UpdateSelected( const Standard_Boolean UpdateVwr ) {
806
807 if ( !HasOpenedContext() ) {
808 HighlightSelected();
809 }
810 myLocalContexts(myCurLocalIndex)->UpdateSelected( UpdateVwr );
811}
812
813void AIS2D_InteractiveContext::AddOrRemoveSelected(
814 const Handle(AIS2D_InteractiveObject)& anIObj,
815 const Standard_Boolean UpdateVwr ) {
816
817 if ( !anIObj->HasInteractiveContext() ) anIObj->SetContext(this);
818 if ( ! HasOpenedContext() )
819 AddOrRemoveCurObject( anIObj, UpdateVwr );
820 else
821 myLocalContexts(myCurLocalIndex)->AddOrRemoveSelected( anIObj, UpdateVwr);
822
823}
824
825void AIS2D_InteractiveContext::HighlightSelected( const Standard_Boolean UpdateVwr ) {
826
827 if ( !HasOpenedContext() ) {
828 if ( ! mySeqOfSelIO->IsEmpty() )
829 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
830 Highlight( mySeqOfSelIO->Value(i), Standard_False );
831 } else {
832 myLocalContexts(myCurLocalIndex)->UnhighlightPicked( UpdateVwr );
833 }
834 if( UpdateVwr )
835 UpdateCurrentViewer();
836}
837
838void AIS2D_InteractiveContext::UnhighlightSelected( const Standard_Boolean UpdateVwr ) {
839 if ( !HasOpenedContext() ) {
840 if ( ! mySeqOfSelIO->IsEmpty() )
841 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
842 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
843 } else {
844 myLocalContexts(myCurLocalIndex)->UnhighlightPicked( UpdateVwr );
845 }
846 if( UpdateVwr )
847 UpdateCurrentViewer();
848}
849
850void AIS2D_InteractiveContext::ClearSelected( const Standard_Boolean UpdateVwr ) {
851 if ( !HasOpenedContext() )
852 ClearCurrent( UpdateVwr );
853 else
854 myLocalContexts(myCurLocalIndex)->ClearSelected( UpdateVwr );
855}
856
857AIS2D_DisplayStatus AIS2D_InteractiveContext::DisplayStatus( const Handle(AIS2D_InteractiveObject)& anIObj ) const {
858
859 if ( anIObj.IsNull() ) return AIS2D_DS_None;
860
861 if ( myObjects.IsBound(anIObj))
862 return myObjects(anIObj)->GraphicStatus();
863
864 AIS2D_DataMapIteratorOfDataMapOfLC ItM(myLocalContexts);
865 for ( ; ItM.More(); ItM.Next() )
866 if ( ItM.Value()->IsIn(anIObj) )
867 return AIS2D_DS_Temporary;
868
869 return AIS2D_DS_None;
870
871}
872
873AIS2D_PToListOfInt AIS2D_InteractiveContext::DisplayedModes( const Handle(AIS2D_InteractiveObject)& anIObj ) const {
874 return myObjects(anIObj)->DisplayedModes();
875}
876
877Standard_Boolean AIS2D_InteractiveContext::IsDisplayed( const Handle(AIS2D_InteractiveObject)& anIObj ) const {
878
879 if ( anIObj.IsNull() ) return Standard_False;
880
881 if ( myObjects.IsBound(anIObj) )
882 if ( myObjects(anIObj)->GraphicStatus() == AIS2D_DS_Displayed )
883 return Standard_True;
884
885 AIS2D_DataMapIteratorOfDataMapOfLC ItM(myLocalContexts);
886 for ( ; ItM.More(); ItM.Next() )
887 if ( ItM.Value()->IsDisplayed(anIObj) ) return Standard_True;
888
889 return Standard_False;
890
891}
892
893Standard_Boolean AIS2D_InteractiveContext::IsDisplayed( const Handle(AIS2D_InteractiveObject)& /*anIObj*/,
894 const Standard_Integer /*aMode*/ ) const {
895
896 return Standard_False;
897
898}
899
900Standard_Boolean AIS2D_InteractiveContext::IsHighlighted( const Handle(AIS2D_InteractiveObject)& anIObj ) const {
901
902 if ( anIObj.IsNull() ) return Standard_False;
903
904 if (!HasOpenedContext()){
905#ifdef OCC146
906 if (!anIObj->IsHighlighted()) return Standard_False;
907#endif
908 if(!myObjects.IsBound(anIObj))
909 return Standard_False;
910 return myObjects(anIObj)->IsHighlight();
911 }
912 AIS2D_DataMapIteratorOfDataMapOfLC ItM(myLocalContexts);
913 for (;ItM.More();ItM.Next() ) {
914 if (ItM.Value()->IsHighlight(anIObj) )
915 return Standard_True;
916 }
917 return Standard_False;
918
919
920}
921
922Standard_Boolean AIS2D_InteractiveContext::IsHighlighted( const Handle(AIS2D_InteractiveObject)& anIObj,
923 Standard_Boolean& /*WithColor*/,
924 Quantity_NameOfColor& /*theHiCol*/ ) const {
925 if ( anIObj.IsNull() ) return Standard_False;
926
927 if ( !HasOpenedContext() ) {
928#ifdef OCC146
929 if (!anIObj->IsHighlighted()) return Standard_False;
930#endif
931 if ( !myObjects.IsBound(anIObj) )
932 return Standard_False;
933 return myObjects(anIObj)->IsHighlight();
934 }
935 AIS2D_DataMapIteratorOfDataMapOfLC ItM(myLocalContexts);
936 for ( ; ItM.More(); ItM.Next() )
937 if ( ItM.Value()->IsHighlight(anIObj) )
938 return Standard_True;
939
940 return Standard_False;
941
942}
943
944void AIS2D_InteractiveContext::SubIntensityOn(
945 const Handle(AIS2D_InteractiveObject)& anIObj,
946 const Standard_Boolean UpdateVwr) {
947
948 Standard_Integer indCol;
949 if ( !HasOpenedContext() ) {
950 if ( !myObjects.IsBound(anIObj) ) return;
951 const Handle(AIS2D_GlobalStatus) GStatus = myObjects(anIObj);
952 if ( GStatus->IsSubIntensityOn() ) return;
953 GStatus->SubIntensityOn();
954 Standard_Boolean UpdMain(Standard_False),UpdColl(Standard_False);
955
956 for (TColStd_ListIteratorOfListOfInteger It( * GStatus->DisplayedModes() ); It.More(); It.Next() ) {
957 if ( GStatus->GraphicStatus()==AIS2D_DS_Displayed) {
958 SetHighlightColor( mySubIntensity );
959 HighlightWithColor( anIObj, mySubIntensity );
960 UpdMain = Standard_True;
961 } else if ( GStatus->GraphicStatus()==AIS2D_DS_Erased ) {
962 indCol = myCollectorVwr->InitializeColor( mySubIntensity );
963 myCollectorVwr->View()->SetDefaultOverrideColor( indCol );
964 HighlightWithColor(anIObj, mySubIntensity );
965 UpdColl=Standard_True;
966 }
967 }
968 if ( UpdateVwr ) {
969 if ( UpdMain) myMainVwr->Update();
970 if ( UpdColl ) myCollectorVwr->Update();
971 }
972 } else {
973 if ( myObjects.IsBound(anIObj) ) {
974 const Handle(AIS2D_GlobalStatus)& GStatus = myObjects(anIObj);
975 GStatus->SubIntensityOn();
976 for ( ItL.Initialize( * GStatus->DisplayedModes() ); ItL.More(); ItL.Next() ) {
977 SetHighlightColor( mySubIntensity );
978 HighlightWithColor(anIObj, mySubIntensity );
979 }
980 } else
981 myLocalContexts(myCurLocalIndex)->SubIntensityOn(anIObj);
982
983 if (UpdateVwr) myMainVwr->Update();
984 }
985}
986
987void AIS2D_InteractiveContext::SubIntensityOff(
988 const Handle(AIS2D_InteractiveObject)& anIObj,
989 const Standard_Boolean UpdateVwr) {
990
991 if ( !HasOpenedContext() ) {
992 if ( !myObjects.IsBound(anIObj) ) return;
993 const Handle(AIS2D_GlobalStatus)& GStatus = myObjects(anIObj);
994 if ( !GStatus->IsSubIntensityOn() ) return;
995 GStatus->SubIntensityOff();
996 Standard_Boolean UpdMain(Standard_False),UpdColl(Standard_False);
997
998 for ( TColStd_ListIteratorOfListOfInteger It( * GStatus->DisplayedModes() ); It.More() ;It.Next() ) {
999 if ( GStatus->GraphicStatus() != AIS2D_DS_Erased ) {
1000 Unhighlight( anIObj );
1001 UpdMain = Standard_True;
1002 } else {
1003 Unhighlight( anIObj );
1004 UpdColl=Standard_True;
1005 }
1006 }
1007
1008 Standard_Integer DM,SM;
1009 AIS2D_TypeOfDetection HM;
1010 GetDefModes(anIObj,DM,HM,SM);
1011 if ( IsIOSelected(anIObj) )
1012 Highlight(anIObj,HM);
1013
1014 if ( UpdateVwr ) {
1015 if ( UpdMain ) myMainVwr->Update();
1016 if ( UpdColl ) myCollectorVwr->Update();
1017 }
1018 } else {
1019 if ( myObjects.IsBound(anIObj) ) {
1020 const Handle(AIS2D_GlobalStatus)& GStatus = myObjects(anIObj);
1021 GStatus->SubIntensityOff();
1022 for (ItL.Initialize(* GStatus->DisplayedModes());ItL.More();ItL.Next())
1023 Unhighlight(anIObj);
1024 if (GStatus->IsHighlight())
1025 Highlight(anIObj);
1026 } else
1027 myLocalContexts(myCurLocalIndex)->SubIntensityOff(anIObj);
1028 if ( IsSelected(anIObj) )
1029 Highlight(anIObj);
1030
1031 if ( UpdateVwr) myMainVwr->Update();
1032 }
1033}
1034
1035Standard_Boolean AIS2D_InteractiveContext::IsInCollector( const Handle(AIS2D_InteractiveObject)& anIObj ) const {
1036
1037 if ( anIObj.IsNull() )
1038 return Standard_False;
1039
1040 if ( myObjects.IsBound(anIObj) )
1041 return ( myObjects( anIObj)->GraphicStatus() == AIS2D_DS_Erased );
1042 return Standard_False;
1043}
1044
1045void AIS2D_InteractiveContext::Status( const Handle(AIS2D_InteractiveObject)& anIObj,
1046 TCollection_ExtendedString& aStatus ) const {
1047
1048 aStatus = "";
1049
1050 if ( anIObj.IsNull() ) return ;
1051 if ( myObjects.IsBound(anIObj) ) {
1052 aStatus += "\t ____________________________________________";
1053 aStatus += "\t| Known at Neutral Point:\n\tDisplayStatus:";
1054 const Handle(AIS2D_GlobalStatus)& theGStat = myObjects(anIObj);
1055 switch ( theGStat->GraphicStatus() ) {
1056 case AIS2D_DS_Displayed: {
1057 aStatus +="\t| -->Displayed\n";
1058 break;
1059 }
1060 case AIS2D_DS_Erased: {
1061 aStatus +="\t| -->Erased\n";
1062 break;
1063 }
1064 case AIS2D_DS_FullErased: {
1065 aStatus +="\t| -->Full Erased\n";
1066 break;
1067
1068 }
1069 case AIS2D_DS_Temporary:
1070 case AIS2D_DS_None:
1071 break;
1072
1073 }
1074 aStatus += "\t| Active Display Modes in the MainViewer :\n";
1075 for ( ItL.Initialize(*(theGStat->DisplayedModes()));
1076 ItL.More(); ItL.Next() ) {
1077 aStatus += "\t|\t Mode ";
1078 aStatus += TCollection_AsciiString(ItL.Value());
1079 aStatus+="\n";
1080 }
1081 if ( IsCurrent(anIObj) )
1082 aStatus +="\t| Current\n";
1083 //if ( IsSelected(anIObj) )
1084// aStatus +="\t| Selected\n";
1085
1086 aStatus += "\t| Active Selection Modes in the MainViewer :\n";
1087 for ( ItL.Initialize(*(theGStat->SelectionModes() ));
1088 ItL.More(); ItL.Next() ) {
1089 aStatus += "\t\t Mode ";
1090 aStatus += TCollection_AsciiString(ItL.Value());
1091 aStatus+="\n";
1092 }
1093 aStatus += "\t ____________________________________________";
1094
1095 }
1096
1097}
1098
1099void AIS2D_InteractiveContext::UpdateCurrentViewer() {
1100
1101 if ( !myMainVwr.IsNull() ) myMainVwr->UpdateNew();
1102
1103}
1104
1105void AIS2D_InteractiveContext::UpdateCollector() {
1106 if ( !myCollectorVwr.IsNull() ) myCollectorVwr->UpdateNew();
1107}
1108
1109void AIS2D_InteractiveContext::DisplayedObjects (AIS2D_ListOfIO& aListOfIO,
1110 const Standard_Boolean OnlyFromNeutral) const
1111{
1112 AIS2D_DataMapIteratorOfDataMapOfIOStatus It( myObjects );
1113
1114 if ( !HasOpenedContext() || OnlyFromNeutral ) {
1115 for ( ; It.More(); It.Next() )
1116 if ( It.Value()->GraphicStatus() == AIS2D_DS_Displayed )
1117 aListOfIO.Append( It.Key() );
1118 } else {
1119 TColStd_MapOfTransient theMap;
1120
1121 for ( ; It.More(); It.Next() ) {
1122 if ( It.Value()->GraphicStatus() == AIS2D_DS_Displayed )
1123 theMap.Add(It.Key());
1124 }
1125
1126 Standard_Integer NbDisp;
1127 for ( AIS2D_DataMapIteratorOfDataMapOfLC it1(myLocalContexts);
1128 it1.More(); it1.Next() ) {
1129 const Handle(AIS2D_LocalContext)& LC = it1.Value();
1130 NbDisp = LC->DisplayedObjects(theMap);
1131 }
1132
1133 Handle(AIS2D_InteractiveObject) curIO;
1134 Handle(Standard_Transient) Tr;
1135 for ( TColStd_MapIteratorOfMapOfTransient it2(theMap); it2.More(); it2.Next() ) {
1136 Tr = it2.Key();
1137 curIO = *((Handle(AIS2D_InteractiveObject)*) &Tr);
1138 aListOfIO.Append(curIO);
1139 }
1140 }
1141}
1142
1143void AIS2D_InteractiveContext::GetDefModes( const Handle(AIS2D_InteractiveObject)& anIObj,
1144 Standard_Integer& DispMode,
1145 AIS2D_TypeOfDetection& HiMode,
1146 Standard_Integer& SelMode) const {
1147
1148 if ( anIObj.IsNull() ) return ;
1149
1150 DispMode = anIObj->HasDisplayMode() ? anIObj->DisplayMode() : anIObj->DefaultDisplayMode();
1151 HiMode = anIObj->HasHighlightMode() ? anIObj->HighlightMode() : anIObj->DefaultHighlightMode();
1152 SelMode = anIObj->HasSelectionMode() ? anIObj->SelectionMode() : anIObj->DefaultSelectionMode();
1153
1154}
1155
1156void AIS2D_InteractiveContext::EraseGlobal(
1157 const Handle(AIS2D_InteractiveObject)& anIObj,
1158 const Standard_Boolean /*UpdateVwr*/,
1159 const Standard_Boolean /*PutInCollector*/) {
1160
1161 if ( anIObj.IsNull() ) return ;
1162 if ( !myObjects.IsBound( anIObj ) ) return;
1163
1164}
1165
1166
1167void AIS2D_InteractiveContext::SetHighlightColor( const Quantity_NameOfColor aCol ) {
1168
1169 if ( myHighlightColor != aCol ) {
1170 myHighlightColor = aCol;
1171 Standard_Integer anIndex = myMainVwr->InitializeColor(aCol);
1172 myMainVwr->View()->SetDefaultOverrideColor( anIndex );
1173 }
1174}
1175
1176void AIS2D_InteractiveContext::SetSelectionColor( const Quantity_NameOfColor aCol ) {
1177
1178 if ( mySelectionColor != aCol ) {
1179 mySelectionColor = aCol;
1180 Standard_Integer anIndex = myMainVwr->InitializeColor(aCol);
1181 myMainVwr->View()->SetDefaultOverrideColor(anIndex);
1182 }
1183}
1184
1185void AIS2D_InteractiveContext::SetSubIntensityColor( const Quantity_NameOfColor aCol ) {
1186 mySubIntensity = aCol;
1187}
1188
1189Standard_Integer AIS2D_InteractiveContext::HighestIndex() const {
1190
1191 AIS2D_DataMapIteratorOfDataMapOfLC It( myLocalContexts );
1192 Standard_Integer HiInd = 0;
1193 for ( ; It.More(); It.Next() )
1194 HiInd = ( It.Key() > HiInd ) ? It.Key() : HiInd;
1195 return HiInd;
1196
1197}
1198
1199Standard_Integer AIS2D_InteractiveContext::InitializeColor( const Quantity_Color& aColor ) {
1200
1201#ifdef IMP140901
1202 Handle(Aspect_ColorMap) colormap = myMainVwr->ColorMap();
1203#else
1204 Handle(Aspect_GenericColorMap) colormap = myMainVwr->ColorMap();
1205#endif
1206 Standard_Integer size = colormap->Size();
1207 Standard_Integer indColor = colormap->AddEntry(aColor);
1208 if( size != colormap->Size() ) {
1209 myMainVwr->SetColorMap( colormap );
1210 }
1211 return indColor;
1212
1213}
1214
1215Standard_Integer AIS2D_InteractiveContext::InitializeStyle( const Aspect_TypeOfLine aType ) {
1216
1217 Handle(Aspect_TypeMap) typemap = myMainVwr->TypeMap();
1218 Standard_Integer size = typemap->Size();
1219 Standard_Integer indType = typemap->AddEntry(aType);
1220 if( size != typemap->Size() ) {
1221 myMainVwr->SetTypeMap( typemap );
1222 }
1223
1224 return indType;
1225
1226}
1227
1228Standard_Integer AIS2D_InteractiveContext::InitializeWidth( const Aspect_WidthOfLine aWidth ) {
1229
1230 Handle(Aspect_WidthMap) widthmap = myMainVwr->WidthMap();
1231 Standard_Integer size = widthmap->Size();
1232 Standard_Integer indWidth = widthmap->AddEntry(aWidth);
1233 if( size != widthmap->Size() ) {
1234 myMainVwr->SetWidthMap( widthmap );
1235 }
1236
1237 return indWidth;
1238
1239}
1240
1241Standard_Integer AIS2D_InteractiveContext::InitializeMarker( const Aspect_TypeOfMarker aMark ) {
1242
1243 Handle(Aspect_MarkMap) markmap = myMainVwr->MarkMap();
1244 Standard_Integer size = markmap->Size();
1245 Standard_Integer indMark = markmap->AddEntry(aMark);
1246 if( size != markmap->Size() ) {
1247 myMainVwr->SetMarkMap( markmap );
1248 }
1249
1250 return indMark;
1251
1252}
1253
1254Standard_Integer AIS2D_InteractiveContext::InitializeFont( const Aspect_FontStyle& aFont ) {
1255
1256 Handle(Aspect_FontMap) fontmap = myMainVwr->FontMap();
1257 Standard_Integer size = fontmap->Size();
1258 Standard_Integer indFont = fontmap->AddEntry(aFont);
1259 if( size != fontmap->Size() ) {
1260 myMainVwr->SetFontMap( fontmap );
1261 }
1262 return indFont;
1263
1264}
1265
1266void AIS2D_InteractiveContext::DrawObject( const Handle(AIS2D_InteractiveObject)& anIObj,
1267 const Standard_Integer aDispMode ) {
1268
1269 if ( anIObj->IsKind(STANDARD_TYPE(AIS2D_ProjShape) ) ) {
1270
1271 Handle(AIS2D_ProjShape) thePS = Handle(AIS2D_ProjShape)::DownCast(anIObj);
1272 Handle(Graphic2d_Line) theLines = thePS->GetPrimitives();
1273 Handle(Prs2d_AspectLine) theAspLine;
1274
1275 if ( !anIObj->HasAspect(theLines) ) {
1276 Handle(Prs2d_AspectRoot) theAspRoot = anIObj->Attributes()->FindAspect(Prs2d_AN_LINE);
1277 theAspLine = Handle(Prs2d_AspectLine)::DownCast(theAspRoot);
1278 anIObj->SetAspect( theAspLine, theLines );
1279
1280 } else {
1281 theAspLine = Handle(Prs2d_AspectLine)::DownCast( anIObj->GetAspect(theLines) );
1282 }
1283
1284 Quantity_Color aColor;
1285 Aspect_TypeOfLine aType;
1286 Aspect_WidthOfLine aWidth;
1287
1288 theAspLine->ValuesOfLine( aColor, aType, aWidth );
1289
1290 Standard_Integer colorInd = theAspLine->ColorIndex();
1291 Standard_Integer typeInd = theAspLine->TypeIndex();
1292 Standard_Integer widthInd = theAspLine->WidthIndex();
1293
1294 if ( !colorInd ) {
1295 colorInd = InitializeColor( aColor );
1296 theLines->SetColorIndex( colorInd );
1297 }
1298
1299 if ( !typeInd ) {
1300 typeInd = InitializeStyle( aType );
1301 theLines->SetTypeIndex( typeInd );
1302 }
1303
1304 if ( !widthInd ) {
1305 widthInd = InitializeWidth( aWidth );
1306 theLines->SetWidthIndex( widthInd );
1307 }
1308
1309 if ( thePS->IsHLMode() ) {
1310 Handle(Graphic2d_Line) theHLines = thePS->GetHLPrimitives();
1311 theHLines->SetColorIndex( colorInd );
1312 theHLines->SetWidthIndex( widthInd );
1313 Standard_Integer theDashInd = InitializeStyle( Aspect_TOL_DASH );
1314 theHLines->SetTypeIndex( theDashInd );
1315 }
1316
1317 } else {
1318
1319 Handle(Graphic2d_Primitive) thePrim;
1320
1321 for ( Standard_Integer i = 1; i <= anIObj->Length(); i++ ) {
1322 thePrim = anIObj->Primitive( i );
1323 thePrim->SetDisplayMode(aDispMode);
1324 if ( thePrim->IsKind(STANDARD_TYPE(Graphic2d_Line) ) ) {
1325
1326 Handle(Graphic2d_Line) theLine = Handle(Graphic2d_Line)::DownCast(thePrim);
1327 Handle(Prs2d_AspectLine) theAspLine;
1328
1329 if ( !anIObj->HasAspect(theLine) ) {
1330 Handle(Prs2d_AspectRoot) theAspRoot = anIObj->Attributes()->FindAspect(Prs2d_AN_LINE);
1331 theAspLine = Handle(Prs2d_AspectLine)::DownCast(theAspRoot);
1332 anIObj->SetAspect( theAspLine, theLine );
1333
1334 } else {
1335 theAspLine = Handle(Prs2d_AspectLine)::DownCast( anIObj->GetAspect(theLine) );
1336 }
1337
1338 Quantity_Color aColor;
1339 Aspect_TypeOfLine aType;
1340 Aspect_WidthOfLine aWidth;
1341
1342 Quantity_Color aIntColor;
1343 Graphic2d_TypeOfPolygonFilling aTypeFill;
1344 Standard_Integer aTile;
1345 Standard_Boolean aDrawEdge;
1346
1347 theAspLine->ValuesOfLine( aColor, aType, aWidth );
1348 theAspLine->ValuesOfPoly( aIntColor, aTypeFill, aTile, aDrawEdge );
1349
1350 Standard_Integer colorInd = theAspLine->ColorIndex();
1351 Standard_Integer typeInd = theAspLine->TypeIndex();
1352 Standard_Integer widthInd = theAspLine->WidthIndex();
1353 Standard_Integer colorIntInd = theAspLine->InterColorIndex();
1354
1355 if ( !colorInd ) {
1356 colorInd = InitializeColor( aColor );
1357 theLine->SetColorIndex( colorInd );
1358 }
1359
1360 if ( !typeInd ) {
1361 typeInd = InitializeStyle( aType );
1362 theLine->SetTypeIndex( typeInd );
1363 }
1364
1365 if ( !widthInd ) {
1366 widthInd = InitializeWidth( aWidth );
1367 theLine->SetWidthIndex( widthInd );
1368 }
1369
1370 if ( !colorIntInd ) {
1371 colorIntInd = InitializeColor( aIntColor );
1372 theLine->SetInteriorColorIndex( colorIntInd );
1373 }
1374
1375 theLine->SetTypeOfPolygonFilling( aTypeFill );
1376 theLine->SetInteriorPattern( aTile );
1377 theLine->SetDrawEdge( aDrawEdge );
1378
1379 if ( theLine->IsKind(STANDARD_TYPE(Prs2d_Point) ) ) {
1380
1381 Handle(Prs2d_Point) thePnt = Handle(Prs2d_Point)::DownCast(theLine);
1382 thePnt->SetIndex( InitializeMarker( thePnt->Marker() ) );
1383 }
1384
1385 } // end if the kind of primitive is Graphic2d_Line
1386
1387 } // end for exploration of the interactive object
1388
1389 } // end if IO is AIS2D_ProjShape
1390
1391}
1392
1393void AIS2D_InteractiveContext::ResetOriginalState(const Standard_Boolean /*updateviewer*/) {
1394 /*
1395 Standard_Boolean upd_main(Standard_False),upd_col(Standard_False);
1396 TColStd_ListIteratorOfListOfInteger itl;
1397
1398 for (AIS_DataMapIteratorOfDataMapOfIOStatus it(myObjects);it.More();it.Next()){
1399 const Handle(AIS_InteractiveObject)& iobj = it.Key();
1400 const Handle(AIS_GlobalStatus)& STAT = it.Value();
1401 switch(STAT->GraphicStatus()){
1402 case AIS_DS_Displayed:{
1403 upd_main = Standard_True;
1404
1405 // partie display...
1406 for(itl.Initialize(STAT->DisplayedModes());itl.More();itl.Next())
1407 myMainPM->Display(iobj,itl.Value());
1408 if(STAT->IsHilighted()){
1409 if(STAT->HilightColor()!=Quantity_NOC_WHITE)
1410 HilightWithColor(iobj,STAT->HilightColor(),Standard_False);
1411 else
1412 Hilight(iobj,Standard_False);
1413 }
1414 //partie selection
1415 for(itl.Initialize(STAT->SelectionModes());itl.More();itl.Next()){
1416 if(itl.Value()!=-1)
1417 mgrSelector->Activate(iobj,itl.Value(),myMainSel);
1418 }
1419 break;
1420 }
1421 case AIS_DS_Erased:{
1422 upd_col = Standard_True;
1423 EraseGlobal(iobj,Standard_False,Standard_True);
1424 break;
1425 }
1426 case AIS_DS_FullErased:{
1427 EraseGlobal(iobj,Standard_False,Standard_False);
1428 break;
1429 }
1430#ifndef DEB
1431 default:
1432 break;
1433#endif
1434 }
1435 }
1436 if(updateviewer){
1437 if(upd_main)
1438 myMainVwr->Update();
1439 if(upd_col)
1440 myCollectorVwr->Update();
1441 }*/
1442}
1443
1444Standard_Boolean AIS2D_InteractiveContext::AvailableToDetect( const Handle(AIS2D_InteractiveObject)& anIO ) const {
1445#ifndef OCC146
1446 if ( anIO->HighlightMode() == AIS2D_TOD_OBJECT)
1447 return ( ! anIO->State() );
1448#endif
1449 return Standard_True;
1450}
1451
1452void AIS2D_InteractiveContext::DoDetectObject( const Handle(AIS2D_InteractiveObject)& theIO,
1453 const Handle(Graphic2d_TransientManager)& theDrawer ) {
1454 theIO->ClearSeqDetPrim();
1455#ifdef OCC146
1456 if (!theIO->State())
1457#endif
1458 theIO->Unhighlight();
1459 myCurDetectMode = theIO->HighlightMode();
1460 switch ( myCurDetectMode ) {
1461 default :
1462 case AIS2D_TOD_OBJECT :
1463 if ( !IsIOSelected( theIO ) ) {
1464 theDrawer->Draw( theIO );
1465#ifdef OCC146
1466 }
1467 {
1468#endif
1469 if ( !IsIOPicked( theIO ) )
1470 mySeqOfDetIO->Append( theIO );
1471 }
1472 break;
1473 case AIS2D_TOD_PRIMITIVE: {
1474 Standard_Integer pLength = theIO->PickList()->Length();
1475 Handle(Graphic2d_Primitive) thePrim;
1476
1477 if ( pLength ) {
1478 for ( int i = 1; i <= pLength; i++ ) {
1479 thePrim = theIO->Primitive(theIO->PickList()->Value(i));
1480 if ( ! thePrim->IsHighlighted() &&
1481 ! IsPrimSelected ( theIO, thePrim ) ) {
1482 theDrawer->Draw( thePrim );
1483#ifdef OCC146
1484 }
1485 {
1486#endif
1487 if ( ! IsPrimPicked( theIO, thePrim ) ) {
1488 theIO->AddDetectPrim( thePrim, 0 );
1489 if ( !IsIOPicked( theIO ) )
1490 mySeqOfDetIO->Append( theIO );
1491 }
1492 }
1493 }
1494
1495 } else {
1496 thePrim = theIO->Primitive( theIO->PickedIndex() );
1497 if ( ! thePrim->IsHighlighted() ) {
1498 theDrawer->Draw( thePrim );
1499#ifdef OCC146
1500 }
1501 {
1502#endif
1503 if ( ! IsPrimPicked( theIO, thePrim ) ) {
1504 theIO->AddDetectPrim( thePrim, 0 );
1505 if ( !IsIOPicked( theIO ) )
1506 mySeqOfDetIO->Append( theIO );
1507 }
1508 }
1509 }
1510 }
1511 break;
1512 case AIS2D_TOD_ELEMENT: {
1513 Standard_Integer theInd, pLength = theIO->PickList()->Length();
1514 Handle(Graphic2d_Primitive) thePrim;
1515 if ( pLength ) {
1516 for ( int i = 1; i <= pLength; i++ ) {
1517 thePrim = theIO->Primitive(theIO->PickList()->Value(i));
1518 theInd = thePrim->PickedIndex();
1519 if ( ! thePrim->IsHighlighted() ) {
1520
1521 // SAV - begin
1522 const TColStd_MapOfInteger& indices = thePrim->PickedIndices();
1523
1524 if ( indices.Extent() ) {
1525 theDrawer->DrawPickedElements( thePrim );
1526
1527 TColStd_MapIteratorOfMapOfInteger it( indices );
1528 theIO->AddDetectPrim( thePrim, it.Key() );
1529
1530 if ( !IsIOPicked( theIO ) )
1531 mySeqOfDetIO->Append( theIO );
1532 }
1533 else {
1534
1535 for ( int j = 1; j <= thePrim->NumOfElemIndices(); ++j ) {
1536 theDrawer->DrawElement( thePrim, j );
1537 if ( ! IsElemPicked( theIO, thePrim, j ) ) {
1538 theIO->AddDetectPrim( thePrim, j );
1539 if ( !IsIOPicked( theIO ) )
1540 mySeqOfDetIO->Append( theIO );
1541 }
1542 }
1543 }
1544
1545/*
1546 for ( int j = 1; j <= thePrim->NumOfElemIndices(); ++j ) {
1547 theDrawer->DrawElement( thePrim, j );
1548 if ( ! IsElemPicked( theIO, thePrim, j ) ) {
1549 theIO->AddDetectPrim( thePrim, j );
1550 if ( !IsIOPicked( theIO ) )
1551 mySeqOfDetIO->Append( theIO );
1552 }
1553 }
1554*/
1555 }
1556 /*if ( ! IsElemSelected( theIO, thePrim, theInd ) ) {
1557 theDrawer->DrawElement( thePrim, theInd );
1558 if ( ! IsElemPicked( theIO, thePrim, theInd ) ) {
1559 theIO->AddDetectPrim( thePrim, theInd );
1560 if ( ! IsIOPicked( theIO ) )
1561 mySeqOfDetIO->Append( theIO );
1562 }
1563
1564 }
1565 */
1566 }
1567 } else {
1568 thePrim = theIO->Primitive(theIO->PickedIndex());
1569 theInd = thePrim->PickedIndex();
1570#ifdef BUG
1571 if ( theInd > 0 )
1572#else
1573 if ( theInd != 0 )
1574#endif
1575#ifdef OCC146
1576 {
1577#endif
1578 if ( ! IsElemSelected( theIO, thePrim, theInd ) ) {
1579 theDrawer->DrawElement( thePrim, theInd );
1580#ifdef OCC146
1581 }
1582 {
1583#endif
1584 if ( ! IsElemPicked( theIO, thePrim, theInd ) ) {
1585 theIO->AddDetectPrim( thePrim, theInd );
1586 if ( ! IsIOPicked( theIO ) )
1587 mySeqOfDetIO->Append( theIO );
1588 }
1589 }
1590#ifdef OCC146
1591 }
1592#endif
1593 }
1594 }
1595 break;
1596 case AIS2D_TOD_VERTEX: {
1597 Standard_Integer theInd, pLength = theIO->PickList()->Length();
1598 Handle(Graphic2d_Primitive) thePrim;
1599 if ( pLength ) {
1600 for ( int i = 1; i <= pLength; i++ ) {
1601 thePrim = theIO->Primitive(theIO->PickList()->Value(i));
1602 theInd = thePrim->PickedIndex();
1603 if ( ! thePrim->IsHighlighted() )
1604 for ( int j = 1; j <= thePrim->NumOfVertIndices(); ++j ) {
1605 theDrawer->DrawVertex( thePrim, j );
1606 if ( ! IsElemPicked( theIO, thePrim, -j ) ) {
1607 theIO->AddDetectPrim( thePrim, -j );
1608 if ( !IsIOPicked( theIO ) )
1609 mySeqOfDetIO->Append( theIO );
1610 }
1611 }
1612 }
1613 /*if ( ! IsElemSelected( theIO, thePrim, theInd ) ) {
1614 theDrawer->DrawVertex( thePrim, -theInd );
1615 if ( ! IsElemPicked( theIO, thePrim, theInd ) ) {
1616 theIO->AddDetectPrim( thePrim, -theInd );
1617 if ( ! IsIOPicked( theIO ) )
1618 mySeqOfDetIO->Append( theIO );
1619 }
1620 }*/
1621
1622 } else {
1623 thePrim = theIO->Primitive(theIO->PickedIndex());
1624 theInd = thePrim->PickedIndex();
1625 if ( theInd < 0 )
1626#ifdef OCC146
1627 {
1628#endif
1629 if ( ! IsElemSelected( theIO, thePrim, theInd ) ) {
1630 theDrawer->DrawVertex( thePrim, -theInd );
1631#ifdef OCC146
1632 }
1633 {
1634#endif
1635 if ( ! IsElemPicked( theIO, thePrim, theInd ) ) {
1636 theIO->AddDetectPrim( thePrim, theInd );
1637 if ( !IsIOPicked( theIO ) )
1638 mySeqOfDetIO->Append( theIO );
1639 }
1640 }
1641#ifdef OCC146
1642 }
1643#endif
1644
1645 }
1646 }
1647 break;
1648 }
1649
1650}
1651
1652Standard_Boolean AIS2D_InteractiveContext::IsIOPicked( const Handle(AIS2D_InteractiveObject)& anIO ) const {
1653
1654 for ( int i = 1; i <= mySeqOfDetIO->Length(); i++ )
1655 if ( anIO == mySeqOfDetIO->Value(i) )
1656 return Standard_True;
1657 return Standard_False;
1658
1659}
1660
1661Standard_Boolean AIS2D_InteractiveContext::IsIOSelected( const Handle(AIS2D_InteractiveObject)& anIO ) const {
1662
1663 for ( int i = 1; i <= mySeqOfSelIO->Length(); i++ )
1664 if ( anIO == mySeqOfSelIO->Value(i) )
1665 return Standard_True;
1666 return Standard_False;
1667
1668}
1669
1670Standard_Boolean AIS2D_InteractiveContext::IsPrimSelected( const Handle(AIS2D_InteractiveObject)& anIO,
1671 const Handle(Graphic2d_Primitive)& aPrim ) const {
1672
1673 Handle(AIS2D_HSequenceOfPrimArchit) theSPA = anIO->GetSelectedSeqPrim();
1674
1675 for ( int i = 1; i <= theSPA->Length(); i++ )
1676 if ( aPrim == theSPA->Value(i)->GetPrimitive() )
1677 return Standard_True;
1678 return Standard_False;
1679
1680}
1681
1682Standard_Boolean AIS2D_InteractiveContext::IsPrimPicked( const Handle(AIS2D_InteractiveObject)& anIO,
1683 const Handle(Graphic2d_Primitive)& aPrim ) const {
1684 Handle(AIS2D_HSequenceOfPrimArchit) theSPA = anIO->GetDetectSeqPrim();
1685
1686 for ( int i = 1; i <= theSPA->Length(); i++ )
1687 if ( aPrim == theSPA->Value(i)->GetPrimitive() )
1688 return Standard_True;
1689 return Standard_False;
1690}
1691
1692Standard_Boolean AIS2D_InteractiveContext::IsElemPicked( const Handle(AIS2D_InteractiveObject)& anIO,
1693 const Handle(Graphic2d_Primitive)& aPrim,
1694 const Standard_Integer ind ) const {
1695 Handle(AIS2D_HSequenceOfPrimArchit) theSPA = anIO->GetDetectSeqPrim();
1696 for ( int i = 1; i <= theSPA->Length(); i++ )
1697 if ( aPrim == theSPA->Value(i)->GetPrimitive() &&
1698 ind == theSPA->Value(i)->GetIndex() )
1699 return Standard_True;
1700 return Standard_False;
1701}
1702
1703Standard_Boolean AIS2D_InteractiveContext::IsElemSelected( const Handle(AIS2D_InteractiveObject)& anIO,
1704 const Handle(Graphic2d_Primitive)& aPrim,
1705 const Standard_Integer ind ) const {
1706 Handle(AIS2D_HSequenceOfPrimArchit) theSPA = anIO->GetSelectedSeqPrim();
1707 for ( int i = 1; i <= theSPA->Length(); i++ )
1708 if ( aPrim == theSPA->Value(i)->GetPrimitive() &&
1709 ind == theSPA->Value(i)->GetIndex() )
1710 return Standard_True;
1711 return Standard_False;
1712}
1713
1714void AIS2D_InteractiveContext::Highlight( const Handle(AIS2D_InteractiveObject)& anIObj,
1715 const Standard_Boolean updateVwr ) {
1716 if ( anIObj.IsNull() ) return;
1717
1718 if ( !anIObj->HasInteractiveContext() )
1719 anIObj->SetContext( this );
1720 if ( !HasOpenedContext() ) {
1721 if ( !myObjects.IsBound(anIObj) ) return;
1722 Handle(AIS2D_GlobalStatus) aGS = myObjects(anIObj);
1723
1724 aGS->SetHighlightStatus( Standard_True );
1725
1726 switch ( aGS->GraphicStatus() ) {
1727
1728 case AIS2D_DS_Displayed: {
1729
1730 Standard_Integer DispMode,SelMode;
1731 AIS2D_TypeOfDetection HiMode;
1732 GetDefModes( anIObj, DispMode, HiMode, SelMode );
1733 Standard_Integer pInd;
1734 anIObj->Highlight(myMainVwr->InitializeColor( mySelectionColor ));
1735 switch( HiMode ) {
1736 default:
1737 case AIS2D_TOD_OBJECT:
1738 break;
1739 case AIS2D_TOD_PRIMITIVE:
1740 pInd = anIObj->PickedIndex();
1741 anIObj->Unhighlight();
1742 break;
1743 case AIS2D_TOD_ELEMENT:
1744 pInd = anIObj->PickedIndex();
1745 anIObj->Unhighlight();
1746 break;
1747 case AIS2D_TOD_VERTEX:
1748 pInd = anIObj->PickedIndex();
1749 anIObj->Unhighlight();
1750 break;
1751 } //end switch
1752
1753 if ( updateVwr) myMainVwr->Update();
1754
1755 break;
1756 }
1757 case AIS2D_DS_Erased: {
1758#ifdef DEB
1759 Standard_Integer HiMode = anIObj->HasHighlightMode() ?
1760 anIObj->HighlightMode() : anIObj->DefaultHighlightMode();
1761#endif
1762 anIObj->Highlight(myCollectorVwr->InitializeColor( mySelectionColor ));
1763 if ( updateVwr ) myCollectorVwr->Update();
1764 break;
1765 }
1766 case AIS2D_DS_FullErased:
1767 case AIS2D_DS_Temporary:
1768 case AIS2D_DS_None:
1769 break;
1770 } //end switch
1771 } // end if opened context isn't exists
1772 //else
1773 // myLocalContexts(myCurLocalIndex)->Highlight(anIObj);
1774
1775}
1776
1777void AIS2D_InteractiveContext::HighlightWithColor( const Handle(AIS2D_InteractiveObject)& anIObj,
1778 const Quantity_NameOfColor aCol,
1779 const Standard_Boolean updateVwr ) {
1780
1781 if ( anIObj.IsNull() ) return;
1782
1783 if ( !anIObj->HasInteractiveContext() ) anIObj->SetContext(this);
1784
1785 if ( !HasOpenedContext() ) {
1786 if ( !myObjects.IsBound(anIObj) ) return;
1787
1788 const Handle(AIS2D_GlobalStatus)& aGS = myObjects(anIObj);
1789 //const TColStd_ListOfInteger& LL = * aGS->DisplayedModes();
1790
1791 aGS->SetHighlightStatus (Standard_True);
1792
1793 switch ( aGS->GraphicStatus() ) {
1794 case AIS2D_DS_Displayed:{
1795 Standard_Integer DispMode, SelMode;
1796 AIS2D_TypeOfDetection HiMode;
1797 GetDefModes( anIObj, DispMode, HiMode, SelMode );
1798 Standard_Integer indCol = myMainVwr->InitializeColor( aCol );
1799 anIObj->Highlight(indCol);
1800 //SetSelectionColor(aCol);
1801 aGS->SetHighlightColor(aCol);
1802 // if ( updateVwr ) myMainVwr->Update();
1803 break;
1804 }
1805 case AIS2D_DS_Erased: {
1806#ifdef DEB
1807 Standard_Integer HiMode = anIObj->HasHighlightMode()? anIObj->HighlightMode():0;
1808 Standard_Integer indCol = myCollectorVwr->InitializeColor( aCol );
1809#endif
1810 if ( updateVwr) myCollectorVwr->Update();
1811 break;
1812 }
1813 case AIS2D_DS_FullErased:
1814 case AIS2D_DS_Temporary:
1815 case AIS2D_DS_None:
1816 break;
1817 }
1818 } // else
1819 // myLocalContexts(myCurLocalIndex)->Highlight(anIObj,aCol);
1820 if ( updateVwr) myMainVwr->Update();
1821
1822}
1823
1824void AIS2D_InteractiveContext::Unhighlight( const Handle(AIS2D_InteractiveObject)& anIObj,
1825 const Standard_Boolean updateVwr ) {
1826 if ( anIObj.IsNull() ) return;
1827 anIObj->Unhighlight();
1828 switch ( anIObj->HighlightMode() ) {
1829 default:
1830 case AIS2D_TOD_OBJECT:
1831 break;
1832 case AIS2D_TOD_PRIMITIVE:
1833 if ( !anIObj->Primitive(anIObj->PickedIndex()).IsNull() )
1834 anIObj->Primitive(anIObj->PickedIndex())->Unhighlight();
1835 break;
1836 case AIS2D_TOD_ELEMENT:
1837 if ( !anIObj->Primitive(anIObj->PickedIndex()).IsNull() )
1838 anIObj->Primitive(anIObj->PickedIndex())->Unhighlight();
1839 break;
1840 case AIS2D_TOD_VERTEX:
1841 if ( !anIObj->Primitive(anIObj->PickedIndex()).IsNull() )
1842 anIObj->Primitive(anIObj->PickedIndex())->Unhighlight();
1843 break;
1844 }
1845 if ( updateVwr) myMainVwr->UpdateNew();
1846}
1847
1848void AIS2D_InteractiveContext::Place(
1849 const Standard_Integer XPix,
1850 const Standard_Integer YPix,
1851 const Handle(V2d_View)& aView,
1852 const Handle(AIS2D_InteractiveObject)& anIO,
1853 const Standard_Boolean isTemporary ) {
1854
1855 Standard_Real XPS, YPS;
1856 aView->Convert( XPix, YPix, XPS, YPS );
1857 gp_GTrsf2d theGTrsf;
1858 gp_Trsf2d theTrsf;
1859 theTrsf.SetTranslationPart( gp_Vec2d(gp_Pnt2d(0.,0.), gp_Pnt2d(XPS, YPS) ) );
1860 theGTrsf.SetTrsf2d( theTrsf );
1861 anIO->SetTransform( theGTrsf );
1862 Handle(V2d_Viewer) theViewer = aView->Viewer();
1863 if ( isTemporary ) {
1864
1865 Handle(Graphic2d_TransientManager) theDrawer =
1866 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
1867 Standard_Integer ind = theViewer->InitializeColor(myHighlightColor);
1868 theDrawer->SetOverride( Standard_True );
1869 theDrawer->SetOverrideColor( ind );
1870 Display( anIO, Standard_False );
1871 anIO->Highlight( ind );
1872 theDrawer->BeginDraw( aView->Driver() );
1873 theDrawer->Draw( anIO );
1874 theDrawer->EndDraw();
1875 theDrawer->SetOverride( Standard_False );
1876 return;
1877 }
1878 if ( !IsDisplayed( anIO ) )
1879 Display( anIO );
1880 else
1881 theViewer->Update();
1882
1883}
1884
1885void AIS2D_InteractiveContext::Drag(
1886 const Standard_Integer XPix,
1887 const Standard_Integer YPix,
1888 const Handle(V2d_View)& aView,
1889 const Standard_Boolean isTemporary ) {
1890
1891 if ( ! mySeqOfSelIO->IsEmpty() ) {
1892 Handle(AIS2D_InteractiveObject) theIO;
1893 for ( int j = 1; j <= mySeqOfSelIO->Length(); ++j ) {
1894 theIO = mySeqOfSelIO->Value(j);
1895 if ( !isTemporary ) {
1896 Unhighlight( theIO, Standard_False );
1897 theIO->SetState(0);
1898 mySeqOfSelIO->Remove(j);
1899 }
1900 Place( XPix, YPix, aView, theIO, isTemporary );
1901 }
1902 }
1903}
1904
1905AIS2D_StatusOfDetection AIS2D_InteractiveContext::MoveTo(
1906 const Standard_Integer XPix,
1907 const Standard_Integer YPix,
1908 const Handle(V2d_View)& aView ) {
1909
1910 RectMoveTo = Standard_False;
1911 if ( HasOpenedContext() && aView->Viewer() != myCollectorVwr ) {
1912 myWasLastMain = Standard_True;
1913 return myLocalContexts(myCurLocalIndex)->MoveTo( XPix, YPix, aView );
1914 }
1915 Standard_Boolean is_main = Standard_True, UpdVwr = Standard_False;
1916 Handle(V2d_Viewer) theViewer = aView->Viewer();
1917
1918 if ( theViewer == myMainVwr ) {
1919 myLastPicked = myLastinMain;
1920 myWasLastMain = Standard_True;
1921 } else if ( theViewer == myCollectorVwr ) {
1922 myLastPicked = myLastinColl;
1923 is_main = Standard_False;
1924 myWasLastMain = Standard_False;
1925 } else
1926 return AIS2D_SOD_Error;
1927
1928 AIS2D_StatusOfDetection theStat( AIS2D_SOD_Nothing );
1929
1930 Handle(Graphic2d_TransientManager) theDrawer =
1931 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
1932
1933 Handle(Graphic2d_DisplayList) thePickList = aView->Pick( XPix, YPix, myDetectPrecision);
1934
1935 if ( ! thePickList->IsEmpty() ) {
1936
1937 if ( thePickList->Length() == 1 ) {
1938 Handle(Graphic2d_GraphicObject) theGO = thePickList->Value(1);
1939 if ( ! theGO->IsKind(STANDARD_TYPE(AIS2D_InteractiveObject) ) )
1940 return AIS2D_SOD_Nothing;
1941 Handle(AIS2D_InteractiveObject) theIO = Handle(AIS2D_InteractiveObject)::DownCast(theGO);
1942 if ( IsIOPicked( theIO ) )
1943 switch ( theIO->HighlightMode() ) {
1944 default:
1945 case AIS2D_TOD_OBJECT:
1946 return AIS2D_SOD_OnlyOneDetected;
1947 break;
1948 case AIS2D_TOD_PRIMITIVE:
1949 if ( IsPrimPicked(theIO, theIO->Primitive(theIO->PickedIndex())) )
1950 return AIS2D_SOD_OnlyOneDetected;
1951 break;
1952 case AIS2D_TOD_ELEMENT: {
1953 Standard_Integer ind = theIO->PickedIndex();
1954 if ( IsElemPicked( theIO, theIO->Primitive(ind), theIO->Primitive(ind)->PickedIndex() ) )
1955 return AIS2D_SOD_OnlyOneDetected;
1956 else if ( ind < 0 )
1957 myResetDetect= Standard_True;
1958
1959 }
1960 break;
1961 case AIS2D_TOD_VERTEX: {
1962 Standard_Integer ind = theIO->PickedIndex();
1963 if ( IsElemPicked( theIO, theIO->Primitive(ind), theIO->Primitive(ind)->PickedIndex() ) )
1964 return AIS2D_SOD_OnlyOneDetected;
1965 //else if ( ind > 0 )
1966 // myResetDetect= Standard_True;
1967
1968 }
1969 break;
1970
1971 }
1972#ifdef OCC146
1973 myResetDetect = Standard_True;
1974#endif
1975 }
1976 if ( myResetDetect ) {
1977 mySeqOfDetIO->Clear();
1978 Standard_Integer ind = myMainVwr->InitializeColor(myHighlightColor);
1979
1980 for ( int i = 1 ; i <= thePickList->Length(); i++ ) {
1981 Handle(Graphic2d_GraphicObject) theGOi = thePickList->Value(i);
1982 if ( theGOi->IsKind(STANDARD_TYPE(AIS2D_InteractiveObject) ) ) {
1983
1984 myLastPicked = Handle(AIS2D_InteractiveObject)::DownCast( theGOi );
1985 ( is_main ) ? myLastinMain = myLastPicked : myLastinColl = myLastPicked;
1986 if ( myLastPicked->HasHighlightMode() )
1987
1988 if ( AvailableToDetect(myLastPicked) ) {
1989 if ( myLastPicked->HighlightMode() == AIS2D_TOD_OBJECT )
1990#ifdef OCC146
1991 if (!myLastPicked->State())
1992#endif
1993 myLastPicked->Highlight( ind );
1994 theDrawer->SetOverride(Standard_True);
1995 theDrawer->SetOverrideColor(ind);
1996 theDrawer->BeginDraw( aView->Driver() );
1997 DoDetectObject( myLastPicked, theDrawer );
1998 theDrawer->EndDraw();
1999 theDrawer->SetOverride(Standard_False);
2000
2001 } else theStat = AIS2D_SOD_Selected;
2002 }
2003 } // end for
2004
2005 myResetDetect= Standard_False;
2006
2007 } // end if myResetDetect is true
2008
2009 } else {
2010
2011 theStat = AIS2D_SOD_Nothing;
2012 theDrawer->RestoreArea( aView->Driver() );
2013 myResetDetect= Standard_True;
2014
2015 if ( ! mySeqOfDetIO->IsEmpty() ) {
2016 Handle(AIS2D_InteractiveObject) theIO;
2017 for ( int i = 1; i <= mySeqOfDetIO->Length(); ++i ) {
2018 theIO = mySeqOfDetIO->Value(i);
2019 if ( theIO->HighlightMode() == AIS2D_TOD_ELEMENT ||
2020 theIO->HighlightMode() == AIS2D_TOD_VERTEX ) {
2021 theIO->ClearSeqDetPrim();
2022 } else {
2023 if ( ! theIO->State() )
2024 theIO->Unhighlight();
2025 }
2026 theIO->ClearSeqDetPrim();
2027 }
2028 UpdVwr = Standard_True;
2029 }
2030 ( is_main ) ? myLastinMain.Nullify() : myLastinColl.Nullify();
2031 mySeqOfDetIO->Clear();
2032
2033 } // end if PickList isn't empty
2034
2035 //if ( !myLastPicked.IsNull() ) myLastPicked->Unhighlight();
2036
2037 if ( UpdVwr )
2038 is_main ? myMainVwr->Update() : myCollectorVwr->Update();
2039 myLastPicked.Nullify();
2040 myLastMoveView = aView;
2041
2042 return theStat;
2043
2044}
2045
2046
2047//SAV
2048AIS2D_StatusOfDetection AIS2D_InteractiveContext
2049::MoveCircleTo( const Standard_Integer XPix,
2050 const Standard_Integer YPix,
2051 const Standard_Integer Radius,
2052 const Handle(V2d_View)& aView )
2053{
2054 mySeqOfDetIO->Clear();
2055
2056 Handle(Graphic2d_DisplayList) thePickList =
2057 aView->PickByCircle( XPix, YPix, Radius );
2058
2059 return Detect( thePickList, aView );
2060}
2061
2062
2063AIS2D_StatusOfDetection AIS2D_InteractiveContext::MoveTo(
2064 const Standard_Integer Xmin,
2065 const Standard_Integer Ymin,
2066 const Standard_Integer Xmax,
2067 const Standard_Integer Ymax,
2068 const Handle(V2d_View)& aView ) {
2069
2070
2071 /*if ( HasOpenedContext() && aView->Viewer() != myCollectorVwr ) {
2072 myWasLastMain = Standard_True;
2073 return myLocalContexts(myCurLocalIndex)->MoveTo( Xmin, Ymin, Xmax, Ymax, aView );
2074 }
2075 */
2076 mySeqOfDetIO->Clear();
2077
2078 Handle(Graphic2d_DisplayList) thePickList = aView->Pick( Xmin, Ymin, Xmax, Ymax, myPickMode );
2079
2080 return Detect( thePickList, aView );
2081}
2082
2083//SAV
2084AIS2D_StatusOfDetection AIS2D_InteractiveContext
2085::Detect( const Handle(Graphic2d_DisplayList)& dList,
2086 const Handle(V2d_View)& aView )
2087{
2088 AIS2D_StatusOfDetection theStat( AIS2D_SOD_Nothing );
2089
2090 RectMoveTo = Standard_True;
2091 Handle(V2d_Viewer) theViewer = aView->Viewer();
2092 Standard_Boolean is_main = ( theViewer == myCollectorVwr ) ?
2093 Standard_False : Standard_True;
2094 if ( is_main ) myWasLastMain = Standard_True;
2095
2096 Handle(Graphic2d_TransientManager) theDrawer =
2097 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
2098
2099
2100 if ( ! dList->IsEmpty() ) {
2101 Standard_Integer ind = ( is_main ) ?
2102 myMainVwr->InitializeColor(myHighlightColor) :
2103 myCollectorVwr->InitializeColor(myHighlightColor);
2104 Handle(AIS2D_InteractiveObject) theIO;
2105 theDrawer->SetOverride( Standard_True );
2106 theDrawer->SetOverrideColor( ind );
2107 theDrawer->BeginDraw( aView->Driver() );
2108
2109 for ( int i = 1 ; i <= dList->Length(); i++ ) {
2110 Handle(Graphic2d_GraphicObject) theGOi = dList->Value(i);
2111 if ( theGOi->IsKind(STANDARD_TYPE(AIS2D_InteractiveObject))) {
2112 theIO = Handle(AIS2D_InteractiveObject)::DownCast( theGOi );
2113 if ( theIO->HasHighlightMode() )
2114 if ( AvailableToDetect( theIO ) ) {
2115 if ( theIO->HighlightMode() == AIS2D_TOD_OBJECT )
2116 theIO->Highlight( ind );
2117
2118 DoDetectObject( theIO, theDrawer );
2119
2120 } else theStat = AIS2D_SOD_Selected;
2121 }
2122 } // end for
2123 theDrawer->EndDraw();
2124 theDrawer->SetOverride( Standard_False );
2125 } else {
2126
2127 theStat = AIS2D_SOD_Nothing;
2128 theDrawer->RestoreArea( aView->Driver() );
2129 if ( !mySeqOfDetIO->IsEmpty() )
2130 for ( int i = 1; i<= mySeqOfDetIO->Length(); ++i ) {
2131 mySeqOfDetIO->Value(i)->Unhighlight();
2132 mySeqOfDetIO->Value(i)->ClearSeqDetPrim();
2133 }
2134 mySeqOfDetIO->Clear();
2135 is_main ? myMainVwr->Update() : myCollectorVwr->Update();
2136 } // end if PickList isn't empty
2137
2138
2139 return theStat;
2140}
2141
2142AIS2D_StatusOfPick AIS2D_InteractiveContext::Select( const Standard_Boolean UpdateVwr ) {
2143
2144 if ( HasOpenedContext() )
2145 if ( myWasLastMain )
2146 return myLocalContexts(myCurLocalIndex)->Select(UpdateVwr);
2147 else {
2148 myLocalContexts( myCurLocalIndex )->SetSelected( myLastPicked, UpdateVwr );
2149 return AIS2D_SOP_OneSelected;
2150 }
2151#ifdef DEB
2152 AIS2D_StatusOfPick PS( AIS2D_SOP_NothingSelected );
2153#endif
2154
2155 if ( ! mySeqOfDetIO->IsEmpty() ) {
2156 Handle(AIS2D_InteractiveObject) theIO;
2157 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
2158
2159 switch ( myCurDetectMode ) {
2160 default :
2161 case AIS2D_TOD_OBJECT : {
2162 for ( int i = 1; i <= mySeqOfDetIO->Length(); ++i ) {
2163 theIO = mySeqOfDetIO->Value(i);
2164 if ( ! RectMoveTo ) {
2165 thePA = theIO->GetSelectedSeqPrim();
2166 if ( ! thePA->IsEmpty() ) {
2167 for ( int j = 1; j <= thePA->Length(); ++j )
2168 thePA->Value(j)->GetPrimitive()->Unhighlight();
2169 theIO->ClearSeqSelPrim();
2170 }
2171
2172 if ( ! mySeqOfSelIO->IsEmpty() )
2173 for ( int j = 1; j <= mySeqOfSelIO->Length(); ++j ) {
2174 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
2175 mySeqOfSelIO->Value(i)->SetState(0);
2176 mySeqOfSelIO->Remove(i);
2177 }
2178 }
2179 if ( ! theIO->State() ) {
2180 SetCurrentObject( theIO, Standard_False );
2181 mySeqOfSelIO->Append(theIO);
2182 }
2183 }
2184 theIO->ClearSeqDetPrim();
2185 }
2186 break;
2187
2188 case AIS2D_TOD_PRIMITIVE:
2189 {
2190 for ( int i = 1; i <= mySeqOfDetIO->Length(); ++i )
2191 {
2192 Standard_Integer j;
2193
2194 theIO = mySeqOfDetIO->Value(i);
2195 theIO->Highlight(myMainVwr->InitializeColor(mySelectionColor));
2196 theIO->Unhighlight();
2197 theIO->SetState(1);
2198
2199 // unselect selected
2200 if ( !RectMoveTo )
2201 {
2202
2203 thePA = theIO->GetSelectedSeqPrim();
2204 for ( j = 1; j <= thePA->Length(); ++j )
2205 {
2206 thePA->Value(j)->GetPrimitive()->Unhighlight();
2207 }
2208 theIO->ClearSeqSelPrim();
2209
2210 for ( j = 1; j <= mySeqOfSelIO->Length(); ++j )
2211 {
2212 // by EAV: 12.09.01
2213 // Unhighlight( mySeqOfSelIO->Value(j), Standard_False );
2214 mySeqOfSelIO->Value(j)->SetState( 0 );
2215 mySeqOfSelIO->Remove(j);
2216 }
2217 }
2218
2219 // select detected
2220 thePA = theIO->GetDetectSeqPrim();
2221 for ( j = 1; j <= thePA->Length(); ++j )
2222 {
2223 Handle(Graphic2d_Primitive) thePrim = thePA->Value(j)->GetPrimitive();
2224 if ( !thePrim ->IsHighlighted() ) {
2225 thePrim->Highlight();
2226 theIO->AddSelectPrim( thePrim, 0 );
2227 }
2228 }
2229 if ( ! IsIOSelected( theIO ) )
2230 mySeqOfSelIO->Append( mySeqOfDetIO->Value(i) );
2231
2232 } // end for
2233#ifndef OCC146
2234 theIO->ClearSeqDetPrim();
2235#endif
2236 }
2237 break;
2238 case AIS2D_TOD_ELEMENT: {
2239 Standard_Integer theInd;
2240 for ( int i = 1; i <= mySeqOfDetIO->Length(); ++i ) {
2241 theIO = mySeqOfDetIO->Value(i);
2242 theIO->Highlight(myMainVwr->InitializeColor(mySelectionColor));
2243 theIO->Unhighlight();
2244 theIO->SetState(1);
2245 if ( !RectMoveTo ) {
2246 thePA = theIO->GetSelectedSeqPrim();
2247 if ( ! thePA->IsEmpty() ) {
2248 for ( int j = 1; j <= thePA->Length(); ++j )
2249 thePA->Value(j)->GetPrimitive()->Unhighlight();
2250 theIO->ClearSeqSelPrim();
2251 }
2252 if ( ! mySeqOfSelIO->IsEmpty() )
2253 for ( int j = 1; j <= mySeqOfSelIO->Length(); ++j ) {
2254 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
2255 mySeqOfSelIO->Value(i)->SetState(0);
2256 mySeqOfSelIO->Remove(i);
2257 }
2258 }
2259 thePA = theIO->GetDetectSeqPrim();
2260 if ( ! thePA->IsEmpty() ) {
2261 Handle(Graphic2d_Primitive) thePrim;
2262 for ( int j = 1; j <= thePA->Length(); ++j ) {
2263 thePrim = thePA->Value(j)->GetPrimitive();
2264 theInd = thePA->Value(j)->GetIndex();
2265
2266 //SAV - marking that highlighted elements became selected
2267 // fixing regression of element single selection
2268 if ( !thePrim->SetElementsSelected() )
2269 thePrim->Highlight( theInd );
2270 else
2271 thePrim->Unhighlight();
2272 theIO->AddSelectPrim( thePrim, theInd );
2273 }
2274 }
2275 if ( ! IsIOSelected( theIO ) ) mySeqOfSelIO->Append(mySeqOfDetIO->Value(i));
2276 } // end for
2277#ifndef OCC146
2278 theIO->ClearSeqDetPrim();
2279#endif
2280 }
2281 break;
2282 case AIS2D_TOD_VERTEX: {
2283 Standard_Integer theInd;
2284 for ( int i = 1; i <= mySeqOfDetIO->Length(); ++i ) {
2285 theIO = mySeqOfDetIO->Value(i);
2286 theIO->Highlight(myMainVwr->InitializeColor(mySelectionColor));
2287 theIO->Unhighlight();
2288 theIO->SetState(1);
2289 if ( !RectMoveTo ) {
2290 thePA = theIO->GetSelectedSeqPrim();
2291 if ( ! thePA->IsEmpty() ) {
2292 for ( int j = 1; j <= thePA->Length(); ++j )
2293 thePA->Value(j)->GetPrimitive()->Unhighlight();
2294 theIO->ClearSeqSelPrim();
2295 }
2296 if ( ! mySeqOfSelIO->IsEmpty() )
2297 for ( int j = 1; j <= mySeqOfSelIO->Length(); ++j ) {
2298 Unhighlight( mySeqOfSelIO->Value(i), Standard_False );
2299 mySeqOfSelIO->Value(i)->SetState(0);
2300 mySeqOfSelIO->Remove(i);
2301 }
2302 }
2303 thePA = theIO->GetDetectSeqPrim();
2304 if ( ! thePA->IsEmpty() ) {
2305 Handle(Graphic2d_Primitive) thePrim;
2306 for ( int j = 1; j <= thePA->Length(); ++j ) {
2307 thePrim = thePA->Value(j)->GetPrimitive();
2308 theInd = thePA->Value(j)->GetIndex();
2309 thePrim->Highlight( theInd );
2310 theIO->AddSelectPrim( thePrim, theInd );
2311 }
2312 }
2313 if ( ! IsIOSelected( theIO ) ) mySeqOfSelIO->Append(mySeqOfDetIO->Value(i));
2314 } // end for
2315#ifndef OCC146
2316 theIO->ClearSeqDetPrim();
2317#endif
2318 }
2319 break;
2320 } // end switch
2321#ifndef OCC146
2322 mySeqOfDetIO->Clear();
2323#endif
2324 } else {
2325
2326 // if sequence of detected objects is empty
2327 if ( ! mySeqOfSelIO->IsEmpty() ) {
2328 switch ( myCurDetectMode ) {
2329 default :
2330 case AIS2D_TOD_OBJECT : {
2331 Handle(AIS2D_InteractiveObject) theIO;
2332 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
2333 theIO = mySeqOfSelIO->Value(i);
2334 theIO->Unhighlight();
2335 theIO->SetState(0);
2336 if ( myObjects.IsBound(theIO) )
2337 if ( myObjects(theIO)->IsSubIntensityOn() )
2338 HighlightWithColor( theIO, mySubIntensity, Standard_False );
2339 }
2340 }
2341 break;
2342 case AIS2D_TOD_PRIMITIVE: {
2343 Handle(AIS2D_InteractiveObject) theIO;
2344 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
2345 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
2346 theIO = mySeqOfSelIO->Value(i);
2347 thePA = theIO->GetSelectedSeqPrim();
2348 theIO->Unhighlight();
2349 if ( ! thePA->IsEmpty() ) {
2350 for ( int j = 1; j <= thePA->Length(); ++j )
2351 thePA->Value(j)->GetPrimitive()->Unhighlight();
2352 theIO->ClearSeqSelPrim();
2353 }
2354 theIO->SetState(0);
2355 if ( myObjects.IsBound(theIO) )
2356 if ( myObjects(theIO)->IsSubIntensityOn() )
2357 HighlightWithColor( theIO, mySubIntensity, Standard_False );
2358 }
2359
2360 }
2361 break;
2362 case AIS2D_TOD_ELEMENT: {
2363 Handle(AIS2D_InteractiveObject) theIO;
2364 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
2365 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
2366 theIO = mySeqOfSelIO->Value(i);
2367 thePA = theIO->GetSelectedSeqPrim();
2368 theIO->Unhighlight();
2369 if ( ! thePA->IsEmpty() ) {
2370 for ( int j = 1; j <= thePA->Length(); ++j ) {
2371 thePA->Value(j)->GetPrimitive()->Unhighlight();
2372 // SAV - unselecting sub primitives
2373 thePA->Value(j)->GetPrimitive()->ClearSelectedElements();
2374 }
2375 theIO->ClearSeqSelPrim();
2376 }
2377 theIO->SetState(0);
2378 if ( myObjects.IsBound(theIO) )
2379 if ( myObjects(theIO)->IsSubIntensityOn() )
2380 HighlightWithColor( theIO, mySubIntensity, Standard_False );
2381 }
2382 }
2383 break;
2384 case AIS2D_TOD_VERTEX: {
2385 Handle(AIS2D_InteractiveObject) theIO;
2386 Handle(AIS2D_HSequenceOfPrimArchit) thePA;
2387 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i ) {
2388 theIO = mySeqOfSelIO->Value(i);
2389 thePA = theIO->GetSelectedSeqPrim();
2390 theIO->Unhighlight();
2391 if ( ! thePA->IsEmpty() ) {
2392 for ( int j = 1; j <= thePA->Length(); ++j )
2393 thePA->Value(j)->GetPrimitive()->Unhighlight();
2394 theIO->ClearSeqSelPrim();
2395 }
2396 theIO->SetState(0);
2397 if ( myObjects.IsBound(theIO) )
2398 if ( myObjects(theIO)->IsSubIntensityOn() )
2399 HighlightWithColor( theIO, mySubIntensity, Standard_False );
2400 }
2401 }
2402 break;
2403 } // end switch
2404 mySeqOfSelIO->Clear();
2405 } // end if sequence of detected objects isn't empty
2406
2407
2408 }
2409 if ( UpdateVwr ) myWasLastMain ? myMainVwr->Update() : UpdateCollector();
2410
2411 Standard_Integer NS = mySeqOfSelIO->Length();
2412 if ( !NS ) return AIS2D_SOP_NothingSelected;
2413 if ( NS == 1 ) return AIS2D_SOP_OneSelected;
2414
2415 return AIS2D_SOP_SeveralSelected;
2416
2417}
2418
2419AIS2D_StatusOfPick AIS2D_InteractiveContext::ShiftSelect( const Standard_Boolean UpdateVwr )
2420{
2421 if ( HasOpenedContext() ) {
2422 if ( myWasLastMain )
2423 return myLocalContexts( myCurLocalIndex )->ShiftSelect( UpdateVwr );
2424 else {
2425 myLocalContexts( myCurLocalIndex )->AddOrRemoveSelected( myLastPicked, UpdateVwr );
2426 Standard_Integer NS = mySeqOfSelIO->Length();
2427 if ( !NS ) return AIS2D_SOP_NothingSelected;
2428 if ( NS == 1 ) return AIS2D_SOP_OneSelected;
2429 return AIS2D_SOP_SeveralSelected;
2430 }
2431 } //end if opened local context exists
2432
2433 if ( myWasLastMain && !myLastinMain.IsNull() )
2434 AddOrRemoveCurObject( myLastinMain,UpdateVwr );
2435 else if ( !myWasLastMain && !myLastinColl.IsNull() )
2436 AddOrRemoveCurObject( myLastinColl, UpdateVwr );
2437
2438 Standard_Integer NS = mySeqOfSelIO->Length();
2439 if ( NS == 0 ) return AIS2D_SOP_NothingSelected;
2440 if ( NS == 1 ) return AIS2D_SOP_OneSelected;
2441 return AIS2D_SOP_SeveralSelected;
2442
2443}
2444
2445AIS2D_StatusOfPick AIS2D_InteractiveContext::ShiftSelect(
2446 const Standard_Integer /*XPMin*/,
2447 const Standard_Integer /*YPMin*/,
2448 const Standard_Integer /*XPMax*/,
2449 const Standard_Integer /*YPMax*/,
2450 const Handle(V2d_View)& /*aView*/,
2451 const Standard_Boolean /*UpdateVwr*/ )
2452{
2453/*
2454 if ( HasOpenedContext() )
2455 return myLocalContexts( myCurLocalIndex )->ShiftSelect( XPMin, YPMin, XPMax, YPMax, aView, UpdateVwr );
2456
2457 UnhighlightCurrent(Standard_False);
2458 // static Handle(StdSelect_ViewerSelector2d) aSelector;
2459
2460 if ( aView->Viewer() == myMainVwr) {
2461 // aSelector= myMainSelector;
2462 myWasLastMain = Standard_True;}
2463
2464 else if (aView->Viewer() == myCollectorVwr){
2465 // aSelector= myCollectorSel;
2466 myWasLastMain = Standard_False;}
2467 else
2468 return AIS2D_SOP_NothingSelected;
2469 aSelector->SetSensitivity( aView->Convert(mySensitivity) );
2470 aSelector->Pick( XPMin, YPMin, XPMax, YPMax, aView );
2471 AIS2D_Selection::SetCurrentSelection( myCurrentName.ToCString() );
2472 for ( aSelector->Init(); aSelector->More(); aSelector->Next() ) {
2473 const Handle(SelectMgr_SelectableObject)& SObj = aSelector->Picked()->Selectable();
2474 if ( !SObj.IsNull() ) {
2475 AIS2D_SelectStatus SelStat = AIS2D_Selection::Select(SObj);
2476 Standard_Integer mod = (SelStat == AIS2D_SS_Added) ? 1 : 0;
2477 ( * ( (Handle(AIS2D_InteractiveObject)* ) & SObj ) )->SetState(mod);
2478 }
2479 }
2480
2481 HighlightCurrent( UpdateVwr );
2482
2483 Standard_Integer NS = NbCurrents();
2484 if ( NS == 0 ) return AIS2D_SOP_NothingSelected;
2485 if ( NS == 1 ) return AIS2D_SOP_OneSelected;
2486 return AIS2D_SOP_SeveralSelected;
2487 */
2488 return AIS2D_SOP_NothingSelected;
2489}
2490
2491 Standard_Integer AIS2D_InteractiveContext::NbSelected() const
2492{
2493 if ( mySeqOfSelIO->IsEmpty() )
2494 return 0;
2495
2496 Standard_Integer nsel = 0;
2497 switch ( myCurDetectMode )
2498 {
2499 case AIS2D_TOD_ELEMENT:
2500 case AIS2D_TOD_VERTEX:
2501 case AIS2D_TOD_PRIMITIVE:
2502 {
2503 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
2504 {
2505 Handle( AIS2D_InteractiveObject ) io = mySeqOfSelIO->Value( i );
2506 if ( !io.IsNull() )
2507 nsel += io->GetSelectedSeqPrim()->Length();
2508 }
2509 break;
2510 }
2511 default :
2512 nsel = mySeqOfSelIO->Length(); break;
2513 }
2514 return nsel;
2515}
2516
2517 void AIS2D_InteractiveContext::InitSelected()
2518{
2519 myCurSelected = 1;
2520 myMaxSelected = NbSelected();
2521}
2522
2523Standard_Boolean AIS2D_InteractiveContext::MoreSelected() const
2524{
2525 return myCurSelected <= myMaxSelected;
2526}
2527
2528void AIS2D_InteractiveContext::NextSelected()
2529{
2530 myCurSelected++;
2531}
2532
2533Handle( MMgt_TShared ) AIS2D_InteractiveContext::SelectedObject() const
2534{
2535 switch ( myCurDetectMode )
2536 {
2537 case AIS2D_TOD_ELEMENT:
2538 case AIS2D_TOD_VERTEX:
2539 case AIS2D_TOD_PRIMITIVE:
2540 {
2541 Standard_Integer current = 0;
2542 for ( int i = 1; i <= mySeqOfSelIO->Length(); ++i )
2543 {
2544 Handle( AIS2D_InteractiveObject ) io = mySeqOfSelIO->Value( i );
2545 if ( !io.IsNull() )
2546 {
2547 Standard_Integer l = io->GetSelectedSeqPrim()->Length();
2548 if ( myCurSelected <= current + l )
2549 {
2550 return io->GetSelectedSeqPrim()->Value( myCurSelected - current )->GetPrimitive();
2551 }
2552 current += l;
2553 }
2554 }
2555 break;
2556 }
2557 default: break;
2558 }
2559 return mySeqOfSelIO->Value( myCurSelected );
2560}
2561
2562// *******************************************************************************
2563// Immediate Mode Management
2564// *******************************************************************************
2565
2566void AIS2D_InteractiveContext::BeginImmediateDraw( const Handle(V2d_View)& aView ) {
2567
2568 Handle(V2d_Viewer) theViewer = aView->Viewer();
2569 Handle(Graphic2d_TransientManager) theDrawer =
2570 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
2571 theDrawer->BeginDraw( aView->Driver() );
2572
2573}
2574
2575void AIS2D_InteractiveContext::ImmediateDraw( const Handle(AIS2D_InteractiveObject)& anIObj,
2576 const Handle(V2d_View)& aView ) {
2577
2578 Handle(V2d_Viewer) theViewer = aView->Viewer();
2579 Handle(Graphic2d_TransientManager) theDrawer =
2580 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
2581 theDrawer->Draw( anIObj );
2582
2583}
2584
2585void AIS2D_InteractiveContext::EndImmediateDraw( const Handle(V2d_View)& aView ) {
2586 Handle(V2d_Viewer) theViewer = aView->Viewer();
2587 Handle(Graphic2d_TransientManager) theDrawer =
2588 Handle(Graphic2d_TransientManager)::DownCast( theViewer->View()->Drawer() );
2589 theDrawer->EndDraw();
2590}
2591
2592Standard_Boolean AIS2D_InteractiveContext::IsImmediateModeOn(const Handle(V2d_View)& /*aView*/) const {
2593return Standard_False;
2594}
2595
2596//SAV
2597void AIS2D_InteractiveContext::SetDetectionMode( const AIS2D_TypeOfDetection mode )
2598{
2599 myCurDetectMode = mode;
2600}
Open CASCADE Technology repository