Branch data Line data Source code
1 : : //-- File: RefGroup.cc
2 : :
3 : : #include <stdio.h>
4 : : #include <string.h>
5 : : #include <assert.h>
6 : :
7 : : #include "RefGroup.hpp"
8 : : #include "CubitObservable.hpp"
9 : : #include "CubitBox.hpp"
10 : : #include "DLIList.hpp"
11 : : #include "CastTo.hpp"
12 : : #include "GeometryQueryTool.hpp"
13 : : #include "RefEntityFactory.hpp"
14 : : #include "AppUtil.hpp"
15 : : #include "GeometryEvent.hpp"
16 : :
17 [ + - ][ + - ]: 280 : RefGroup::RefGroup( const char* name, int id)
18 : : {
19 : 140 : recursionMark = 0;
20 : :
21 [ + - ]: 140 : if( id == 0 )
22 [ + - ][ + - ]: 140 : entityId = RefEntityFactory::instance()->next_ref_group_id();
23 : : else
24 : 0 : entityId = id;
25 : :
26 : : // assign default names
27 [ + - ]: 140 : assign_default_name();
28 : :
29 [ + + ]: 140 : if (name != NULL)
30 [ + - ][ + - ]: 11 : entity_name( name );
[ + - ]
31 : 140 : }
32 : :
33 [ # # ][ # # ]: 0 : RefGroup::RefGroup (DLIList<RefEntity*>& entity_list)
34 : : {
35 : 0 : recursionMark = 0;
36 : : //entityList = entity_list;
37 : : int i;
38 [ # # ][ # # ]: 0 : for ( i = entity_list.size(); i > 0; i-- )
39 : : {
40 [ # # ]: 0 : RefEntity *ent_ptr = entity_list.get_and_step();
41 [ # # ][ # # ]: 0 : if ( !entityList.move_to(ent_ptr) )
42 [ # # ]: 0 : entityList.append(ent_ptr);
43 : : }
44 [ # # ]: 0 : entityList.reset();
45 [ # # ][ # # ]: 0 : for (i=entityList.size(); i > 0; i--)
46 [ # # ][ # # ]: 0 : register_observable(entityList.get_and_step());
[ # # ]
47 : :
48 [ # # ][ # # ]: 0 : entityId = RefEntityFactory::instance()->next_ref_group_id();
49 : :
50 : : // Notify Model about the creation of this object
51 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, this)) ;
[ # # ][ # # ]
52 : :
53 : : // assign default names
54 [ # # ]: 0 : assign_default_name();
55 : :
56 : 0 : }
57 : :
58 [ # # ][ # # ]: 0 : RefGroup::RefGroup(int /*proe_type*/)
59 : : {
60 : : // This constructor was created just to get around not doing a notify,
61 : : // so we can use it for Pro/E parts and assemblies.
62 : 0 : recursionMark = 0;
63 : 0 : }
64 : :
65 [ + - ][ + - ]: 297 : RefGroup::~RefGroup ()
66 : : {
67 [ + - ]: 99 : remove_all_ref_entities();
68 [ - + ]: 198 : }
69 : :
70 : 8502 : CubitStatus RefGroup::add_ref_entity(RefEntity *ref_entity, bool emit_event)
71 : : {
72 : 8502 : CubitStatus status = CUBIT_FAILURE;
73 : :
74 : : // Force failure of commands like: group 3 add group 3
75 [ + - ][ + - ]: 17092 : if ( ( ref_entity->entity_type_info() == entity_type_info() ) &&
[ + - ][ + + ]
[ - + ][ - + ]
76 [ + - ][ + - ]: 8590 : ( ref_entity->entity_name() == entity_name() ) )
[ + - ][ + + ]
[ + - ][ + + ]
[ # # # # ]
77 : 0 : return CUBIT_FAILURE;
78 : :
79 [ + - ]: 8502 : if (!entityList.move_to(ref_entity))
80 : : {
81 : 8502 : entityList.append(ref_entity);
82 [ + - ]: 8502 : register_observable(ref_entity);
83 : 8502 : status = CUBIT_SUCCESS;
84 [ - + ]: 8502 : if (emit_event)
85 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GROUP_MODIFIED, this));
86 : : }
87 : 8502 : return status;
88 : : }
89 : :
90 : 33 : CubitStatus RefGroup::add_ref_entity(DLIList<RefEntity*>& entity_list,
91 : : bool emit_event)
92 : : {
93 : 33 : RefEntity* entity = NULL;
94 : 33 : CubitStatus status = CUBIT_FAILURE;
95 [ + - ][ + + ]: 4235 : for (int i=entity_list.size(); i > 0; i--)
96 : : {
97 [ + - ]: 4202 : entity = entity_list.get_and_step();
98 [ + - ][ + - ]: 4202 : if ( entityList.move_to(entity) == CUBIT_FALSE )
99 : : {
100 [ + - ]: 4202 : entityList.append(entity);
101 [ + - ][ + - ]: 4202 : register_observable(entity);
102 : 4202 : status = CUBIT_SUCCESS;
103 : : }
104 : : }
105 : :
106 [ - + ][ # # ]: 33 : if (emit_event && status == CUBIT_SUCCESS)
107 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GROUP_MODIFIED, this));
[ # # ][ # # ]
108 : :
109 : 33 : return status;
110 : : }
111 : :
112 : 737 : CubitStatus RefGroup::remove_ref_entity(RefEntity *entity,
113 : : bool emit_event)
114 : : {
115 : 737 : CubitStatus status = CUBIT_FAILURE;
116 [ + - ]: 737 : if (entityList.remove(entity)) {
117 [ + - ]: 737 : unregister_observable(entity);
118 : 737 : status = CUBIT_SUCCESS;
119 [ - + ]: 737 : if (emit_event)
120 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GROUP_MODIFIED, this));
121 : : }
122 : 737 : return status;
123 : : }
124 : :
125 : 0 : CubitStatus RefGroup::remove_ref_entity(DLIList<RefEntity*> &entity_list,
126 : : bool emit_event)
127 : : {
128 : :
129 : : int i;
130 : : RefEntity *entity;
131 : 0 : CubitStatus status = CUBIT_FAILURE;
132 [ # # ][ # # ]: 0 : for (i = entity_list.size(); i > 0; i--) {
133 [ # # ]: 0 : entity = entity_list.get_and_step();
134 [ # # ][ # # ]: 0 : if (entityList.remove(entity)) {
135 [ # # ][ # # ]: 0 : unregister_observable(entity);
136 : 0 : status = CUBIT_SUCCESS;
137 : : }
138 : : }
139 : :
140 [ # # ][ # # ]: 0 : if (emit_event && status == CUBIT_SUCCESS)
141 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GROUP_MODIFIED, this));
[ # # ][ # # ]
142 : :
143 : 0 : return status;
144 : : }
145 : :
146 : 231 : int RefGroup::remove_all_ref_entities()
147 : : {
148 : 231 : int num_entities = entityList.size();
149 [ + + ]: 12188 : for (int i=entityList.size(); i > 0; i--) {
150 [ + - ]: 11957 : unregister_observable(entityList.get_and_step());
151 : : }
152 : 231 : entityList.clean_out();
153 : 231 : return num_entities;
154 : : }
155 : :
156 : 121 : void RefGroup::get_child_ref_entities(DLIList<RefEntity*>& entity_list)
157 : : {
158 : 121 : entityList.reset();
159 : 121 : entity_list.merge_unique(entityList, CUBIT_TRUE );
160 : 121 : }
161 : :
162 : 0 : int RefGroup::get_num_child_ref_entities_by_type(const std::type_info &entity_type)
163 : : {
164 : 0 : int count = 0;
165 : 0 : int size = entityList.size();
166 [ # # ]: 0 : for(int i=0; i<size; i++)
167 : : {
168 : 0 : RefEntity *cur_ent = entityList[i];
169 [ # # ]: 0 : if(cur_ent->entity_type_info() == entity_type)
170 : 0 : count++;
171 : : }
172 : 0 : return count;
173 : : }
174 : :
175 : 0 : RefEntity* RefGroup::get_child_ref_entity_by_index(const std::type_info& entity_type, int index)
176 : : {
177 : 0 : RefEntity *entity = NULL;
178 : 0 : int size = entityList.size();
179 : 0 : int type_index = 0;
180 [ # # ][ # # ]: 0 : for(int i=0; i<size && !entity; i++)
181 : : {
182 : 0 : RefEntity *cur_ent = entityList[i];
183 [ # # ]: 0 : if(cur_ent->entity_type_info() == entity_type)
184 : : {
185 [ # # ]: 0 : if(type_index == index)
186 : 0 : entity = cur_ent;
187 : : else
188 : 0 : type_index++;
189 : : }
190 : : }
191 : 0 : return entity;
192 : : }
193 : :
194 : 132 : void RefGroup::get_child_entities(DLIList<CubitEntity*>& cub_entity_list)
195 : : {
196 : 132 : cub_entity_list.casting_merge_unique(entityList, CUBIT_TRUE);
197 : 132 : }
198 : :
199 : 0 : void RefGroup::expand_group( DLIList<RefEntity*> & entity_list )
200 : : {
201 : : //This function will get the list of child entities for this group and
202 : : //if there are any groups in its child list, it will call this fucntion
203 : : //again on those groups. The end result should be that the returned
204 : : //list does not contain groups... just basic_topology entities
205 : : //(the other ref_entities)
206 [ # # ][ # # ]: 0 : DLIList<RefEntity*> group_list, mixed_list;
[ # # ]
207 : : RefEntity *ref_entity_ptr;
208 : : RefGroup *group;
209 [ # # ]: 0 : mixed_list.append( this );
210 : :
211 : : // don't swap the upper and lower bounds on ii.
212 [ # # ][ # # ]: 0 : for ( int ii = 0; ii < mixed_list.size(); ii++ )
213 : : {
214 : : //Note, the list gets added to, so don't do a simple get_and_step
215 [ # # ]: 0 : mixed_list.reset();
216 [ # # ]: 0 : mixed_list.step(ii);
217 [ # # ]: 0 : ref_entity_ptr = mixed_list.get();
218 : :
219 [ # # ]: 0 : group = CAST_TO( ref_entity_ptr, RefGroup );
220 [ # # ]: 0 : if (group)
221 : : {
222 : : // avoid infinite recursion of groups A and B containing each other
223 [ # # ][ # # ]: 0 : if (!group_list.move_to(group)) {
224 [ # # ]: 0 : group->get_child_ref_entities(mixed_list);
225 [ # # ]: 0 : group_list.append(group);
226 : : }
227 : : }
228 : : // In the future if we have other RefEntities that are grouping
229 : : // entities then we should have another statement here...
230 : : else
231 [ # # ]: 0 : entity_list.append( ref_entity_ptr );
232 : : }
233 : :
234 [ # # ]: 0 : return;
235 : : }
236 : :
237 : 0 : void RefGroup::get_parent_ref_entities(DLIList<RefEntity*>&)
238 : : {
239 : : //- appends all ref entities that own this to entity_list.
240 : : //- Goes up just one dimension.
241 : : // There is nothing above us. Do nothing
242 : 0 : }
243 : :
244 : 0 : int RefGroup::maximum_dimension()
245 : : {
246 : 0 : recursionMark = 1;
247 : : // This routine returns the maximum dimension of its owned subentities.
248 : : // The 'only' kludge is that if one of its subentities is a RefGroup, it
249 : : // must call 'maximum_dimension' on that entity instead of dimension().
250 : :
251 : : RefEntity *entity;
252 : 0 : int test_dim = 0;
253 : 0 : int dimension = 0;
254 : :
255 [ # # ]: 0 : for (int i = entityList.size(); i > 0; i--)
256 : : {
257 : 0 : entity = entityList.get_and_step();
258 : : RefGroup* group;
259 [ # # ][ # # ]: 0 : if ( (group = CAST_TO(entity,RefGroup) ) != NULL )
260 : : {
261 [ # # ]: 0 : if (group->recursionMark == 0)
262 : 0 : test_dim = group->maximum_dimension();
263 : : }
264 : : else
265 : : {
266 : 0 : test_dim = entity->dimension();
267 : : }
268 [ # # ]: 0 : dimension = CUBIT_MAX(dimension, test_dim);
269 : : }
270 : 0 : recursionMark = 0;
271 : 0 : return dimension;
272 : : }
273 : :
274 : 0 : CubitBox RefGroup::bounding_box()
275 : : {
276 : 0 : recursionMark = 1;
277 : :
278 : 0 : CubitBox super_box = CubitBox();
279 : 0 : int super_box_defined = CUBIT_FALSE;
280 : :
281 [ # # ][ # # ]: 0 : for (int i = entityList.size(); i > 0; i--) {
282 : :
283 [ # # ]: 0 : RefEntity *entity = entityList.get_and_step();
284 [ # # ]: 0 : RefGroup *group = CAST_TO(entity, RefGroup);
285 [ # # ][ # # ]: 0 : if (!group || group->recursionMark == 0) {
286 [ # # ]: 0 : CubitBox entity_box = entity->bounding_box();
287 : :
288 : : // "Concatenate" this box with the super_box, creating a bounding
289 : : // box that bounds the entities (from the list), processed so far.
290 [ # # ]: 0 : if (super_box_defined)
291 [ # # ]: 0 : super_box |= entity_box;
292 : : else {
293 [ # # ]: 0 : super_box = entity_box;
294 : 0 : super_box_defined = CUBIT_TRUE;
295 [ # # ]: 0 : }
296 : : }
297 : : }
298 : 0 : recursionMark = 0;
299 : :
300 : 0 : return super_box;
301 : : }
302 : :
303 : 11 : void RefGroup::get_sub_entities(DLIList<RefEntity*> &entity_list)
304 : : {
305 : 11 : recursionMark = 1;
306 : :
307 : : //- appends all ref entities owned by this entity on entity_list
308 : : //- and recurses all the way down to dimension 0
309 [ + - ]: 11 : DLIList<RefEntity*> local_entity_list;
310 [ + - ]: 11 : get_child_ref_entities(local_entity_list);
311 : :
312 : : // *need* to merge now if a group
313 : : // else more efficient to merge later
314 [ + - ]: 11 : entity_list.merge_unique(local_entity_list, CUBIT_TRUE);
315 [ + - ][ + - ]: 22 : DLIList<RefEntity*> temp_list, temp_list2;
[ + - ][ + - ]
316 : :
317 : :
318 [ + - ][ + + ]: 22 : for (int i=local_entity_list.size(); i > 0; i--) {
319 : : // take some care to avoid infinite recursion
320 [ + - ]: 11 : RefEntity *child = local_entity_list.get_and_step();
321 [ - + ]: 11 : RefGroup *group = CAST_TO(child, RefGroup);
322 [ - + ][ # # ]: 11 : if (!group || group->recursionMark == 0) {
323 [ + - ]: 11 : temp_list2.clean_out();
324 [ + - ]: 11 : child->get_all_child_ref_entities(temp_list2);
325 [ + - ]: 11 : temp_list.merge_unique(temp_list2);
326 : : }
327 : : }
328 : :
329 [ + - ]: 11 : entity_list.merge_unique(temp_list);
330 [ + - ]: 11 : recursionMark = 0;
331 : 11 : }
332 : :
333 : 0 : void RefGroup::is_mergeable(AutoMergeStatus val)
334 : : {
335 : 0 : recursionMark = 1;
336 : 0 : autoMergeStatus = val;
337 [ # # ]: 0 : DLIList<RefEntity*> children;
338 [ # # ]: 0 : get_child_ref_entities( children );
339 [ # # ][ # # ]: 0 : for ( int i = children.size(); i > 0; i-- ) {
340 [ # # ]: 0 : RefEntity *child = children.get_and_step();
341 [ # # ]: 0 : RefGroup *group = CAST_TO(child, RefGroup);
342 [ # # ][ # # ]: 0 : if (!group || group->recursionMark == 0)
343 [ # # ]: 0 : child->is_mergeable(val);
344 : : }
345 [ # # ]: 0 : recursionMark = 0;
346 : 0 : }
347 : :
348 : 0 : CubitVector RefGroup::center_point()
349 [ # # ]: 0 : { return bounding_box().center(); }
350 : :
351 : :
352 : 11 : int RefGroup::subtract(RefGroup *group_to_subtract, RefGroup *target_group)
353 : : {
354 : : // Get the list of RefEntities associated with each group
355 [ + - ]: 11 : DLIList<RefEntity*> final_list;
356 [ + - ][ + - ]: 22 : DLIList<RefEntity*> entity_list_2;
357 : :
358 [ + - ]: 11 : get_child_ref_entities(final_list);
359 [ + - ]: 11 : group_to_subtract->get_child_ref_entities(entity_list_2);
360 : :
361 : : // At this point, we have three groups, all non-null. Note that
362 : : // some or all of these may be the same group, so don't destroy
363 : : // the target group until all information is generated.
364 : :
365 : : // 1. Final = group 2
366 : : // 2. Remove from final all items that are in both final and group 1
367 [ + - ][ + + ]: 1760 : for (int i=entity_list_2.size(); i > 0; i--) {
368 [ + - ]: 1749 : RefEntity *entity = entity_list_2.get_and_step();
369 [ + - ]: 1749 : final_list.remove(entity);
370 : : }
371 : :
372 [ + - ]: 11 : target_group->remove_all_ref_entities();
373 [ + - ]: 11 : target_group->add_ref_entity(final_list);
374 : :
375 [ + - ]: 11 : return CUBIT_SUCCESS;
376 : : }
377 : :
378 : 11 : int RefGroup::intersect(RefGroup *other_group, RefGroup *target_group)
379 : : {
380 : : // Get the list of RefEntities associated with each group
381 [ + - ]: 11 : DLIList<RefEntity*> entity_list_1;
382 [ + - ][ + - ]: 22 : DLIList<RefEntity*> entity_list_2;
383 : :
384 [ + - ]: 11 : get_child_ref_entities(entity_list_1);
385 [ + - ]: 11 : other_group->get_child_ref_entities(entity_list_2);
386 : :
387 [ + - ][ + - ]: 22 : DLIList<RefEntity*> final_list;
388 : :
389 : : // At this point, we have three groups, all non-null. Note that
390 : : // some or all of these may be the same group, so don't destroy
391 : : // the target group until all information is generated.
392 : :
393 : : // Final = all items in both group 1 and group 2.
394 [ + - ][ + + ]: 1760 : for (int i=entity_list_2.size(); i > 0; i--) {
395 [ + - ]: 1749 : RefEntity *entity = entity_list_2.get_and_step();
396 [ + - ][ + - ]: 1749 : if (entity_list_1.move_to(entity)) {
397 [ + - ]: 1749 : final_list.append_unique(entity);
398 : : }
399 : : }
400 : :
401 [ + - ]: 11 : target_group->remove_all_ref_entities();
402 [ + - ]: 11 : target_group->add_ref_entity(final_list);
403 : :
404 [ + - ]: 11 : return CUBIT_SUCCESS;
405 : : }
406 : :
407 : 11 : int RefGroup::unite(RefGroup *other_group, RefGroup *target_group)
408 : : {
409 : : // Get the list of RefEntities associated with each group
410 [ + - ]: 11 : DLIList<RefEntity*> final_list;
411 [ + - ][ + - ]: 22 : DLIList<RefEntity*> entity_list_2;
412 : :
413 [ + - ]: 11 : get_child_ref_entities(final_list);
414 [ + - ]: 11 : other_group->get_child_ref_entities(entity_list_2);
415 : :
416 : : // At this point, we have three groups, all non-null. Note that
417 : : // some or all of these may be the same group, so don't destroy
418 : : // the target group until all information is generated.
419 : :
420 : : // 1. Final = group 1
421 : : // 2. Add all items that are in group 2, but not already in group 1
422 [ + - ][ + + ]: 22 : for (int i=entity_list_2.size(); i > 0; i--) {
423 [ + - ]: 11 : RefEntity *entity = entity_list_2.get_and_step();
424 [ + - ]: 11 : final_list.append_unique(entity);
425 : : }
426 : :
427 [ + - ]: 11 : target_group->remove_all_ref_entities();
428 [ + - ]: 11 : target_group->add_ref_entity(final_list);
429 : :
430 [ + - ]: 11 : return CUBIT_SUCCESS;
431 : : }
432 : :
433 : 0 : int RefGroup::validate()
434 : : {
435 : : // NOTE: RefGroup::validate() should not call RefEntity::validate()
436 : : // directly since the contained entities will make that
437 : : // call in their respective validate() functions.
438 : :
439 : 0 : recursionMark = 1;
440 : 0 : int error = 0;
441 [ # # ]: 0 : for (int i = entityList.size(); i > 0; i--) {
442 : 0 : RefEntity *entity = entityList.get_and_step();
443 [ # # ]: 0 : RefGroup *group = CAST_TO(entity, RefGroup);
444 [ # # ][ # # ]: 0 : if (!group || group->recursionMark == 0)
445 : 0 : error += entity->validate();
446 : : }
447 : 0 : recursionMark = 0;
448 : 0 : return error;
449 : : }
450 : :
451 : 99 : CubitStatus RefGroup::delete_group(RefGroup *group_ptr, CubitBoolean propagate)
452 : : {
453 : : // This function will delete the corresponding group from the Model
454 : : // If propagate is CUBIT_TRUE, the contained groups are deleted also.
455 : :
456 [ + - ][ + - ]: 99 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_DESTRUCTED, group_ptr));
457 : :
458 [ - + ]: 99 : if( propagate )
459 : : {
460 [ # # ]: 0 : DLIList<RefGroup*> contained_groups;
461 [ # # ]: 0 : get_contained_groups ( group_ptr, contained_groups );
462 [ # # ][ # # ]: 0 : for( int i=0; i<contained_groups.size(); i++ )
463 : : {
464 [ # # ][ # # ]: 0 : delete_group( contained_groups.get_and_step(), false );
465 [ # # ]: 0 : }
466 : : }
467 : :
468 : 99 : group_ptr->remove_all_ref_entities();
469 [ + - ]: 99 : delete group_ptr;
470 : :
471 : 99 : return CUBIT_SUCCESS;
472 : : }
473 : :
474 : 332 : void RefGroup::delete_all_groups()
475 : : {
476 [ + - ]: 332 : DLIList<RefGroup*> ref_groups;
477 [ + - ][ + - ]: 332 : GeometryQueryTool::instance()->ref_groups(ref_groups);
478 [ + - ]: 332 : int num_groups = ref_groups.size();
479 [ + + ]: 431 : for( int i=0; i<num_groups; i++ )
480 [ + - ][ + - ]: 431 : delete_group( ref_groups.get_and_step() );
[ + - ]
481 : :
482 : 332 : }
483 : :
484 : 0 : void RefGroup::get_contained_groups (RefGroup *group_ptr, DLIList<RefGroup*> &contained_groups)
485 : : {
486 [ # # ][ # # ]: 0 : DLIList<RefEntity*> group_list, mixed_list;
[ # # ]
487 : : RefEntity *ref_entity_ptr;
488 : : RefGroup *group;
489 : :
490 [ # # ]: 0 : mixed_list.append( group_ptr );
491 : :
492 : : // Using expand_group algorithm to get sub_groups of group_ptr
493 : : // don't swap the upper and lower bounds on ii.
494 [ # # ][ # # ]: 0 : for ( int ii = 0; ii < mixed_list.size(); ii++ )
495 : : {
496 : : // Note, the list gets added to, so don't do a simple get_and_step
497 [ # # ]: 0 : mixed_list.reset();
498 [ # # ]: 0 : mixed_list.step(ii);
499 [ # # ]: 0 : ref_entity_ptr = mixed_list.get();
500 : :
501 [ # # ]: 0 : group = CAST_TO( ref_entity_ptr, RefGroup ); //which it should be the first time around
502 [ # # ]: 0 : if (group)
503 : : {
504 : : // avoid infinite recursion of groups A and B containing each other
505 [ # # ][ # # ]: 0 : if (!group_list.move_to(group)) {
506 [ # # ]: 0 : group->get_child_ref_entities(mixed_list);
507 [ # # ]: 0 : group_list.append(group);
508 : : }
509 : : }
510 : : }
511 [ # # ][ # # ]: 0 : CAST_LIST(group_list, contained_groups, RefGroup);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
512 : 0 : }
513 : :
514 : 0 : void RefGroup::get_groups_within( CubitEntity* cubit_entity_ptr,
515 : : DLIList<RefGroup*> &groups_within,
516 : : const CubitBoolean recursive)
517 : : {
518 [ # # ]: 0 : RefEntity* ref_entity_ptr = CAST_TO( cubit_entity_ptr, RefEntity );
519 [ # # ]: 0 : if( ref_entity_ptr != NULL )
520 : : {
521 : 0 : get_groups_within( ref_entity_ptr, groups_within, recursive);
522 : 0 : return;
523 : : }
524 : :
525 : 0 : return;
526 : : }
527 : :
528 : 6378 : void RefGroup::get_groups_within( RefEntity* ref_entity_ptr,
529 : : DLIList<RefGroup*> &groups_within,
530 : : const CubitBoolean recursive)
531 : : {
532 : : RefGroup* ref_group_ptr;
533 : :
534 : : // Get the observer's of this entity
535 [ + - ]: 6378 : DLIList <CubitObserver*> observer_list;
536 [ + - ]: 6378 : ref_entity_ptr->get_observer_list( observer_list );
537 : :
538 : : // Now, loop through the observer list, adding them
539 [ + - ][ + + ]: 6400 : for (int i=0; i<observer_list.size(); i++)
540 : : {
541 [ + - ][ - + ]: 22 : ref_group_ptr = CAST_TO (observer_list.get(), RefGroup);
542 : :
543 [ + - ]: 22 : if( ref_group_ptr != NULL )
544 : : {
545 : : // Add this observer
546 [ + - ]: 22 : groups_within.append_unique( ref_group_ptr );
547 : :
548 : : // Add all the groups the observer is within
549 [ - + ][ # # ]: 22 : if (recursive) get_groups_within( ref_group_ptr, groups_within );
550 : : }
551 [ + - ]: 22 : observer_list.step();
552 [ + - ]: 6378 : }
553 : 6378 : }
554 : :
555 : : // Here we need to move through all the model's group's, since observer's
556 : : // aren't recursive (i.e., if group 2 contains group 3 which contains
557 : : // hex 1, then hex 1's observer is only group 3. Group 2 actually
558 : : // contains hex 1 however, but through group 3).
559 : 11 : void RefGroup::get_groups_within( RefGroup* ref_group_ptr,
560 : : DLIList<RefGroup*> &groups_within,
561 : : const CubitBoolean recursive)
562 : : {
563 : : // Get the model's groups
564 [ + - ]: 11 : DLIList<RefGroup*> model_group_list;
565 [ + - ][ + - ]: 11 : GeometryQueryTool::instance()->ref_groups(model_group_list);
566 : : int i, j;
567 : : RefGroup* model_group;
568 : : RefGroup* contained_group;
569 : :
570 : : // Go through all the groups, finding which ones contain
571 : : // the entity, at any level below (checks groups within
572 : : // groups).
573 [ + - ][ + + ]: 22 : for( i=0; i<model_group_list.size(); i++ )
574 : : {
575 [ + - ]: 11 : model_group = model_group_list.get_and_step();
576 : :
577 : : // See if it exists directly in model_group
578 [ + - ]: 11 : DLIList<RefEntity*> contained_ref_entities;
579 [ + - ]: 11 : model_group->get_child_ref_entities( contained_ref_entities );
580 [ + - ][ - + ]: 11 : if( contained_ref_entities.move_to( (RefEntity*)ref_group_ptr ) )
581 [ # # ]: 0 : groups_within.append_unique( model_group );
582 : :
583 [ + - ]: 11 : if (!recursive) continue;
584 : :
585 : : // Now check all of model group's contained groups
586 [ # # ][ # # ]: 11 : DLIList<RefGroup*> contained_group_list;
[ + - ][ - + ]
587 [ # # ]: 0 : model_group->get_contained_groups( model_group, contained_group_list );
588 [ # # ]: 0 : contained_group_list.remove( model_group );
589 [ # # ][ # # ]: 0 : for( j=0; j<contained_group_list.size(); j++ )
590 : : {
591 [ # # ]: 0 : contained_group = contained_group_list.get_and_step();
592 : :
593 [ # # ]: 0 : contained_ref_entities.clean_out();
594 [ # # ]: 0 : contained_group->get_child_ref_entities( contained_ref_entities );
595 : :
596 [ # # ][ # # ]: 0 : if( contained_ref_entities.move_to( (RefEntity*)ref_group_ptr ) )
597 [ # # ]: 0 : groups_within.append_unique( model_group );
598 : : }
599 [ + - ]: 22 : }
600 : 11 : }
601 : :
602 : 44 : void RefGroup::notify_observer(const CubitEvent *observer_event)
603 : : {
604 [ - + ]: 44 : const GeometryEvent* geom_event = dynamic_cast<const GeometryEvent*>(observer_event);
605 [ + - ]: 44 : if (geom_event != NULL)
606 : : {
607 : 44 : RefEntity *entity = geom_event->get_entity();
608 : :
609 : 44 : int event = geom_event->get_type();
610 [ - + ]: 44 : if (event == GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED) {
611 : 0 : add_ref_entity(entity);
612 : 0 : return;
613 : : }
614 [ + - ]: 44 : else if (event ==GeometryEvent:: TOPOLOGY_ENTITY_DESTRUCTED) {
615 : 44 : remove_ref_entity(entity);
616 : 44 : return;
617 : : }
618 [ # # ]: 0 : else if ( event == GeometryEvent::ENTITIES_MERGED )
619 : : {
620 : : // Out with the old...
621 : 0 : remove_ref_entity(entity);
622 : :
623 : : // ...in with the new.
624 : 0 : const MergeEvent *merge_event = static_cast<const MergeEvent*>(geom_event);
625 : : RefEntity *kept_entity =
626 : 0 : CAST_TO( merge_event->get_kept_entity(), RefEntity );
627 : 0 : add_ref_entity(kept_entity);
628 : : }
629 : : }
630 : 0 : return;
631 [ + - ][ + - ]: 6540 : }
632 : :
633 : : /*
634 : : void RefGroup::draw (int color)
635 : : {
636 : : recursionMark = 1;
637 : : if (is_visible())
638 : : {
639 : : for (int i = entityList.size(); i > 0; i--)
640 : : {
641 : : RefEntity *entity = entityList.get_and_step();
642 : : RefGroup *group = CAST_TO(entity, RefGroup);
643 : : if (!group || group->recursionMark == 0)
644 : : entity->draw(color);
645 : : }
646 : : }
647 : : recursionMark = 0;
648 : : }
649 : : */
650 : :
|
