[occt.git] / src / Graphic3d / Graphic3d_StructureManager.cxx


#define XTRACE

// File         Graphic3d_StructureManager.cxx
// Created      Mars 1992
// Author       NW,JPB,CAL

//-Copyright    MatraDatavision 1991,1992

//-Version      

//-Design       Declaration of variables specific to managers

//-Warning      Manager manages a set of structures

//-References   

//-Language     C++ 2.0

//-Declarations

// for the class
#include <Graphic3d_StructureManager.ixx>
#include <Graphic3d_StructureManager.pxx>
static Standard_Boolean Initialisation = Standard_True;
static int StructureManager_ArrayId[StructureManager_MAX];
static Standard_Integer StructureManager_CurrentId = 0;

#include <Graphic3d_Structure.pxx>
#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>

//-Aliases

//-Global data definitions

//      -- l'identifieur du manager
//      MyId                    :       Standard_Integer;

//      -- le mode de mise a jour de l'affichage
//      MyUpdateMode            :       TypeOfUpdate;

//      -- les differents contextes de primitives
//      MyAspectLine3d          :       AspectLine3d;
//      MyAspectText3d          :       AspectText3d;
//      MyAspectMarker3d        :       AspectMarker3d;
//      MyAspectFillArea3d      :       AspectFillArea3d;

//      -- les structures affichees
//      MyDisplayedStructure    :       SequenceOfStructure;

//      -- les structures mises en evidence
//      MyHighlightedStructure  :       SequenceOfStructure;

//      -- les structures visibles
//      MyVisibleStructure      :       SequenceOfStructure;

//      -- les structures detectables
//      MyPickStructure         :       SequenceOfStructure;

//      -- le generateur d'identificateurs de structures
//      MyStructGenId           :       GenId;

//-Constructors

Graphic3d_StructureManager::Graphic3d_StructureManager (const Handle(Aspect_GraphicDevice)& aDevice):
MyDisplayedStructure (),
MyHighlightedStructure (),
MyVisibleStructure (),
MyPickStructure () {

Standard_Real Coef;
Standard_Integer i;
Standard_Boolean NotFound       = Standard_True;
Standard_Integer Limit  = Graphic3d_StructureManager::Limit ();

        /* Initialize PHIGS and start up */
        if (Initialisation) {

                Initialisation = Standard_False;
                /* table to manage IDs of StructureManager */
                for (i=1; i<=Limit; i++) StructureManager_ArrayId[i]    = 0;

                StructureManager_CurrentId      = 1;
                StructureManager_ArrayId[1]     = 1;

        }
        else {
                for (i=1; i<=Limit && NotFound; i++)
                        if (StructureManager_ArrayId[i] == 0) {
                                NotFound        = Standard_False;
                                StructureManager_CurrentId      = i;
                                StructureManager_ArrayId[i]     = 1;
                        }

                if (NotFound)
                        Graphic3d_InitialisationError::Raise
                                        ("Too many ViewManagers are defined");
        }

        Coef            = (Structure_IDMIN+Structure_IDMAX)/Limit;
        Aspect_GenId theGenId(
          Standard_Integer (Structure_IDMIN+Coef*(StructureManager_CurrentId-1)),
          Standard_Integer (Structure_IDMIN+Coef*StructureManager_CurrentId-1));
        MyStructGenId   = theGenId;

        MyId                    = StructureManager_CurrentId;

        MyAspectLine3d          = new Graphic3d_AspectLine3d ();
        MyAspectText3d          = new Graphic3d_AspectText3d ();
        MyAspectMarker3d        = new Graphic3d_AspectMarker3d ();
        MyAspectFillArea3d      = new Graphic3d_AspectFillArea3d ();

        MyUpdateMode            = Aspect_TOU_WAIT;
        MyGraphicDevice         = aDevice;

}

//-Destructors

void Graphic3d_StructureManager::Destroy () {

#ifdef TRACE
        cout << "Graphic3d_StructureManager::Destroy (" << MyId << ")\n";
        cout << flush;
#endif

        MyDisplayedStructure.Clear ();
        MyHighlightedStructure.Clear ();
        MyVisibleStructure.Clear ();
        MyPickStructure.Clear ();
        StructureManager_ArrayId[MyId]  = 0;

}

//-Methods, in order

void Graphic3d_StructureManager::SetUpdateMode (const Aspect_TypeOfUpdate AType) {

        MyUpdateMode    = AType;

}

Aspect_TypeOfUpdate Graphic3d_StructureManager::UpdateMode () const {

        return (MyUpdateMode);

}

void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) {

        MyAspectLine3d          = CTX;

}

void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) {

        MyAspectFillArea3d      = CTX;

}

void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) {

        MyAspectText3d          = CTX;

}

void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) {

        MyAspectMarker3d        = CTX;

}

void Graphic3d_StructureManager::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const {

        CTXL    = MyAspectLine3d;
        CTXT    = MyAspectText3d;
        CTXM    = MyAspectMarker3d;
        CTXF    = MyAspectFillArea3d;

}

Handle(Graphic3d_AspectLine3d) Graphic3d_StructureManager::Line3dAspect () const {

        return (MyAspectLine3d);

}

Handle(Graphic3d_AspectText3d) Graphic3d_StructureManager::Text3dAspect () const {

        return (MyAspectText3d);

}

Handle(Graphic3d_AspectMarker3d) Graphic3d_StructureManager::Marker3dAspect () const {

        return (MyAspectMarker3d);

}

Handle(Graphic3d_AspectFillArea3d) Graphic3d_StructureManager::FillArea3dAspect () const {

        return (MyAspectFillArea3d);

}

void Graphic3d_StructureManager::Remove (const Standard_Integer AnId) {

#ifdef TRACE
        cout << "Graphic3d_StructureManager::Remove " << AnId << "\n" << flush;
#endif

        MyStructGenId.Free (AnId);

}

void Graphic3d_StructureManager::Visible (const Handle(Graphic3d_Structure)& AStructure) {

  MyVisibleStructure.Add(AStructure);

}

void Graphic3d_StructureManager::Invisible (const Handle(Graphic3d_Structure)& AStructure) {

  MyVisibleStructure.Remove(AStructure);
 
}

void Graphic3d_StructureManager::Detectable (const Handle(Graphic3d_Structure)& AStructure) {

  MyPickStructure.Add(AStructure);

}

void Graphic3d_StructureManager::Undetectable (const Handle(Graphic3d_Structure)& AStructure) {

  MyPickStructure.Remove(AStructure);
 
}

void Graphic3d_StructureManager::DisplayedStructures (Graphic3d_MapOfStructure& SG) const {

  SG.Assign(MyDisplayedStructure);

  //JMBStandard_Integer Length  = MyDisplayedStructure.Length ();

  //JMBfor (Standard_Integer i=1; i<=Length; i++)
  //JMB SG.Add (MyDisplayedStructure.Value (i));

}

Standard_Integer Graphic3d_StructureManager::NumberOfDisplayedStructures () const {

Standard_Integer Length = MyDisplayedStructure.Extent ();

        return (Length);

}

//Handle(Graphic3d_Structure) Graphic3d_StructureManager::DisplayedStructure (const Standard_Integer AnIndex) const {

//return (MyDisplayedStructure.Value (AnIndex));

//}

void Graphic3d_StructureManager::HighlightedStructures (Graphic3d_MapOfStructure& SG) const {

  SG.Assign(MyHighlightedStructure);

}

void Graphic3d_StructureManager::PickStructures (Graphic3d_MapOfStructure& SG) const {

  SG.Assign(MyPickStructure);

}

void Graphic3d_StructureManager::VisibleStructures (Graphic3d_MapOfStructure& SG) const {

  SG.Assign(MyVisibleStructure);


}

void Graphic3d_StructureManager::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {

Standard_Boolean Flag = Standard_True;
Standard_Real Xm, Ym, Zm, XM, YM, ZM, RL, RF;

        RL = RealLast ();
        RF = RealFirst ();

        XMin = YMin = ZMin = RL;
        XMax = YMax = ZMax = RF;

        Graphic3d_MapIteratorOfMapOfStructure it(MyDisplayedStructure);
        for (; it.More(); it.Next()) {
          Handle(Graphic3d_Structure) SG = it.Key();
          if (! (SG->IsEmpty() || SG->IsInfinite ())) {
            SG->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
            if (Xm < XMin) XMin = Xm;
            if (Ym < YMin) YMin = Ym;
            if (Zm < ZMin) ZMin = Zm;
            if (XM > XMax) XMax = XM;
            if (YM > YMax) YMax = YM;
            if (ZM > ZMax) ZMax = ZM;
            Flag = Standard_False;
          }
        }

        // If all structures are empty or infinite
        if (Flag) {
          XMin = YMin = ZMin = RF;
          XMax = YMax = ZMax = RL;
        }
 
}
 
Standard_Integer Graphic3d_StructureManager::NewIdentification () {

Standard_Integer Id     = MyStructGenId.Next ();

#ifdef TRACE
        cout << "Graphic3d_StructureManager::NewIdentification " << Id << "\n";
        cout << flush;
#endif

        return Id;

}

Handle(Graphic3d_Structure) Graphic3d_StructureManager::Identification (const Standard_Integer AId) const {

//  Standard_Integer ind=0;
  Standard_Boolean notfound     = Standard_True;

  Handle(Graphic3d_Structure) StructNull;
 
  Graphic3d_MapIteratorOfMapOfStructure it( MyDisplayedStructure);
  
  Handle(Graphic3d_Structure) SGfound;

  for (; it.More() && notfound; it.Next()) {
    Handle(Graphic3d_Structure) SG = it.Key();
    if ( SG->Identification () == AId) {
      notfound  = Standard_False;
      SGfound = SG;
    }
  }


  if (notfound)
    return (StructNull);
  else
    return (SGfound);

}

Standard_Integer Graphic3d_StructureManager::Identification () const {
 
        return (MyId);
 
}

Standard_Integer Graphic3d_StructureManager::Limit () {

        return (StructureManager_MAX);

}

Standard_Integer Graphic3d_StructureManager::CurrentId () {

        return (StructureManager_CurrentId);

}

Handle(Aspect_GraphicDevice) Graphic3d_StructureManager::GraphicDevice () const {

        return (MyGraphicDevice);

}
Commit	Line	Data
7fd59977	1
	2	#define XTRACE
	3
	4	// File Graphic3d_StructureManager.cxx
	5	// Created Mars 1992
	6	// Author NW,JPB,CAL
	7
	8	//-Copyright MatraDatavision 1991,1992
	9
	10	//-Version
	11
81bba717	12	//-Design Declaration of variables specific to managers
7fd59977	13
81bba717	14	//-Warning Manager manages a set of structures
7fd59977	15
	16	//-References
	17
	18	//-Language C++ 2.0
	19
	20	//-Declarations
	21
	22	// for the class
	23	#include <Graphic3d_StructureManager.ixx>
	24	#include <Graphic3d_StructureManager.pxx>
	25	static Standard_Boolean Initialisation = Standard_True;
	26	static int StructureManager_ArrayId[StructureManager_MAX];
	27	static Standard_Integer StructureManager_CurrentId = 0;
	28
	29	#include <Graphic3d_Structure.pxx>
	30	#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
	31
	32	//-Aliases
	33
	34	//-Global data definitions
	35
	36	// -- l'identifieur du manager
	37	// MyId : Standard_Integer;
	38
	39	// -- le mode de mise a jour de l'affichage
	40	// MyUpdateMode : TypeOfUpdate;
	41
	42	// -- les differents contextes de primitives
	43	// MyAspectLine3d : AspectLine3d;
	44	// MyAspectText3d : AspectText3d;
	45	// MyAspectMarker3d : AspectMarker3d;
	46	// MyAspectFillArea3d : AspectFillArea3d;
	47
	48	// -- les structures affichees
	49	// MyDisplayedStructure : SequenceOfStructure;
	50
	51	// -- les structures mises en evidence
	52	// MyHighlightedStructure : SequenceOfStructure;
	53
	54	// -- les structures visibles
	55	// MyVisibleStructure : SequenceOfStructure;
	56
	57	// -- les structures detectables
	58	// MyPickStructure : SequenceOfStructure;
	59
	60	// -- le generateur d'identificateurs de structures
	61	// MyStructGenId : GenId;
	62
	63	//-Constructors
	64
	65	Graphic3d_StructureManager::Graphic3d_StructureManager (const Handle(Aspect_GraphicDevice)& aDevice):
	66	MyDisplayedStructure (),
	67	MyHighlightedStructure (),
	68	MyVisibleStructure (),
	69	MyPickStructure () {
	70
	71	Standard_Real Coef;
	72	Standard_Integer i;
	73	Standard_Boolean NotFound = Standard_True;
	74	Standard_Integer Limit = Graphic3d_StructureManager::Limit ();
	75
	76	/* Initialize PHIGS and start up */
	77	if (Initialisation) {
	78
79	Initialisation = Standard_False;
81bba717	80	/* table to manage IDs of StructureManager */
7fd59977	81	for (i=1; i<=Limit; i++) StructureManager_ArrayId[i] = 0;
	82
	83	StructureManager_CurrentId = 1;
	84	StructureManager_ArrayId[1] = 1;
	85
	86	}
	87	else {
	88	for (i=1; i<=Limit && NotFound; i++)
	89	if (StructureManager_ArrayId[i] == 0) {
	90	NotFound = Standard_False;
	91	StructureManager_CurrentId = i;
	92	StructureManager_ArrayId[i] = 1;
	93	}
	94
	95	if (NotFound)
	96	Graphic3d_InitialisationError::Raise
	97	("Too many ViewManagers are defined");
	98	}
	99
	100	Coef = (Structure_IDMIN+Structure_IDMAX)/Limit;
	101	Aspect_GenId theGenId(
	102	Standard_Integer (Structure_IDMIN+Coef*(StructureManager_CurrentId-1)),
	103	Standard_Integer (Structure_IDMIN+Coef*StructureManager_CurrentId-1));
	104	MyStructGenId = theGenId;
	105
	106	MyId = StructureManager_CurrentId;
	107
	108	MyAspectLine3d = new Graphic3d_AspectLine3d ();
	109	MyAspectText3d = new Graphic3d_AspectText3d ();
	110	MyAspectMarker3d = new Graphic3d_AspectMarker3d ();
	111	MyAspectFillArea3d = new Graphic3d_AspectFillArea3d ();
	112
	113	MyUpdateMode = Aspect_TOU_WAIT;
	114	MyGraphicDevice = aDevice;
	115
	116	}
	117
	118	//-Destructors
	119
	120	void Graphic3d_StructureManager::Destroy () {
	121
	122	#ifdef TRACE
	123	cout << "Graphic3d_StructureManager::Destroy (" << MyId << ")\n";
	124	cout << flush;
	125	#endif
	126
	127	MyDisplayedStructure.Clear ();
	128	MyHighlightedStructure.Clear ();
	129	MyVisibleStructure.Clear ();
	130	MyPickStructure.Clear ();
	131	StructureManager_ArrayId[MyId] = 0;
	132
	133	}
	134
	135	//-Methods, in order
	136
	137	void Graphic3d_StructureManager::SetUpdateMode (const Aspect_TypeOfUpdate AType) {
	138
	139	MyUpdateMode = AType;
	140
	141	}
	142
	143	Aspect_TypeOfUpdate Graphic3d_StructureManager::UpdateMode () const {
	144
145	return (MyUpdateMode);
146
147	}
148
149	void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) {
150
151	MyAspectLine3d = CTX;
152
153	}
154
155	void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) {
156
157	MyAspectFillArea3d = CTX;
158
159	}
160
161	void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) {
162
163	MyAspectText3d = CTX;
164
165	}
166
167	void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) {
168
169	MyAspectMarker3d = CTX;
170
171	}
172
173	void Graphic3d_StructureManager::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const {
174
175	CTXL = MyAspectLine3d;
176	CTXT = MyAspectText3d;
177	CTXM = MyAspectMarker3d;
178	CTXF = MyAspectFillArea3d;
179
180	}
181
182	Handle(Graphic3d_AspectLine3d) Graphic3d_StructureManager::Line3dAspect () const {
183
184	return (MyAspectLine3d);
185
186	}
187
188	Handle(Graphic3d_AspectText3d) Graphic3d_StructureManager::Text3dAspect () const {
189
190	return (MyAspectText3d);
191
192	}
193
194	Handle(Graphic3d_AspectMarker3d) Graphic3d_StructureManager::Marker3dAspect () const {
195
196	return (MyAspectMarker3d);
197
198	}
199
200	Handle(Graphic3d_AspectFillArea3d) Graphic3d_StructureManager::FillArea3dAspect () const {
201
202	return (MyAspectFillArea3d);
203
204	}
205
206	void Graphic3d_StructureManager::Remove (const Standard_Integer AnId) {
207
208	#ifdef TRACE
209	cout << "Graphic3d_StructureManager::Remove " << AnId << "\n" << flush;
210	#endif
211
212	MyStructGenId.Free (AnId);
213
214	}
215
216	void Graphic3d_StructureManager::Visible (const Handle(Graphic3d_Structure)& AStructure) {
217
218	MyVisibleStructure.Add(AStructure);
219
220	}
221
222	void Graphic3d_StructureManager::Invisible (const Handle(Graphic3d_Structure)& AStructure) {
223
224	MyVisibleStructure.Remove(AStructure);
225
226	}
227
228	void Graphic3d_StructureManager::Detectable (const Handle(Graphic3d_Structure)& AStructure) {
229
230	MyPickStructure.Add(AStructure);
231
232	}
233
234	void Graphic3d_StructureManager::Undetectable (const Handle(Graphic3d_Structure)& AStructure) {
235
236	MyPickStructure.Remove(AStructure);
237
238	}
239
240	void Graphic3d_StructureManager::DisplayedStructures (Graphic3d_MapOfStructure& SG) const {
241
242	SG.Assign(MyDisplayedStructure);
243
244	//JMBStandard_Integer Length = MyDisplayedStructure.Length ();
245
246	//JMBfor (Standard_Integer i=1; i<=Length; i++)
247	//JMB SG.Add (MyDisplayedStructure.Value (i));
248
249	}
250
251	Standard_Integer Graphic3d_StructureManager::NumberOfDisplayedStructures () const {
252
253	Standard_Integer Length = MyDisplayedStructure.Extent ();
254
255	return (Length);
256
257	}
258
259	//Handle(Graphic3d_Structure) Graphic3d_StructureManager::DisplayedStructure (const Standard_Integer AnIndex) const {
260
261	//return (MyDisplayedStructure.Value (AnIndex));
262
263	//}
264
265	void Graphic3d_StructureManager::HighlightedStructures (Graphic3d_MapOfStructure& SG) const {
266
267	SG.Assign(MyHighlightedStructure);
268
269	}
270
271	void Graphic3d_StructureManager::PickStructures (Graphic3d_MapOfStructure& SG) const {
272
273	SG.Assign(MyPickStructure);
274
275	}
276
277	void Graphic3d_StructureManager::VisibleStructures (Graphic3d_MapOfStructure& SG) const {
278
279	SG.Assign(MyVisibleStructure);
280
281
282	}
283
284	void Graphic3d_StructureManager::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
285
286	Standard_Boolean Flag = Standard_True;
287	Standard_Real Xm, Ym, Zm, XM, YM, ZM, RL, RF;
288
289	RL = RealLast ();
290	RF = RealFirst ();
291
292	XMin = YMin = ZMin = RL;
293	XMax = YMax = ZMax = RF;
294
295	Graphic3d_MapIteratorOfMapOfStructure it(MyDisplayedStructure);
296	for (; it.More(); it.Next()) {
297	Handle(Graphic3d_Structure) SG = it.Key();
298	if (! (SG->IsEmpty() \|\| SG->IsInfinite ())) {
299	SG->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
300	if (Xm < XMin) XMin = Xm;
301	if (Ym < YMin) YMin = Ym;
302	if (Zm < ZMin) ZMin = Zm;
303	if (XM > XMax) XMax = XM;
304	if (YM > YMax) YMax = YM;
305	if (ZM > ZMax) ZMax = ZM;
306	Flag = Standard_False;
307	}
308	}
309
81bba717	310	// If all structures are empty or infinite
7fd59977	311	if (Flag) {
	312	XMin = YMin = ZMin = RF;
	313	XMax = YMax = ZMax = RL;
	314	}
	315
	316	}
	317
	318	Standard_Integer Graphic3d_StructureManager::NewIdentification () {
	319
	320	Standard_Integer Id = MyStructGenId.Next ();
	321
	322	#ifdef TRACE
	323	cout << "Graphic3d_StructureManager::NewIdentification " << Id << "\n";
	324	cout << flush;
	325	#endif
	326
	327	return Id;
	328
	329	}
	330
	331	Handle(Graphic3d_Structure) Graphic3d_StructureManager::Identification (const Standard_Integer AId) const {
	332
	333	// Standard_Integer ind=0;
	334	Standard_Boolean notfound = Standard_True;
	335
	336	Handle(Graphic3d_Structure) StructNull;
	337
	338	Graphic3d_MapIteratorOfMapOfStructure it( MyDisplayedStructure);
	339
	340	Handle(Graphic3d_Structure) SGfound;
	341
	342	for (; it.More() && notfound; it.Next()) {
	343	Handle(Graphic3d_Structure) SG = it.Key();
	344	if ( SG->Identification () == AId) {
	345	notfound = Standard_False;
	346	SGfound = SG;
	347	}
	348	}
	349
	350
	351	if (notfound)
	352	return (StructNull);
	353	else
	354	return (SGfound);
	355
	356	}
	357
	358	Standard_Integer Graphic3d_StructureManager::Identification () const {
	359
	360	return (MyId);
	361
	362	}
	363
	364	Standard_Integer Graphic3d_StructureManager::Limit () {
	365
	366	return (StructureManager_MAX);
	367
	368	}
	369
	370	Standard_Integer Graphic3d_StructureManager::CurrentId () {
	371
	372	return (StructureManager_CurrentId);
	373
	374	}
375
376	Handle(Aspect_GraphicDevice) Graphic3d_StructureManager::GraphicDevice () const {
377
378	return (MyGraphicDevice);
379
380	}