[occt.git] / src / PrsMgr / PrsMgr_PresentationManager.cxx

// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <PrsMgr_PresentationManager.ixx>
#include <PrsMgr_PresentableObject.hxx>
#include <PrsMgr_Presentation.hxx>
#include <PrsMgr_Presentations.hxx>
#include <PrsMgr_ModedPresentation.hxx>
#include <TColStd_ListIteratorOfListOfTransient.hxx>


PrsMgr_PresentationManager::PrsMgr_PresentationManager ():
myImmediateMode(Standard_False){}


void PrsMgr_PresentationManager::Display(
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode) 
{
  if (!HasPresentation(aPresentableObject,aMode)){
    AddPresentation(aPresentableObject,aMode);
  }
  else if(Presentation(aPresentableObject,aMode)->MustBeUpdated()){
    Update(aPresentableObject,aMode);
  }
  
  if(myImmediateMode)
    Add(aPresentableObject,aMode);
  else
    Presentation(aPresentableObject,aMode)->Display();
}

void PrsMgr_PresentationManager::Erase(
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode) 
{
  if (HasPresentation(aPresentableObject,aMode))
  {
    if(myImmediateMode)
    {
      Remove(aPresentableObject,aMode);
    }
    else
    {
     Presentation(aPresentableObject,aMode)->Erase();
    }

    RemovePresentation (aPresentableObject,aMode);
  }
}

void PrsMgr_PresentationManager::Clear(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
				       const Standard_Integer aMode) 
{
  if (HasPresentation(aPresentableObject,aMode)){
    if(myImmediateMode)
      Remove(aPresentableObject,aMode);
    else
      Presentation(aPresentableObject,aMode)->Clear();}
}

void PrsMgr_PresentationManager::SetVisibility (const Handle(PrsMgr_PresentableObject)& thePresentableObject,
                                                const Standard_Integer theMode,
                                                const Standard_Boolean theValue)
{
  Presentation(thePresentableObject, theMode)->SetVisible (theValue);
}

void PrsMgr_PresentationManager::Highlight(
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode)
{
  if (!HasPresentation(aPresentableObject,aMode)){
    AddPresentation(aPresentableObject,aMode);
  }
  else if(Presentation(aPresentableObject,aMode)->MustBeUpdated()){
    Update(aPresentableObject,aMode);
  }
  Presentation(aPresentableObject,aMode)->Highlight();

  if(myImmediateMode)
    Add(aPresentableObject,aMode);
}

void PrsMgr_PresentationManager::Unhighlight(
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode) 
{
  if (HasPresentation(aPresentableObject,aMode)){
    Presentation(aPresentableObject,aMode)->Unhighlight();
    if(myImmediateMode)
      Remove(aPresentableObject,aMode);
  }
}


void PrsMgr_PresentationManager::
SetDisplayPriority(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
		   const Standard_Integer aMode,
		   const Standard_Integer theNewPrior) const 
{
  if (HasPresentation(aPresentableObject,aMode))
    Presentation(aPresentableObject,aMode)->SetDisplayPriority(theNewPrior);
}

Standard_Integer PrsMgr_PresentationManager::
DisplayPriority(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
		const Standard_Integer aMode) const 
{
  if (HasPresentation(aPresentableObject,aMode))
    return Presentation(aPresentableObject,aMode)->DisplayPriority();
  
  return 0;
}


Standard_Boolean PrsMgr_PresentationManager::IsDisplayed (    
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode) const {
     if (HasPresentation(aPresentableObject,aMode))
       return Presentation(aPresentableObject,aMode)->IsDisplayed();
     return Standard_False;
    }

Standard_Boolean PrsMgr_PresentationManager::IsHighlighted (    
    const Handle(PrsMgr_PresentableObject)& aPresentableObject,
    const Standard_Integer aMode) const {
          if (HasPresentation(aPresentableObject,aMode))
       return Presentation(aPresentableObject,aMode)->IsHighlighted();
     return Standard_False;
    }

void PrsMgr_PresentationManager::Update (const Handle(PrsMgr_PresentableObject)& aPresentableObject,const Standard_Integer aMode ) const {
  if(HasPresentation(aPresentableObject,aMode)) {
    Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
    if (!P.IsNull()) {
      P->Clear();
      aPresentableObject->Fill(this,P,aMode);
      P->SetUpdateStatus(Standard_False);
    }
  }
}
void PrsMgr_PresentationManager::BeginDraw() {
  myImmediateMode = Standard_True;
  myImmediateList.Clear();
}


void PrsMgr_PresentationManager::Add(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
				     const Standard_Integer aMode) {
  if (myImmediateMode ) {
    Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
    for (TColStd_ListIteratorOfListOfTransient it(myImmediateList);it.More();it.Next()){
      if(it.Value()==P) return;
    }
    myImmediateList.Append(P);
  }
}
void PrsMgr_PresentationManager::Remove(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
				     const Standard_Integer aMode) {
  if (myImmediateMode ) {
    Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
    for (TColStd_ListIteratorOfListOfTransient it(myImmediateList);it.More();it.Next()){
      if(it.Value()==P) {
	myImmediateList.Remove(it);
	return;
      }
    }
  }
}


Standard_Boolean PrsMgr_PresentationManager::HasPresentation
    (const Handle(PrsMgr_PresentableObject)& aPresentableObject,
     const Standard_Integer aMode) const {

       const PrsMgr_Presentations& S = aPresentableObject->Presentations();
       Standard_Boolean found = Standard_False;
       Standard_Integer i=1; Standard_Integer l= S.Length();
       while (i<= l && !found) {
// modif WOK++ : operator == is ambiguous 
//	 found =  aMode == S(i).Mode()
//	          && this == S(i).Presentation()->PresentationManager();
	 const Handle (PrsMgr_Presentation)& popPrs = S(i).Presentation();
	 const Handle (PrsMgr_PresentationManager)& popPrsMgr = popPrs->PresentationManager();
	 if ( aMode == S(i).Mode() && this == popPrsMgr ) 
	   found = Standard_True;
	 i++;
       }
       return found;
     }

Handle (PrsMgr_Presentation) 
     PrsMgr_PresentationManager::Presentation(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
					      const Standard_Integer aMode) const 
{
  Handle(PrsMgr_Presentation) P;
  const PrsMgr_Presentations& S  = aPresentableObject->Presentations();
  Standard_Boolean found = Standard_False;
  Standard_Integer i=1; Standard_Integer l= S.Length();
  while (i<= l && !found) {
    P =  S(i).Presentation();
    const Handle (PrsMgr_PresentationManager)& popPrsMgr = P->PresentationManager();
    if (aMode == S(i).Mode() && this ==  popPrsMgr) {
      found = Standard_True;


    }
    i++;
  }

  return P;
}

void PrsMgr_PresentationManager::AddPresentation
           (const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	    const Standard_Integer aMode) {

    Handle(PrsMgr_Presentation) P = newPresentation(aPresentableObject);
    aPresentableObject->Presentations().Append(PrsMgr_ModedPresentation(P,aMode));
    aPresentableObject->Fill(this,P,aMode);

    // set layer index accordingly to object's presentations
    Standard_Integer aZLayerId = GetZLayer (aPresentableObject);
    if (aZLayerId >= 0)
      P->SetZLayer (aZLayerId);

    P->SetUpdateStatus(Standard_False);
}

void PrsMgr_PresentationManager::RemovePresentation(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
                                                    const Standard_Integer aMode)
{
  PrsMgr_Presentations& S = aPresentableObject->Presentations();
  Standard_Integer i = 1; 
  Standard_Integer n = S.Length();
  while (i<= n) {
    if (aMode == S(i).Mode()) {
      S.Remove(i);
      break;
    }
    i++;
  }
}

//=======================================================================
//function : SetZLayer
//purpose  :
//=======================================================================

void PrsMgr_PresentationManager::SetZLayer 
  (const Handle(PrsMgr_PresentableObject)& thePresentableObject,
   const Standard_Integer theLayerId)
{
  PrsMgr_Presentations& aPresentations = thePresentableObject->Presentations();
  for (Standard_Integer aIdx = 1; aIdx <= aPresentations.Length (); aIdx++)
  {
    Handle(PrsMgr_Presentation) aPrs = aPresentations (aIdx).Presentation ();
    if (aPrs->PresentationManager () == this)
      aPrs->SetZLayer (theLayerId);
  }
}

//=======================================================================
//function : GetZLayer
//purpose  :
//=======================================================================

Standard_Integer PrsMgr_PresentationManager::GetZLayer 
  (const Handle(PrsMgr_PresentableObject)& thePresentableObject) const
{
  PrsMgr_Presentations& aPresentations = thePresentableObject->Presentations();
  for (Standard_Integer aIdx = 1; aIdx <= aPresentations.Length (); aIdx++)
  {
    Handle(PrsMgr_Presentation) aPrs = aPresentations (aIdx).Presentation ();
    if (aPrs->PresentationManager () == this)
      return aPrs->GetZLayer ();
  }
  
  return -1;
}
Commit	Line	Data
b311480e	1	// Copyright (c) 1998-1999 Matra Datavision
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
b311480e	5	//
d5f74e42	6	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	7	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
b311480e	14
7fd59977	15	#include <PrsMgr_PresentationManager.ixx>
	16	#include <PrsMgr_PresentableObject.hxx>
	17	#include <PrsMgr_Presentation.hxx>
	18	#include <PrsMgr_Presentations.hxx>
	19	#include <PrsMgr_ModedPresentation.hxx>
	20	#include <TColStd_ListIteratorOfListOfTransient.hxx>
	21
	22
	23	PrsMgr_PresentationManager::PrsMgr_PresentationManager ():
	24	myImmediateMode(Standard_False){}
	25
	26
	27	void PrsMgr_PresentationManager::Display(
	28	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	29	const Standard_Integer aMode)
	30	{
	31	if (!HasPresentation(aPresentableObject,aMode)){
	32	AddPresentation(aPresentableObject,aMode);
	33	}
	34	else if(Presentation(aPresentableObject,aMode)->MustBeUpdated()){
	35	Update(aPresentableObject,aMode);
	36	}
	37
	38	if(myImmediateMode)
	39	Add(aPresentableObject,aMode);
	40	else
	41	Presentation(aPresentableObject,aMode)->Display();
	42	}
	43
	44	void PrsMgr_PresentationManager::Erase(
	45	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	46	const Standard_Integer aMode)
	47	{
eef7fc64	48	if (HasPresentation(aPresentableObject,aMode))
eef7fc64	49	{
7fd59977	50	if(myImmediateMode)
eef7fc64	51	{
7fd59977	52	Remove(aPresentableObject,aMode);
eef7fc64	53	}
7fd59977	54	else
eef7fc64	55	{
	56	Presentation(aPresentableObject,aMode)->Erase();
	57	}
	58
	59	RemovePresentation (aPresentableObject,aMode);
	60	}
7fd59977	61	}
	62
	63	void PrsMgr_PresentationManager::Clear(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	64	const Standard_Integer aMode)
	65	{
	66	if (HasPresentation(aPresentableObject,aMode)){
	67	if(myImmediateMode)
	68	Remove(aPresentableObject,aMode);
	69	else
	70	Presentation(aPresentableObject,aMode)->Clear();}
	71	}
	72
eb4320f2	73	void PrsMgr_PresentationManager::SetVisibility (const Handle(PrsMgr_PresentableObject)& thePresentableObject,
	74	const Standard_Integer theMode,
	75	const Standard_Boolean theValue)
	76	{
	77	Presentation(thePresentableObject, theMode)->SetVisible (theValue);
	78	}
7fd59977	79
	80	void PrsMgr_PresentationManager::Highlight(
	81	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	82	const Standard_Integer aMode)
	83	{
	84	if (!HasPresentation(aPresentableObject,aMode)){
	85	AddPresentation(aPresentableObject,aMode);
	86	}
	87	else if(Presentation(aPresentableObject,aMode)->MustBeUpdated()){
	88	Update(aPresentableObject,aMode);
	89	}
	90	Presentation(aPresentableObject,aMode)->Highlight();
	91
	92	if(myImmediateMode)
	93	Add(aPresentableObject,aMode);
	94	}
	95
	96	void PrsMgr_PresentationManager::Unhighlight(
	97	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	98	const Standard_Integer aMode)
	99	{
	100	if (HasPresentation(aPresentableObject,aMode)){
	101	Presentation(aPresentableObject,aMode)->Unhighlight();
	102	if(myImmediateMode)
	103	Remove(aPresentableObject,aMode);
	104	}
	105	}
	106
	107
	108	void PrsMgr_PresentationManager::
	109	SetDisplayPriority(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	110	const Standard_Integer aMode,
	111	const Standard_Integer theNewPrior) const
	112	{
	113	if (HasPresentation(aPresentableObject,aMode))
	114	Presentation(aPresentableObject,aMode)->SetDisplayPriority(theNewPrior);
	115	}
	116
	117	Standard_Integer PrsMgr_PresentationManager::
	118	DisplayPriority(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	119	const Standard_Integer aMode) const
	120	{
	121	if (HasPresentation(aPresentableObject,aMode))
	122	return Presentation(aPresentableObject,aMode)->DisplayPriority();
	123
	124	return 0;
	125	}
	126
	127
	128	Standard_Boolean PrsMgr_PresentationManager::IsDisplayed (
	129	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	130	const Standard_Integer aMode) const {
	131	if (HasPresentation(aPresentableObject,aMode))
	132	return Presentation(aPresentableObject,aMode)->IsDisplayed();
	133	return Standard_False;
	134	}
	135
	136	Standard_Boolean PrsMgr_PresentationManager::IsHighlighted (
	137	const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	138	const Standard_Integer aMode) const {
	139	if (HasPresentation(aPresentableObject,aMode))
	140	return Presentation(aPresentableObject,aMode)->IsHighlighted();
	141	return Standard_False;
	142	}
143
144	void PrsMgr_PresentationManager::Update (const Handle(PrsMgr_PresentableObject)& aPresentableObject,const Standard_Integer aMode ) const {
145	if(HasPresentation(aPresentableObject,aMode)) {
146	Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
147	if (!P.IsNull()) {
148	P->Clear();
149	aPresentableObject->Fill(this,P,aMode);
150	P->SetUpdateStatus(Standard_False);
151	}
152	}
153	}
154	void PrsMgr_PresentationManager::BeginDraw() {
155	myImmediateMode = Standard_True;
156	myImmediateList.Clear();
157	}
158
159
160	void PrsMgr_PresentationManager::Add(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
161	const Standard_Integer aMode) {
162	if (myImmediateMode ) {
163	Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
164	for (TColStd_ListIteratorOfListOfTransient it(myImmediateList);it.More();it.Next()){
165	if(it.Value()==P) return;
166	}
167	myImmediateList.Append(P);
168	}
169	}
170	void PrsMgr_PresentationManager::Remove(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
171	const Standard_Integer aMode) {
172	if (myImmediateMode ) {
173	Handle(PrsMgr_Presentation) P = Presentation(aPresentableObject,aMode);
174	for (TColStd_ListIteratorOfListOfTransient it(myImmediateList);it.More();it.Next()){
175	if(it.Value()==P) {
176	myImmediateList.Remove(it);
177	return;
178	}
179	}
180	}
181	}
182
183
184
185
186	Standard_Boolean PrsMgr_PresentationManager::HasPresentation
187	(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
188	const Standard_Integer aMode) const {
189
190	const PrsMgr_Presentations& S = aPresentableObject->Presentations();
191	Standard_Boolean found = Standard_False;
192	Standard_Integer i=1; Standard_Integer l= S.Length();
193	while (i<= l && !found) {
194	// modif WOK++ : operator == is ambiguous
195	// found = aMode == S(i).Mode()
196	// && this == S(i).Presentation()->PresentationManager();
197	const Handle (PrsMgr_Presentation)& popPrs = S(i).Presentation();
198	const Handle (PrsMgr_PresentationManager)& popPrsMgr = popPrs->PresentationManager();
199	if ( aMode == S(i).Mode() && this == popPrsMgr )
200	found = Standard_True;
201	i++;
202	}
203	return found;
204	}
205
206	Handle (PrsMgr_Presentation)
207	PrsMgr_PresentationManager::Presentation(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
208	const Standard_Integer aMode) const
209	{
210	Handle(PrsMgr_Presentation) P;
211	const PrsMgr_Presentations& S = aPresentableObject->Presentations();
212	Standard_Boolean found = Standard_False;
213	Standard_Integer i=1; Standard_Integer l= S.Length();
214	while (i<= l && !found) {
215	P = S(i).Presentation();
216	const Handle (PrsMgr_PresentationManager)& popPrsMgr = P->PresentationManager();
217	if (aMode == S(i).Mode() && this == popPrsMgr) {
218	found = Standard_True;
219
220
221	}
222	i++;
223	}
224
225	return P;
226	}
227
228	void PrsMgr_PresentationManager::AddPresentation
229	(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
230	const Standard_Integer aMode) {
231
232	Handle(PrsMgr_Presentation) P = newPresentation(aPresentableObject);
233	aPresentableObject->Presentations().Append(PrsMgr_ModedPresentation(P,aMode));
234	aPresentableObject->Fill(this,P,aMode);
59f45b7c	235
	236	// set layer index accordingly to object's presentations
	237	Standard_Integer aZLayerId = GetZLayer (aPresentableObject);
	238	if (aZLayerId >= 0)
	239	P->SetZLayer (aZLayerId);
	240
7fd59977	241	P->SetUpdateStatus(Standard_False);
	242	}
	243
	244	void PrsMgr_PresentationManager::RemovePresentation(const Handle(PrsMgr_PresentableObject)& aPresentableObject,
	245	const Standard_Integer aMode)
	246	{
	247	PrsMgr_Presentations& S = aPresentableObject->Presentations();
	248	Standard_Integer i = 1;
	249	Standard_Integer n = S.Length();
	250	while (i<= n) {
	251	if (aMode == S(i).Mode()) {
	252	S.Remove(i);
	253	break;
	254	}
	255	i++;
	256	}
	257	}
	258
59f45b7c	259	//=======================================================================
	260	//function : SetZLayer
	261	//purpose :
	262	//=======================================================================
	263
	264	void PrsMgr_PresentationManager::SetZLayer
	265	(const Handle(PrsMgr_PresentableObject)& thePresentableObject,
	266	const Standard_Integer theLayerId)
	267	{
	268	PrsMgr_Presentations& aPresentations = thePresentableObject->Presentations();
	269	for (Standard_Integer aIdx = 1; aIdx <= aPresentations.Length (); aIdx++)
	270	{
	271	Handle(PrsMgr_Presentation) aPrs = aPresentations (aIdx).Presentation ();
	272	if (aPrs->PresentationManager () == this)
	273	aPrs->SetZLayer (theLayerId);
	274	}
	275	}
	276
	277	//=======================================================================
	278	//function : GetZLayer
	279	//purpose :
	280	//=======================================================================
	281
	282	Standard_Integer PrsMgr_PresentationManager::GetZLayer
	283	(const Handle(PrsMgr_PresentableObject)& thePresentableObject) const
	284	{
	285	PrsMgr_Presentations& aPresentations = thePresentableObject->Presentations();
	286	for (Standard_Integer aIdx = 1; aIdx <= aPresentations.Length (); aIdx++)
	287	{
	288	Handle(PrsMgr_Presentation) aPrs = aPresentations (aIdx).Presentation ();
	289	if (aPrs->PresentationManager () == this)
	290	return aPrs->GetZLayer ();
	291	}
	292
	293	return -1;
	294	}