// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-// Modified by XAB & Serguei Dec 97 (angle &deviation coeffts)
+#include <AIS_InteractiveContext.hxx>
-#include <AIS_InteractiveContext.ixx>
-
-//#include <AIS_DataMapIteratorOfDataMapOfInteractiveInteger.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-#include <TColStd_MapIteratorOfMapOfTransient.hxx>
-#include <AIS_LocalContext.hxx>
-#include <AIS_LocalStatus.hxx>
-#include <Precision.hxx>
-#include <AIS_Selection.hxx>
+#include <AIS_DataMapIteratorOfDataMapOfILC.hxx>
#include <AIS_DataMapIteratorOfDataMapOfIOStatus.hxx>
#include <AIS_ConnectedInteractive.hxx>
-#include <AIS_MultipleConnectedInteractive.hxx>
-#include <AIS_DataMapIteratorOfDataMapOfILC.hxx>
#include <AIS_GlobalStatus.hxx>
+#include <AIS_InteractiveObject.hxx>
+#include <AIS_ListIteratorOfListOfInteractive.hxx>
+#include <AIS_LocalContext.hxx>
+#include <AIS_LocalStatus.hxx>
#include <AIS_MapIteratorOfMapOfInteractive.hxx>
-#include <PrsMgr_ModedPresentation.hxx>
-#include <Visual3d_ViewManager.hxx>
-#include <Prs3d_ShadingAspect.hxx>
+#include <AIS_MultipleConnectedInteractive.hxx>
#include <AIS_Shape.hxx>
+#include <AIS_Trihedron.hxx>
+#include <Geom_Axis2Placement.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <HLRBRep.hxx>
-#include <Prs3d_IsoAspect.hxx>
+#include <OSD_Environment.hxx>
+#include <Precision.hxx>
+#include <Prs3d_BasicAspect.hxx>
#include <Prs3d_DatumAspect.hxx>
+#include <Prs3d_IsoAspect.hxx>
+#include <Prs3d_LineAspect.hxx>
#include <Prs3d_PlaneAspect.hxx>
+#include <Prs3d_ShadingAspect.hxx>
+#include <PrsMgr_ModedPresentation.hxx>
#include <PrsMgr_PresentableObject.hxx>
+#include <Quantity_Color.hxx>
+#include <SelectMgr_EntityOwner.hxx>
+#include <SelectMgr_Filter.hxx>
+#include <SelectMgr_OrFilter.hxx>
+#include <SelectMgr_SelectionManager.hxx>
#include <Standard_Atomic.hxx>
+#include <Standard_Transient.hxx>
+#include <Standard_Type.hxx>
+#include <StdSelect_ViewerSelector3d.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_MapIteratorOfMapOfTransient.hxx>
+#include <TopLoc_Location.hxx>
+#include <TopoDS_Shape.hxx>
#include <UnitsAPI.hxx>
+#include <V3d_View.hxx>
+#include <V3d_Viewer.hxx>
-#include <AIS_Trihedron.hxx>
-#include <Geom_Axis2Placement.hxx>
-#include <OSD_Environment.hxx>
-
-#include <AIS_ListIteratorOfListOfInteractive.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(AIS_InteractiveContext, Standard_Transient)
namespace
{
- static volatile Standard_Integer THE_AIS_INDEX_SEL = 0;
- static volatile Standard_Integer THE_AIS_INDEX_CUR = 0;
-
- static TCollection_AsciiString AIS_Context_NewSelName()
- {
- return TCollection_AsciiString ("AIS_SelContext_")
- + TCollection_AsciiString (Standard_Atomic_Increment (&THE_AIS_INDEX_SEL));
- }
-
- static TCollection_AsciiString AIS_Context_NewCurName()
- {
- return TCollection_AsciiString ("AIS_CurContext_")
- + TCollection_AsciiString (Standard_Atomic_Increment (&THE_AIS_INDEX_CUR));
- }
+ typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)> AIS_MapOfObjectOwners;
+ typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)>::Iterator AIS_MapIteratorOfMapOfObjectOwners;
}
//=======================================================================
AIS_InteractiveContext::AIS_InteractiveContext(const Handle(V3d_Viewer)& MainViewer):
mgrSelector(new SelectMgr_SelectionManager()),
-myMainPM(new PrsMgr_PresentationManager3d(MainViewer->Viewer())),
+myMainPM(new PrsMgr_PresentationManager3d(MainViewer->StructureManager())),
myMainVwr(MainViewer),
myMainSel(new StdSelect_ViewerSelector3d()),
myWasLastMain(Standard_False),
myToHilightSelected(Standard_True),
myFilters(new SelectMgr_OrFilter()),
myDefaultDrawer(new Prs3d_Drawer()),
+mySelection(new AIS_Selection()),
myDefaultColor(Quantity_NOC_GOLDENROD),
-myHilightColor(Quantity_NOC_CYAN1),
-mySelectionColor(Quantity_NOC_GRAY80),
+myHiStyle(new Graphic3d_HighlightStyle (Aspect_TOHM_COLOR, Quantity_NOC_CYAN1)),
+mySelStyle(new Graphic3d_HighlightStyle (Aspect_TOHM_COLOR, Quantity_NOC_GRAY80)),
myPreselectionColor(Quantity_NOC_GREEN),
-mySubIntensity(Quantity_NOC_GRAY40),
+mySubintStyle(new Graphic3d_HighlightStyle (Aspect_TOHM_COLOR, Quantity_NOC_GRAY40)),
myDisplayMode(0),
myCurLocalIndex(0),
-myAISCurDetected(0),
+myCurDetected(0),
+myCurHighlighted(0),
myZDetectionFlag(0),
-myIsAutoActivateSelMode( Standard_True )
+myIsAutoActivateSelMode(Standard_True)
{
InitAttributes();
}
-void AIS_InteractiveContext::Delete() const
+//=======================================================================
+//function : ~AIS_InteractiveContext
+//purpose :
+//=======================================================================
+AIS_InteractiveContext::~AIS_InteractiveContext()
{
- // clear the static current selection
- AIS_Selection::ClearCurrentSelection();
-
- // to avoid an exception
- if (AIS_Selection::Find (mySelectionName.ToCString()))
- {
- AIS_Selection::Remove (mySelectionName.ToCString());
- }
-
- // to avoid an exception
- if (AIS_Selection::Find (myCurrentName.ToCString()))
- {
- AIS_Selection::Remove (myCurrentName.ToCString());
- }
+ // clear the current selection
+ mySelection->Clear();
// let's remove one reference explicitly. this operation's supposed to
// be performed when mgrSelector will be destroyed but anyway...
- mgrSelector->Remove (myMainSel);
+ const Handle(SelectMgr_ViewerSelector)& aSelector = myMainSel; // to avoid ambiguity
+ mgrSelector->Remove (aSelector);
Handle(AIS_InteractiveContext) aNullContext;
for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
{
Handle(AIS_InteractiveObject) anObj = anObjIter.Key();
anObj->SetContext (aNullContext);
+ for (anObj->Init(); anObj->More(); anObj->Next())
+ {
+ anObj->CurrentSelection()->UpdateBVHStatus (SelectMgr_TBU_Renew);
+ }
}
- MMgt_TShared::Delete();
}
-//=======================================================================
-//function : AIS_SelectionName
-//purpose :
-//=======================================================================
-const TCollection_AsciiString& AIS_InteractiveContext::SelectionName() const
-{
- if(!HasOpenedContext())
- return mySelectionName;
- return myLocalContexts(myCurLocalIndex)->SelectionName();
-
-}
-
-
-
//=======================================================================
//function : UpdateCurrentViewer
//purpose :
myMainVwr->Update();
}
-
-//=======================================================================
-//function : DomainOfMainViewer
-//purpose :
-//=======================================================================
-
-Standard_CString AIS_InteractiveContext::DomainOfMainViewer() const
-{
- return myMainVwr->Domain();
-
-}
-
//=======================================================================
//function : DisplayedObjects
//purpose :
for (TColStd_MapIteratorOfMapOfTransient aDispMapIter (aDispMap); aDispMapIter.More(); aDispMapIter.Next())
{
const Handle(Standard_Transient)& aTransient = aDispMapIter.Key();
- anObj = *((Handle(AIS_InteractiveObject)* )&aTransient);
+ anObj = Handle(AIS_InteractiveObject)::DownCast (aTransient);
theListOfIO.Append (anObj);
}
}
{
for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
{
- if (anObjIter.Value()->GraphicStatus() != theStatus
- || anObjIter.Key()->Type() != theKind)
+ if (theStatus != AIS_DS_None
+ && anObjIter.Value()->GraphicStatus() != theStatus)
+ {
+ continue;
+ }
+ else if (anObjIter.Key()->Type() != theKind)
{
continue;
}
}
}
+//=======================================================================
+//function : ObjectsForView
+//purpose :
+//=======================================================================
+void AIS_InteractiveContext::ObjectsForView (AIS_ListOfInteractive& theListOfIO,
+ const Handle(V3d_View)& theView,
+ const Standard_Boolean theIsVisibleInView,
+ const AIS_DisplayStatus theStatus) const
+{
+ Handle(Graphic3d_CView) aViewImpl = theView->View();
+ const Standard_Integer aViewId = aViewImpl->Identification();
+ for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
+ {
+ if (theStatus != AIS_DS_None
+ && anObjIter.Value()->GraphicStatus() != theStatus)
+ {
+ theListOfIO.Append (anObjIter.Key());
+ continue;
+ }
+
+ Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (anObjIter.Key());
+ const Standard_Boolean isVisible = anAffinity->IsVisible (aViewId);
+ if (isVisible == theIsVisibleInView)
+ {
+ theListOfIO.Append (anObjIter.Key());
+ }
+ }
+}
+
//=======================================================================
//function : Display
//purpose :
theToUpdateViewer, theIObj->AcceptShapeDecomposition());
}
+//=======================================================================
+//function : SetViewAffinity
+//purpose :
+//=======================================================================
+void AIS_InteractiveContext::SetViewAffinity (const Handle(AIS_InteractiveObject)& theIObj,
+ const Handle(V3d_View)& theView,
+ const Standard_Boolean theIsVisible)
+{
+ if (theIObj.IsNull()
+ || !myObjects.IsBound (theIObj))
+ {
+ return;
+ }
+
+ Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (theIObj);
+ Handle(Graphic3d_CView) aViewImpl = theView->View();
+ anAffinity->SetVisible (aViewImpl->Identification(), theIsVisible == Standard_True);
+ if (theIsVisible)
+ {
+ theView->View()->ChangeHiddenObjects()->Remove (theIObj.get());
+ }
+ else
+ {
+ theView->View()->ChangeHiddenObjects()->Add (theIObj.get());
+ }
+}
+
//=======================================================================
//function : Display
//purpose :
const Standard_Integer theDispMode,
const Standard_Integer theSelectionMode,
const Standard_Boolean theToUpdateViewer,
- const Standard_Boolean theToAllowDecomposition)
+ const Standard_Boolean theToAllowDecomposition,
+ const AIS_DisplayStatus theDispStatus)
{
if (theIObj.IsNull())
{
return;
}
- if (!theIObj->HasInteractiveContext())
+ if (theDispStatus == AIS_DS_Erased)
{
- theIObj->SetContext (this);
+ Erase (theIObj, theToUpdateViewer);
+ Load (theIObj, theSelectionMode, theToAllowDecomposition);
+ return;
}
- if (HasOpenedContext())
+ setContextToObject (theIObj);
+ if (theDispStatus == AIS_DS_Temporary
+ && !HasOpenedContext())
{
- myLocalContexts (myCurLocalIndex)->Display (theIObj, theDispMode, theToAllowDecomposition, theSelectionMode);
- if (theToUpdateViewer)
+ return;
+ }
+ else if (HasOpenedContext())
+ {
+ if (theDispStatus == AIS_DS_None
+ || theDispStatus == AIS_DS_Temporary)
{
- myMainVwr->Update();
+ myLocalContexts (myCurLocalIndex)->Display (theIObj, theDispMode, theToAllowDecomposition, theSelectionMode);
+ if (theToUpdateViewer)
+ {
+ myMainVwr->Update();
+ }
+ return;
}
- return;
}
if (!myObjects.IsBound (theIObj))
{
Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Displayed, theDispMode, theSelectionMode);
myObjects.Bind (theIObj, aStatus);
+ Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->RegisterObject (theIObj);
myMainPM->Display(theIObj, theDispMode);
if (theSelectionMode != -1)
{
- if (!mgrSelector->Contains (theIObj))
+ const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
+ if (!mgrSelector->Contains (anObj))
{
mgrSelector->Load (theIObj);
}
else
{
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
- if (aStatus->GraphicStatus() != AIS_DS_Displayed
- && aStatus->GraphicStatus() != AIS_DS_Erased)
+ if (aStatus->GraphicStatus() == AIS_DS_Temporary)
{
return;
}
- // Erase presentations for all display modes different from aDispMode.
+ // Mark the presentation modes hidden of interactive object different from aDispMode.
// Then make sure aDispMode is displayed and maybe highlighted.
// Finally, activate selection mode <SelMode> if not yet activated.
- TColStd_ListOfInteger aModesToRemove;
- for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
+ const Standard_Integer anOldMode = aStatus->DisplayMode();
+ if (anOldMode != theDispMode)
{
- const Standard_Integer anOldMode = aDispModeIter.Value();
- if (anOldMode != theDispMode)
+ if(myMainPM->IsHighlighted (theIObj, anOldMode))
{
- aModesToRemove.Append (anOldMode);
- if(myMainPM->IsHighlighted (theIObj, anOldMode))
- {
- myMainPM->Unhighlight (theIObj, anOldMode);
- }
- myMainPM->Erase (theIObj, anOldMode);
+ unhighlightGlobal (theIObj, anOldMode);
}
+ myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
}
- for (TColStd_ListIteratorOfListOfInteger aRemModeIter (aModesToRemove); aRemModeIter.More(); aRemModeIter.Next())
- {
- aStatus->RemoveDisplayMode (aRemModeIter.Value());
- }
-
- if (!aStatus->IsDModeIn (theDispMode))
- {
- aStatus->AddDisplayMode (theDispMode);
- }
+ aStatus->SetDisplayMode (theDispMode);
myMainPM->Display (theIObj, theDispMode);
- if (aStatus->GraphicStatus() == AIS_DS_Erased)
- {
- aStatus->SetGraphicStatus (AIS_DS_Displayed);
- }
+ aStatus->SetGraphicStatus (AIS_DS_Displayed);
if (aStatus->IsHilighted())
{
const Standard_Integer aHiMod = theIObj->HasHilightMode() ? theIObj->HilightMode() : theDispMode;
- myMainPM->Highlight (theIObj, aHiMod);
+ highlightGlobal (theIObj, aStatus->HilightStyle(), aHiMod);
}
if (theSelectionMode != -1)
{
- if (!mgrSelector->Contains (theIObj))
+ const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
+ if (!mgrSelector->Contains (anObj))
{
mgrSelector->Load (theIObj);
}
if (!mgrSelector->IsActivated (theIObj, theSelectionMode))
{
+ if (!aStatus->IsSModeIn (theSelectionMode))
+ aStatus->AddSelectionMode (theSelectionMode);
mgrSelector->Activate (theIObj, theSelectionMode, myMainSel);
}
}
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
if (HasOpenedContext())
{
myLocalContexts (myCurLocalIndex)->Load (theIObj, theToAllowDecomposition, theSelMode);
}
if (theSelMode == -1
- && !theToAllowDecomposition
- && !myObjects.IsBound (theIObj))
+ && !theToAllowDecomposition)
{
- Standard_Integer aDispMode, aHiMod, aSelModeDef;
- GetDefModes (theIObj, aDispMode, aHiMod, aSelModeDef);
- Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Erased, aDispMode, aSelModeDef);
- myObjects.Bind (theIObj, aStatus);
+ if (!myObjects.IsBound (theIObj))
+ {
+ Standard_Integer aDispMode, aHiMod, aSelModeDef;
+ GetDefModes (theIObj, aDispMode, aHiMod, aSelModeDef);
+ Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Erased, aDispMode, aSelModeDef);
+ myObjects.Bind (theIObj, aStatus);
+ }
+
+ // Register theIObj in the selection manager to prepare further activation of selection
+ const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
+ if (!mgrSelector->Contains (anObj))
+ {
+ mgrSelector->Load (theIObj);
+ }
}
}
}
Standard_Boolean isFound = Standard_False;
- Handle(AIS_Selection) aSelIter = AIS_Selection::Selection (myCurrentName.ToCString());
- for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
+ for (mySelection->Init(); mySelection->More(); mySelection->Next())
{
- Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
+ Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (mySelection->Value()->Selectable());
Display (anObj, Standard_False);
isFound = Standard_True;
}
}
Standard_Boolean isFound = Standard_False;
- Handle(AIS_Selection) aSelIter = AIS_Selection::Selection(myCurrentName.ToCString());
- for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
+ mySelection->Init();
+ while (mySelection->More())
{
- Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
+ Handle(SelectMgr_EntityOwner) anOwner = mySelection->Value();
+ Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
+
Erase (anObj, Standard_False);
isFound = Standard_True;
+
+ mySelection->Init();
}
if (isFound && theToUpdateViewer)
return AIS_DS_None;
}
-//=======================================================================
-//function : DisplayedModes
-//purpose :
-//=======================================================================
-const TColStd_ListOfInteger& AIS_InteractiveContext::DisplayedModes (const Handle(AIS_InteractiveObject)& theIObj) const
-{
- return myObjects (theIObj)->DisplayedModes();
-}
-
//=======================================================================
//function : Remove
//purpose :
return;
}
+ if (theIObj->HasInteractiveContext())
+ {
+ if (theIObj->myCTXPtr != this)
+ {
+ Standard_ProgramError::Raise ("AIS_InteractiveContext - object has been displayed in another context!");
+ }
+ theIObj->SetContext (Handle(AIS_InteractiveContext)());
+ }
+
if (HasOpenedContext())
{
myLocalContexts (myCurLocalIndex)->Remove (theIObj);
}
//=======================================================================
-//function : Hilight
-//purpose :
+//function : HilightWithColor
+//purpose :
//=======================================================================
-void AIS_InteractiveContext::Hilight (const Handle(AIS_InteractiveObject)& theIObj,
- const Standard_Boolean theToUpdateViewer)
+void AIS_InteractiveContext::HilightWithColor(const Handle(AIS_InteractiveObject)& theObj,
+ const Handle(Graphic3d_HighlightStyle)& theStyle,
+ const Standard_Boolean theIsToUpdate)
{
- if (theIObj.IsNull())
- {
+ if (theObj.IsNull())
return;
- }
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
+ setContextToObject (theObj);
if (!HasOpenedContext())
{
- if (!myObjects.IsBound (theIObj))
- {
+ if (!myObjects.IsBound (theObj))
return;
- }
- Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
+ const Handle(AIS_GlobalStatus)& aStatus = myObjects (theObj);
aStatus->SetHilightStatus (Standard_True);
+
if (aStatus->GraphicStatus() == AIS_DS_Displayed)
{
- Standard_Integer aHilightMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
- myMainPM->Highlight (theIObj, aHilightMode);
+ const Standard_Integer aHilightMode = theObj->HasHilightMode() ? theObj->HilightMode() : 0;
+ highlightGlobal (theObj, theStyle, aHilightMode);
+ aStatus->SetHilightStyle (theStyle);
}
}
else
{
- myLocalContexts (myCurLocalIndex)->Hilight (theIObj);
+ myLocalContexts (myCurLocalIndex)->Hilight (theObj, theStyle);
}
- if (theToUpdateViewer)
- {
+ if (theIsToUpdate)
myMainVwr->Update();
- }
}
+
//=======================================================================
-//function : Hilight
+//function : Unhilight
//purpose :
//=======================================================================
-
-void AIS_InteractiveContext::HilightWithColor(const Handle(AIS_InteractiveObject)& anIObj,
- const Quantity_NameOfColor aCol,
- const Standard_Boolean updateviewer)
+void AIS_InteractiveContext::Unhilight(const Handle(AIS_InteractiveObject)& anIObj, const Standard_Boolean updateviewer)
{
if(anIObj.IsNull()) return;
- if(!anIObj->HasInteractiveContext()) anIObj->SetContext(this);
-
if (!HasOpenedContext())
{
if(!myObjects.IsBound(anIObj)) return;
- const Handle(AIS_GlobalStatus)& STATUS = myObjects(anIObj);
- STATUS->SetHilightStatus (Standard_True);
+ const Handle(AIS_GlobalStatus)& aStatus = myObjects(anIObj);
+ aStatus->SetHilightStatus (Standard_False);
+ aStatus->SetHilightStyle (new Graphic3d_HighlightStyle());
- if (STATUS->GraphicStatus() == AIS_DS_Displayed)
+ if (aStatus->GraphicStatus() == AIS_DS_Displayed)
{
Standard_Integer aHilightMode = anIObj->HasHilightMode() ? anIObj->HilightMode() : 0;
- myMainPM->Color (anIObj, aCol, aHilightMode);
- STATUS->SetHilightColor (aCol);
+ unhighlightGlobal (anIObj, aHilightMode);
}
}
else
{
- myLocalContexts(myCurLocalIndex)->Hilight(anIObj,aCol);
+ myLocalContexts(myCurLocalIndex)->Unhilight(anIObj);
}
if(updateviewer) myMainVwr->Update();
}
//=======================================================================
-//function : Unhilight
-//purpose :
+//function : IsHilighted
+//purpose : Returns true if the objects global status is set to highlighted.
//=======================================================================
-
-void AIS_InteractiveContext::Unhilight(const Handle(AIS_InteractiveObject)& anIObj, const Standard_Boolean updateviewer)
+Standard_Boolean AIS_InteractiveContext::IsHilighted (const Handle(AIS_InteractiveObject)& theObj) const
{
- if(anIObj.IsNull()) return;
-
if (!HasOpenedContext())
{
- if(!myObjects.IsBound(anIObj)) return;
+ if (!myObjects.IsBound (theObj))
+ return Standard_False;
- const Handle(AIS_GlobalStatus)& STATUS = myObjects(anIObj);
- STATUS->SetHilightStatus (Standard_False);
- STATUS->SetHilightColor(Quantity_NOC_WHITE);
+ return myObjects (theObj)->IsHilighted();
+ }
- if (STATUS->GraphicStatus() == AIS_DS_Displayed)
+ for (Standard_Integer aCtxIdx = HighestIndex(); aCtxIdx >= 1; aCtxIdx--)
+ {
+ if (myLocalContexts.IsBound (aCtxIdx))
{
- Standard_Integer aHilightMode = anIObj->HasHilightMode() ? anIObj->HilightMode() : 0;
- myMainPM->Unhighlight (anIObj, aHilightMode);
+ if (myLocalContexts (aCtxIdx)->IsHilighted (theObj))
+ return Standard_True;
}
}
- else
- {
- myLocalContexts(myCurLocalIndex)->Unhilight(anIObj);
- }
- if(updateviewer) myMainVwr->Update();
+
+ return Standard_False;
}
//=======================================================================
//function : IsHilighted
-//purpose :
+//purpose : Returns true if the owner is highlighted with selection style.
//=======================================================================
-
-Standard_Boolean AIS_InteractiveContext::IsHilighted(const Handle(AIS_InteractiveObject)& anIObj) const
+Standard_Boolean AIS_InteractiveContext::IsHilighted (const Handle(SelectMgr_EntityOwner)& theOwner) const
{
- if(anIObj.IsNull()) return Standard_False;
+ if (theOwner.IsNull() || !theOwner->HasSelectable())
+ return Standard_False;
+
+ const Handle(AIS_InteractiveObject) anObj =
+ Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
- if (!HasOpenedContext()){
- if(!myObjects.IsBound(anIObj))
+ if (anObj->GlobalSelOwner() == theOwner)
+ {
+ if (!myObjects.IsBound (anObj))
return Standard_False;
- return myObjects(anIObj)->IsHilighted();
- }
- AIS_DataMapIteratorOfDataMapOfILC ItM(myLocalContexts);
- for(;ItM.More();ItM.Next()){
- if(ItM.Value()->IsHilighted(anIObj))
- return Standard_True;
+
+ return myObjects (anObj)->IsHilighted();
}
- return Standard_False;
+
+ return theOwner->IsSelected();
}
-Standard_Boolean AIS_InteractiveContext::IsHilighted(const Handle(AIS_InteractiveObject)& anIObj,
- Standard_Boolean& WithColor,
- Quantity_NameOfColor& TheHiCol) const
-{
- if(!HasOpenedContext()){
- if(myObjects.IsBound(anIObj)){
- const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
- if(STAT->IsHilighted()){
- if(STAT->HilightColor()!=Quantity_NOC_WHITE){
- WithColor=Standard_True;
- TheHiCol = STAT->HilightColor();
- }
- else
- WithColor = Standard_False;
- return Standard_True;
- }
- }
- return Standard_False;
+//=======================================================================
+//function : HighlightStyle
+//purpose :
+//=======================================================================
+Standard_Boolean AIS_InteractiveContext::HighlightStyle (const Handle(AIS_InteractiveObject)& theObj,
+ Handle(Graphic3d_HighlightStyle)& theStyle) const
+{
+ if (HasOpenedContext())
+ myLocalContexts (myCurLocalIndex)->HighlightStyle (theObj, theStyle);
+
+ if (IsHilighted (theObj))
+ {
+ theStyle = myObjects (theObj)->HilightStyle();
+ return Standard_True;
}
- Standard_Integer MaxIndex = HighestIndex();
- for(Standard_Integer i=MaxIndex;i>=1 ; i--){
- if(myLocalContexts.IsBound(i)){
- if(myLocalContexts(i)->IsHilighted(anIObj,WithColor,TheHiCol))
- return Standard_True;
- }
-
+ else
+ {
+ theStyle.Nullify();
+ return Standard_False;
}
- return Standard_False;
}
+//=======================================================================
+//function : HighlightStyle
+//purpose :
+//=======================================================================
+Standard_Boolean AIS_InteractiveContext::HighlightStyle (const Handle(SelectMgr_EntityOwner)& theOwner,
+ Handle(Graphic3d_HighlightStyle)& theStyle) const
+{
+ if (theOwner.IsNull() || !theOwner->HasSelectable())
+ return Standard_False;
+ if (IsHilighted (theOwner))
+ {
+ const Handle(AIS_InteractiveObject) anObj =
+ Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
+ if (anObj->GlobalSelOwner() == theOwner)
+ {
+ theStyle = myObjects (anObj)->HilightStyle();
+ }
+ else
+ {
+ // since part selection style is not stored in global status,
+ // check if the object has own selection style. If not, it can
+ // only be highlighted with default selection style (because
+ // sub-intensity does not modify any selection states)
+ theStyle = getSelStyle (anObj);
+ }
+ return Standard_True;
+ }
+ else
+ {
+ theStyle.Nullify();
+ return Standard_False;
+ }
+}
//=======================================================================
//function : IsDisplayed
{
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
if (aStatus->GraphicStatus() == AIS_DS_Displayed
- && aStatus->IsDModeIn (theMode))
+ && aStatus->DisplayMode() == theMode)
{
return Standard_True;
}
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
if (myObjects.IsBound (theIObj))
{
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
Handle(StdSelect_ViewerSelector3d) aTempSel = myLocalContexts (myCurLocalIndex)->MainSelector();
mgrSelector->Update (theIObj, aTempSel, Standard_False);
}
+
+ // if the object or its part is highlighted dynamically, it is necessary to apply location transformation
+ // to its highlight structure immediately
+ if (!myLastPicked.IsNull() && myLastPicked->IsSameSelectable (theIObj))
+ {
+ const Standard_Integer aHiMod = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
+ myLastPicked->UpdateHighlightTrsf (myMainVwr,
+ myMainPM,
+ aHiMod);
+ }
}
//=======================================================================
//=======================================================================
void AIS_InteractiveContext::SetDeviationAngle (const Standard_Real theAngle)
{
- myDefaultDrawer->SetDeviationCoefficient (theAngle);
+ myDefaultDrawer->SetDeviationAngle (theAngle);
}
//=======================================================================
//function : SetDisplayMode
//purpose :
//=======================================================================
-void AIS_InteractiveContext::SetDisplayMode (const AIS_DisplayMode theMode,
- const Standard_Boolean theToUpdateViewer)
+void AIS_InteractiveContext::SetDisplayMode(const Standard_Integer theMode,
+ const Standard_Boolean theToUpdateViewer)
{
if (theMode == myDisplayMode)
{
}
Handle(AIS_GlobalStatus) aStatus = anObjIter.Value();
- if (aStatus->IsDModeIn (myDisplayMode))
- {
- aStatus->RemoveDisplayMode (myDisplayMode);
- }
+ aStatus->SetDisplayMode (theMode);
- aStatus->AddDisplayMode (theMode);
if (aStatus->GraphicStatus() == AIS_DS_Displayed)
{
- myMainPM->SetVisibility (anObj, myDisplayMode, Standard_False);
myMainPM->Display (anObj, theMode);
+ if (!myLastPicked.IsNull() && myLastPicked->IsSameSelectable (anObj))
+ {
+ myMainPM->BeginImmediateDraw();
+ unhighlightGlobal (anObj, myDisplayMode);
+ myMainPM->EndImmediateDraw (myMainVwr);
+ }
if (aStatus->IsSubIntensityOn())
{
- myMainPM->Color (anObj, mySubIntensity, theMode);
+ highlightWithSubintensity (anObj, theMode);
}
+ myMainPM->SetVisibility (anObj, myDisplayMode, Standard_False);
}
}
const Standard_Integer theMode,
const Standard_Boolean theToUpdateViewer)
{
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext(this);
- }
-
+ setContextToObject (theIObj);
if (!myObjects.IsBound (theIObj))
{
theIObj->SetDisplayMode (theMode);
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
if (aStatus->GraphicStatus() != AIS_DS_Displayed)
{
+ aStatus->SetDisplayMode (theMode);
theIObj->SetDisplayMode (theMode);
return;
}
// erase presentations for all display modes different from <aMode>
- TColStd_ListOfInteger aModesToRemove;
- for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
+ const Standard_Integer anOldMode = aStatus->DisplayMode();
+ if (anOldMode != theMode)
{
- const Standard_Integer anOldMode = aDispModeIter.Value();
- if (anOldMode != theMode)
+ if (myMainPM->IsHighlighted (theIObj, anOldMode))
{
- aModesToRemove.Append (anOldMode);
- if (myMainPM->IsHighlighted (theIObj, anOldMode))
- {
- myMainPM->Unhighlight (theIObj, anOldMode);
- }
- myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
+ unhighlightGlobal (theIObj, anOldMode);
}
+ myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
}
- for (TColStd_ListIteratorOfListOfInteger aRemModeIter (aModesToRemove); aRemModeIter.More(); aRemModeIter.Next())
- {
- aStatus->RemoveDisplayMode (aRemModeIter.Value());
- }
-
- if (!aStatus->IsDModeIn (theMode))
- {
- aStatus->AddDisplayMode (theMode);
- }
+ aStatus->SetDisplayMode (theMode);
myMainPM->Display (theIObj, theMode);
Standard_Integer aDispMode, aHiMode, aSelMode;
GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
if (aStatus->IsHilighted())
{
- myMainPM->Highlight (theIObj, aHiMode);
+ highlightGlobal (theIObj, getSelStyle (theIObj), aHiMode);
}
if (aStatus->IsSubIntensityOn())
{
- myMainPM->Color (theIObj, mySubIntensity, theMode);
+ highlightWithSubintensity (theIObj, theMode);
}
if (theToUpdateViewer)
}
const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
- aStatus->RemoveDisplayMode (anOldMode);
- if (!aStatus->IsDModeIn(myDisplayMode))
- {
- aStatus->AddDisplayMode (myDisplayMode);
- }
+ aStatus->SetDisplayMode (myDisplayMode);
if (aStatus->GraphicStatus() == AIS_DS_Displayed)
{
if (myMainPM->IsHighlighted (theIObj, anOldMode))
{
- myMainPM->Unhighlight (theIObj, anOldMode);
+ unhighlightGlobal (theIObj, anOldMode);
}
myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
myMainPM->Display (theIObj, myDisplayMode);
GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
if (aStatus->IsHilighted())
{
- myMainPM->Highlight (theIObj, aHiMode);
+ highlightSelected (theIObj->GlobalSelOwner());
}
if (aStatus->IsSubIntensityOn())
{
- myMainPM->Color (theIObj, mySubIntensity, myDisplayMode);
+ highlightWithSubintensity (theIObj, myDisplayMode);
}
if (theToUpdateViewer)
{
if (theIObj->RecomputeEveryPrs())
{
- theIObj->Redisplay();
+ theIObj->Update (Standard_True);
+ theIObj->UpdateSelection();
}
else
{
{
theIObj->Update (aModes.Value(), Standard_False);
}
+ theIObj->UpdateSelection();
theIObj->SetRecomputeOk();
}
{
if (theIObj->RecomputeEveryPrs())
{
- theIObj->Redisplay();
+ theIObj->Update (Standard_True);
+ theIObj->UpdateSelection();
}
else
{
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
+ setContextToObject (theIObj);
theIObj->SetColor (theColor);
redisplayPrsRecModes (theIObj, theToUpdateViewer);
}
+//=======================================================================
+//function : SetIsoOnTriangulation
+//purpose :
+//=======================================================================
+void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theIsEnabled,
+ const Handle(AIS_InteractiveObject)& theObject)
+{
+ if (theObject.IsNull())
+ {
+ return;
+ }
+
+ theObject->SetIsoOnTriangulation (theIsEnabled);
+}
+
//=======================================================================
//function : SetDeviationCoefficient
//purpose :
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// to be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Object
&& theIObj->Type() != AIS_KOI_Shape)
{
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// To be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Object
&& theIObj->Type() != AIS_KOI_Shape)
{
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// To be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Shape)
{
return;
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// To be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Shape)
{
return;
if (theIObj->RecomputeEveryPrs())
{
- theIObj->Redisplay();
+ theIObj->Update (Standard_True);
+ theIObj->UpdateSelection();
}
else
{
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// To be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Shape)
{
return;
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
// To be modified after the related methods of AIS_Shape are passed to InteractiveObject
+ setContextToObject (theIObj);
if (theIObj->Type() != AIS_KOI_Shape)
{
return;
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
theIObj->SetWidth (theWidth);
redisplayPrsRecModes (theIObj, theToUpdateViewer);
+ if (!myLastinMain.IsNull() && myLastinMain->IsSameSelectable (theIObj))
+ {
+ if (myLastinMain->IsAutoHilight())
+ {
+ const Standard_Integer aHiMode =
+ theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
+ myLastinMain->HilightWithColor (myMainPM,
+ myLastinMain->IsSelected() ? getSelStyle (theIObj) : getHiStyle (theIObj),
+ aHiMode);
+ }
+ else
+ {
+ theIObj->HilightOwnerWithColor (myMainPM,
+ myLastinMain->IsSelected() ? getSelStyle (theIObj) : getHiStyle (theIObj),
+ myLastinMain);
+ }
+ }
}
//=======================================================================
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
theIObj->SetMaterial (theName);
redisplayPrsRecModes (theIObj, theToUpdateViewer);
}
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
if (!theIObj->IsTransparent()
&& theValue <= 0.05)
{
//purpose :
//=======================================================================
void AIS_InteractiveContext::SetSelectedAspect (const Handle(Prs3d_BasicAspect)& theAspect,
- const Standard_Boolean theIsGlobalChange,
+ const Standard_Boolean ,
const Standard_Boolean theToUpdateViewer)
{
if (HasOpenedContext())
}
Standard_Boolean isFound = Standard_False;
- Handle(AIS_Selection) aSelIter = AIS_Selection::Selection (myCurrentName.ToCString());
- for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
+ for (AIS_NListOfEntityOwner::Iterator aSelIter (mySelection->Objects()); aSelIter.More(); aSelIter.Next())
{
isFound = Standard_True;
- Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
- anObj->SetAspect (theAspect, theIsGlobalChange);
+ Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter.Value()->Selectable());
+ anObj->SetAspect (theAspect);
}
- if (isFound
- && theToUpdateViewer)
+ if (isFound && theToUpdateViewer)
{
myMainVwr->Update();
}
//purpose :
//=======================================================================
void AIS_InteractiveContext::SetLocalAttributes (const Handle(AIS_InteractiveObject)& theIObj,
- const Handle(AIS_Drawer)& theDrawer,
+ const Handle(Prs3d_Drawer)& theDrawer,
const Standard_Boolean theToUpdateViewer)
{
if (theIObj.IsNull())
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
-
+ setContextToObject (theIObj);
theIObj->SetAttributes (theDrawer);
Update (theIObj, theToUpdateViewer);
}
return;
}
- if (!theIObj->HasInteractiveContext())
- {
- theIObj->SetContext (this);
- }
+ setContextToObject (theIObj);
theIObj->UnsetAttributes();
Update (theIObj, theToUpdateViewer);
}
}
theStatus += "\t| Active Display Modes in the MainViewer :\n";
- for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
- {
- theStatus += "\t|\t Mode ";
- theStatus += TCollection_AsciiString (aDispModeIter.Value());
- theStatus += "\n";
- }
- if (IsCurrent (theIObj)) theStatus +="\t| Current\n";
+ theStatus += "\t|\t Mode ";
+ theStatus += TCollection_AsciiString (aStatus->DisplayMode());
+ theStatus += "\n";
+
if (IsSelected(theIObj)) theStatus +="\t| Selected\n";
theStatus += "\t| Active Selection Modes in the MainViewer :\n";
? myDisplayMode
: 0);
theHiMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : theDispMode;
- theSelMode = theIObj->HasSelectionMode() ? theIObj->SelectionMode() : -1;
+ theSelMode = theIObj->GlobalSelectionMode();
}
//=======================================================================
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
- Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
- if (aStatus->GraphicStatus() == AIS_DS_Displayed)
+ const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
+ if (aStatus->GraphicStatus() == AIS_DS_Temporary
+ || aStatus->GraphicStatus() == AIS_DS_Erased)
{
- for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
- {
- if (myMainPM->IsHighlighted (theIObj, aDispModeIter.Value()))
- {
- myMainPM->Unhighlight (theIObj, aDispModeIter.Value());
- }
- myMainPM->SetVisibility (theIObj, aDispModeIter.Value(), Standard_False);
- }
+ return;
+ }
- if (IsCurrent (theIObj)
- && !aStatus->IsDModeIn (aDispMode))
+ if (aStatus->IsHilighted())
+ {
+ if (IsCurrent (theIObj))
{
- myMainPM->SetVisibility (theIObj, aDispMode, Standard_False);
+ AddOrRemoveCurrentObject (theIObj, Standard_False);
}
-
- for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
+ else if (myMainPM->IsHighlighted (theIObj, aStatus->DisplayMode()))
{
- mgrSelector->Deactivate (theIObj, aSelModeIter.Value(), myMainSel);
+ unhighlightGlobal (theIObj, aStatus->DisplayMode());
}
+ }
- if (theToUpdateviewer)
+ myMainPM->SetVisibility (theIObj, aStatus->DisplayMode(), Standard_False);
+
+ if (aStatus->IsHilighted()
+ && theIObj->HasHilightMode())
+ {
+ unhighlightGlobal (theIObj, aDispMode);
+ }
+
+ if (!myLastPicked.IsNull()
+ && myLastPicked->IsSameSelectable (theIObj))
+ {
+ myMainPM->ClearImmediateDraw();
+ }
+
+ if (IsSelected (theIObj)
+ && aStatus->DisplayMode() != aDispMode)
+ {
+ myMainPM->SetVisibility (theIObj, aDispMode, Standard_False);
+ }
+
+ for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
+ {
+ mgrSelector->Deactivate (theIObj, aSelModeIter.Value(), myMainSel);
+ }
+ aStatus->ClearSelectionModes();
+ aStatus->SetGraphicStatus (AIS_DS_Erased);
+
+ if (theToUpdateviewer)
+ {
+ myMainVwr->Update();
+ }
+}
+
+//=======================================================================
+//function : unhighlightOwners
+//purpose :
+//=======================================================================
+void AIS_InteractiveContext::unhighlightOwners (const Handle(AIS_InteractiveObject)& theObject)
+{
+ SelectMgr_SequenceOfOwner aSeq;
+ for (AIS_NListOfEntityOwner::Iterator aSelIter (mySelection->Objects()); aSelIter.More(); aSelIter.Next())
+ {
+ if (aSelIter.Value()->IsSameSelectable (theObject)
+ && aSelIter.Value()->IsSelected())
{
- myMainVwr->Update();
+ aSeq.Append (aSelIter.Value());
}
}
- aStatus->SetGraphicStatus (AIS_DS_Erased);
+ for (SelectMgr_SequenceOfOwner::Iterator aDelIter (aSeq); aDelIter.More(); aDelIter.Next())
+ {
+ AddOrRemoveSelected (aDelIter.Value(), Standard_False);
+ }
}
//=======================================================================
if (theIObj.IsNull()
|| !myObjects.IsBound (theIObj))
{
+ // for cases when reference shape of connected interactives was not displayed
+ // but its selection primitives were calculated
+ const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
+ mgrSelector->Remove (anObj);
return;
}
Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
- for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
- {
- if (aStatus->IsHilighted())
- {
- if (IsCurrent (theIObj))
- {
- AddOrRemoveCurrentObject (theIObj, theToUpdateviewer);
- }
- else if (myMainPM->IsHighlighted (theIObj, aDispModeIter.Value()))
- {
- myMainPM->Unhighlight (theIObj, aDispModeIter.Value());
- }
- }
- myMainPM->Erase (theIObj, aDispModeIter.Value());
- myMainPM->Clear (theIObj, aDispModeIter.Value());
- if (theIObj->HasHilightMode())
- {
- Standard_Integer im = theIObj->HilightMode();
- myMainPM->Unhighlight (theIObj, im);
- myMainPM->Erase (theIObj, im);
- }
- }
+ unhighlightOwners (theIObj);
+
+ myMainPM->Erase (theIObj, -1);
// Object removes from Detected sequence
- for(Standard_Integer aDetIter = 1; aDetIter < myAISDetectedSeq.Length(); ++aDetIter)
+ for (Standard_Integer aDetIter = myDetectedSeq.Lower(); aDetIter <= myDetectedSeq.Upper(); ++aDetIter)
{
Handle(AIS_InteractiveObject) anObj = DetectedCurrentObject();
if (!anObj.IsNull()
&& anObj != theIObj)
{
- myAISDetectedSeq.Remove (aDetIter);
+ myDetectedSeq.Remove (aDetIter);
}
}
- if (myLastinMain == theIObj)
+ // remove IO from the selection manager to avoid memory leaks
+ const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
+ mgrSelector->Remove (anObj);
+
+ myObjects.UnBind (theIObj);
+ myMainVwr->StructureManager()->UnregisterObject (theIObj);
+
+ for (V3d_ListOfViewIterator aDefViewIter (myMainVwr->DefinedViewIterator()); aDefViewIter.More(); aDefViewIter.Next())
{
- myLastinMain.Nullify();
+ aDefViewIter.Value()->View()->ChangeHiddenObjects()->Remove (theIObj.get());
}
- if (myLastPicked == theIObj)
+
+ if (!myLastinMain.IsNull())
{
- myLastPicked.Nullify();
+ if (myLastinMain->IsSameSelectable (theIObj)
+ || myLastPicked->IsSameSelectable(theIObj))
+ {
+ myLastinMain.Nullify();
+ myMainPM->ClearImmediateDraw();
+ }
}
- // remove IO from the selection manager to avoid memory leaks
- mgrSelector->Remove (theIObj);
-
- myObjects.UnBind (theIObj);
-
- if (theToUpdateviewer
- && aStatus->GraphicStatus() == AIS_DS_Displayed)
+ if (theToUpdateviewer && aStatus->GraphicStatus() == AIS_DS_Displayed)
{
myMainVwr->Update();
}
}
const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
- if (aStatus->IsDModeIn (theMode))
+ if (aStatus->DisplayMode() == theMode)
{
const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
if (aDispMode == theMode
&& myMainPM->IsHighlighted (theIObj, theMode))
{
- myMainPM->Unhighlight (theIObj, theMode);
+ unhighlightGlobal (theIObj, theMode);
}
myMainPM->Erase (theIObj, theMode);
- myMainPM->Clear (theIObj, theMode);
}
if (aStatus->GraphicStatus() == AIS_DS_Displayed
}
//=======================================================================
-//function : SetSelectionMode
+//function : IsoOnTriangulation
//purpose :
//=======================================================================
-void AIS_InteractiveContext::SetSelectionMode (const Handle(AIS_InteractiveObject)& ,
- const Standard_Integer )
+void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theToSwitchOn)
{
- //
+ myDefaultDrawer->SetIsoOnTriangulation (theToSwitchOn);
}
//=======================================================================
-//function : UnsetSelectionMode
+//function : IsoOnTriangulation
//purpose :
//=======================================================================
-void AIS_InteractiveContext::UnsetSelectionMode (const Handle(AIS_InteractiveObject)& )
+Standard_Boolean AIS_InteractiveContext::IsoOnTriangulation() const
{
- //
+ return myDefaultDrawer->IsoOnTriangulation();
}
+//function : SetPixelTolerance
+//purpose : Disables the mechanism of adaptive tolerance calculation in
+// SelectMgr_ViewerSelector and sets the given tolerance for ALL
+// sensitive entities activated. For more information, see
+// SelectMgr_ViewerSelector.hxx
//=======================================================================
-//function : SetSensitivityMode
-//purpose :
-//=======================================================================
-void AIS_InteractiveContext::SetSensitivityMode (const StdSelect_SensitivityMode theMode)
-{
- if (HasOpenedContext())
- {
- myLocalContexts (myCurLocalIndex)->SetSensitivityMode (theMode);
- }
- else
- {
- myMainSel->SetSensitivityMode (theMode);
- }
-}
-
-//=======================================================================
-//function : SensitivityMode
-//purpose :
-//=======================================================================
-StdSelect_SensitivityMode AIS_InteractiveContext::SensitivityMode() const
-{
- return HasOpenedContext()
- ? myLocalContexts (myCurLocalIndex)->SensitivityMode()
- : myMainSel->SensitivityMode();
-}
-
-//=======================================================================
-//function : SetSensitivity
-//purpose :
-//=======================================================================
-void AIS_InteractiveContext::SetSensitivity (const Standard_Real thePrecision)
+void AIS_InteractiveContext::SetPixelTolerance (const Standard_Integer thePrecision)
{
if (HasOpenedContext())
{
- myLocalContexts(myCurLocalIndex)->SetSensitivity (thePrecision);
+ myLocalContexts (myCurLocalIndex)->SetPixelTolerance (thePrecision);
}
else
{
- myMainSel->SetSensitivity (thePrecision);
+ myMainSel->SetPixelTolerance (thePrecision);
}
}
//=======================================================================
-//function : Sensitivity
+//function : PixelTolerance
//purpose :
//=======================================================================
-Standard_Real AIS_InteractiveContext::Sensitivity() const
+Standard_Integer AIS_InteractiveContext::PixelTolerance() const
{
return HasOpenedContext()
- ? myLocalContexts(myCurLocalIndex)->Sensitivity()
- : myMainSel->Sensitivity();
+ ? myLocalContexts (myCurLocalIndex)->PixelTolerance()
+ : myMainSel->PixelTolerance();
}
//=======================================================================
-//function : SetPixelTolerance
-//purpose :
+//function : SetSelectionSensitivity
+//purpose : Allows to manage sensitivity of a particular selection of interactive object theObject
//=======================================================================
-void AIS_InteractiveContext::SetPixelTolerance (const Standard_Integer thePrecision)
+void AIS_InteractiveContext::SetSelectionSensitivity (const Handle(AIS_InteractiveObject)& theObject,
+ const Standard_Integer theMode,
+ const Standard_Integer theNewSensitivity)
{
if (HasOpenedContext())
{
- myLocalContexts (myCurLocalIndex)->SetPixelTolerance (thePrecision);
- }
- else
- {
- myMainSel->SetPixelTolerance (thePrecision);
+ myLocalContexts (myCurLocalIndex)->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
+ return;
}
-}
-//=======================================================================
-//function : PixelTolerance
-//purpose :
-//=======================================================================
-Standard_Integer AIS_InteractiveContext::PixelTolerance() const
-{
- return HasOpenedContext()
- ? myLocalContexts (myCurLocalIndex)->PixelTolerance()
- : myMainSel->PixelTolerance();
+ mgrSelector->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
}
//=======================================================================
void AIS_InteractiveContext::InitAttributes()
{
mgrSelector->Add (myMainSel);
- myCurrentName = AIS_Context_NewCurName();
- mySelectionName = AIS_Context_NewSelName();
- AIS_Selection::CreateSelection (mySelectionName.ToCString());
- AIS_Selection::CreateSelection (myCurrentName.ToCString());
-
- myDefaultDrawer->SetShadingAspectGlobal (Standard_False);
Graphic3d_MaterialAspect aMat (Graphic3d_NOM_BRASS);
myDefaultDrawer->ShadingAspect()->SetMaterial (aMat);
aLineAspect->SetWidth (1.0);
aLineAspect->SetTypeOfLine (Aspect_TOL_DASH);
- // tolerance to 4 pixels...
- SetPixelTolerance();
+ // tolerance to 2 pixels...
+ SetPixelTolerance (2);
// Customizing the drawer for trihedrons and planes...
Handle(Prs3d_DatumAspect) aTrihAspect = myDefaultDrawer->DatumAspect();
if (theIObj.IsNull())
return;
- if (myObjects.IsBound (theIObj))
+ theIObj->SetZLayer (theLayerId);
+}
+
+//=======================================================================
+//function : GetZLayer
+//purpose :
+//=======================================================================
+Standard_Integer AIS_InteractiveContext::GetZLayer (const Handle(AIS_InteractiveObject)& theIObj) const
+{
+ return !theIObj.IsNull()
+ ? theIObj->ZLayer()
+ : Graphic3d_ZLayerId_UNKNOWN;
+}
+
+//=======================================================================
+//function : RebuildSelectionStructs
+//purpose : Rebuilds 1st level of BVH selection forcibly
+//=======================================================================
+void AIS_InteractiveContext::RebuildSelectionStructs()
+{
+ myMainSel->RebuildObjectsTree (Standard_True);
+}
+
+//=======================================================================
+//function : Disconnect
+//purpose : Disconnects selectable object from an assembly and updates selection structures
+//=======================================================================
+void AIS_InteractiveContext::Disconnect (const Handle(AIS_InteractiveObject)& theAssembly,
+ const Handle(AIS_InteractiveObject)& theObjToDisconnect)
+{
+ if (theAssembly->IsInstance ("AIS_MultipleConnectedInteractive"))
+ {
+ Handle(AIS_MultipleConnectedInteractive) theObj (Handle(AIS_MultipleConnectedInteractive)::DownCast (theAssembly));
+ theObj->Disconnect (theObjToDisconnect);
+ const Handle(SelectMgr_SelectableObject)& anObj = theObjToDisconnect; // to avoid ambiguity
+ mgrSelector->Remove (anObj);
+ }
+ else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect.IsNull())
{
- if (myObjects (theIObj)->GraphicStatus() == AIS_DS_Displayed || myObjects (theIObj)->GraphicStatus() == AIS_DS_Erased)
+ Handle(AIS_ConnectedInteractive) theObj (Handle(AIS_ConnectedInteractive)::DownCast (theAssembly));
+ theObj->Disconnect();
+ const Handle(SelectMgr_SelectableObject)& anObj = theObj; // to avoid ambiguity
+ mgrSelector->Remove (anObj);
+ }
+ else
+ return;
+}
+
+//=======================================================================
+//function : FitSelected
+//purpose : Fits the view corresponding to the bounds of selected objects
+//=======================================================================
+void AIS_InteractiveContext::FitSelected (const Handle(V3d_View)& theView,
+ const Standard_Real theMargin,
+ const Standard_Boolean theToUpdate)
+{
+ const Handle(AIS_Selection)& aSelection = HasOpenedContext() ?
+ myLocalContexts(myCurLocalIndex)->Selection() : mySelection;
+
+ Bnd_Box aBndSelected;
+
+ AIS_MapOfObjectOwners anObjectOwnerMap;
+ for (aSelection->Init(); aSelection->More(); aSelection->Next())
+ {
+ const Handle(SelectMgr_EntityOwner)& anOwner = aSelection->Value();
+ Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast(anOwner->Selectable());
+ if (anObj->IsInfinite())
+ {
+ continue;
+ }
+
+ if (anOwner == anObj->GlobalSelOwner())
{
- theIObj->SetZLayer (myMainPM, theLayerId);
+ Bnd_Box aTmpBnd;
+ anObj->BoundingBox (aTmpBnd);
+ aBndSelected.Add (aTmpBnd);
+ }
+ else
+ {
+ Handle(SelectMgr_IndexedMapOfOwner) anOwnerMap;
+ if (!anObjectOwnerMap.Find (anOwner->Selectable(), anOwnerMap))
+ {
+ anOwnerMap = new SelectMgr_IndexedMapOfOwner();
+ anObjectOwnerMap.Bind (anOwner->Selectable(), anOwnerMap);
+ }
+
+ anOwnerMap->Add (anOwner);
}
}
- else if (HasOpenedContext())
+
+ for (AIS_MapIteratorOfMapOfObjectOwners anIter (anObjectOwnerMap); anIter.More(); anIter.Next())
{
- myLocalContexts (myCurLocalIndex)->SetZLayer (theIObj, theLayerId);
+ const Handle(SelectMgr_SelectableObject) anObject = anIter.Key();
+ Bnd_Box aTmpBox = anObject->BndBoxOfSelected (anIter.ChangeValue());
+ aBndSelected.Add (aTmpBox);
}
+
+ anObjectOwnerMap.Clear();
+
+ if (aBndSelected.IsVoid())
+ return;
+
+ theView->FitAll (aBndSelected, theMargin, theToUpdate);
}
//=======================================================================
-//function : GetZLayer
+//function : SetTransformPersistence
//purpose :
//=======================================================================
-Standard_Integer AIS_InteractiveContext::GetZLayer (const Handle(AIS_InteractiveObject)& theIObj) const
+void AIS_InteractiveContext::SetTransformPersistence (const Handle(AIS_InteractiveObject)& theObject,
+ const Handle(Graphic3d_TransformPers)& theTrsfPers)
{
- if (theIObj.IsNull())
- return -1;
-
- if (myObjects.IsBound (theIObj))
+ theObject->SetTransformPersistence (theTrsfPers);
+ if (!myObjects.IsBound (theObject))
{
- return theIObj->GetZLayer (myMainPM);
+ return;
}
- else if (HasOpenedContext())
+
+ mgrSelector->UpdateSelection (theObject);
+
+ const Standard_Integer aLayerId = myObjects.Find (theObject)->GetLayerIndex();
+ const Handle(V3d_Viewer)& aCurViewer = CurrentViewer();
+ for (V3d_ListOfViewIterator anActiveViewIter (aCurViewer->ActiveViewIterator()); anActiveViewIter.More(); anActiveViewIter.Next())
{
- return myLocalContexts (myCurLocalIndex)->GetZLayer (theIObj);
+ anActiveViewIter.Value()->View()->InvalidateBVHData (aLayerId);
+ anActiveViewIter.Value()->View()->InvalidateZLayerBoundingBox (aLayerId);
}
-
- return -1;
}
projects / occt.git / blobdiff