Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_AIS_InteractiveContext_java.cxx
1 //
2 //                     Copyright (C) 1991 - 2000 by  
3 //                      Matra Datavision SA.  All rights reserved.
4 //  
5 //                     Copyright (C) 2001 - 2004 by
6 //                     Open CASCADE SA.  All rights reserved.
7 // 
8 // This file is part of the Open CASCADE Technology software.
9 //
10 // This software may be distributed and/or modified under the terms and
11 // conditions of the Open CASCADE Public License as defined by Open CASCADE SA
12 // and appearing in the file LICENSE included in the packaging of this file.
13 //  
14 // This software is distributed on an "AS IS" basis, without warranty of any
15 // kind, and Open CASCADE SA hereby disclaims all such warranties,
16 // including without limitation, any warranties of merchantability, fitness
17 // for a particular purpose or non-infringement. Please see the License for
18 // the specific terms and conditions governing rights and limitations under the
19 // License.
20
21 #include <CASCADESamplesJni_AIS_InteractiveContext.h>
22 #include <AIS_InteractiveContext.hxx>
23 #include <jcas.hxx>
24 #include <stdlib.h>
25 #include <Standard_ErrorHandler.hxx>
26 #include <Standard_Failure.hxx>
27 #include <Standard_SStream.hxx>
28
29 #include <V3d_Viewer.hxx>
30 #include <Standard_Boolean.hxx>
31 #include <AIS_InteractiveObject.hxx>
32 #include <Standard_Integer.hxx>
33 #include <Quantity_NameOfColor.hxx>
34 #include <AIS_KindOfInteractive.hxx>
35 #include <Standard_Real.hxx>
36 #include <TopLoc_Location.hxx>
37 #include <Aspect_TypeOfFacingModel.hxx>
38 #include <Quantity_Color.hxx>
39 #include <Graphic3d_NameOfMaterial.hxx>
40 #include <Aspect_TypeOfDegenerateModel.hxx>
41 #include <AIS_Drawer.hxx>
42 #include <AIS_DisplayStatus.hxx>
43 #include <TColStd_ListOfInteger.hxx>
44 #include <TCollection_ExtendedString.hxx>
45 #include <AIS_DisplayMode.hxx>
46 #include <Prs3d_LineAspect.hxx>
47 #include <AIS_TypeOfIso.hxx>
48 #include <Prs3d_BasicAspect.hxx>
49 #include <AIS_StatusOfDetection.hxx>
50 #include <V3d_View.hxx>
51 #include <AIS_StatusOfPick.hxx>
52 #include <TColgp_Array1OfPnt2d.hxx>
53 #include <TopoDS_Shape.hxx>
54 #include <SelectMgr_EntityOwner.hxx>
55 #include <Standard_Transient.hxx>
56 #include <AIS_ClearMode.hxx>
57 #include <Geom_Transformation.hxx>
58 #include <Prs3d_Drawer.hxx>
59 #include <SelectMgr_Filter.hxx>
60 #include <TopAbs_ShapeEnum.hxx>
61 #include <SelectMgr_ListOfFilter.hxx>
62 #include <AIS_ListOfInteractive.hxx>
63 #include <TCollection_AsciiString.hxx>
64 #include <Standard_CString.hxx>
65 #include <SelectMgr_SelectionManager.hxx>
66 #include <PrsMgr_PresentationManager3d.hxx>
67 #include <StdSelect_ViewerSelector3d.hxx>
68
69
70 extern "C" {
71
72
73 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Create_11 (JNIEnv *env, jobject theobj, jobject MainViewer)
74 {
75
76 jcas_Locking alock(env);
77 {
78 try {
79  Handle( V3d_Viewer ) the_MainViewer;
80  void*                ptr_MainViewer = jcas_GetHandle(env,MainViewer);
81  
82  if ( ptr_MainViewer != NULL ) the_MainViewer = *(   (  Handle( V3d_Viewer )*  )ptr_MainViewer   );
83
84 Handle(AIS_InteractiveContext)* theret = new Handle(AIS_InteractiveContext);
85 *theret = new AIS_InteractiveContext(the_MainViewer);
86 jcas_SetHandle(env,theobj,theret);
87
88 }
89 catch (Standard_Failure) {
90   Standard_SStream Err;
91   Err <<   Standard_Failure::Caught(); 
92   Err << (char) 0;
93   jcas_ThrowException(env,Err.str().c_str());
94 }
95 }
96 alock.Release();
97
98 }
99
100
101
102 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Create_12 (JNIEnv *env, jobject theobj, jobject MainViewer, jobject Collector)
103 {
104
105 jcas_Locking alock(env);
106 {
107 try {
108  Handle( V3d_Viewer ) the_MainViewer;
109  void*                ptr_MainViewer = jcas_GetHandle(env,MainViewer);
110  
111  if ( ptr_MainViewer != NULL ) the_MainViewer = *(   (  Handle( V3d_Viewer )*  )ptr_MainViewer   );
112
113  Handle( V3d_Viewer ) the_Collector;
114  void*                ptr_Collector = jcas_GetHandle(env,Collector);
115  
116  if ( ptr_Collector != NULL ) the_Collector = *(   (  Handle( V3d_Viewer )*  )ptr_Collector   );
117
118 Handle(AIS_InteractiveContext)* theret = new Handle(AIS_InteractiveContext);
119 *theret = new AIS_InteractiveContext(the_MainViewer,the_Collector);
120 jcas_SetHandle(env,theobj,theret);
121
122 }
123 catch (Standard_Failure) {
124   Standard_SStream Err;
125   Err <<   Standard_Failure::Caught(); 
126   Err << (char) 0;
127   jcas_ThrowException(env,Err.str().c_str());
128 }
129 }
130 alock.Release();
131
132 }
133
134
135
136 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Delete (JNIEnv *env, jobject theobj)
137 {
138
139 jcas_Locking alock(env);
140 {
141 try {
142 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
143 the_this->Delete();
144
145 }
146 catch (Standard_Failure) {
147   Standard_SStream Err;
148   Err <<   Standard_Failure::Caught(); 
149   Err << (char) 0;
150   jcas_ThrowException(env,Err.str().c_str());
151 }
152 }
153 alock.Release();
154
155 }
156
157
158
159 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_IsCollectorClosed (JNIEnv *env, jobject theobj)
160 {
161 jboolean thejret;
162
163 jcas_Locking alock(env);
164 {
165 try {
166 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
167  thejret = the_this->IsCollectorClosed();
168
169 }
170 catch (Standard_Failure) {
171   Standard_SStream Err;
172   Err <<   Standard_Failure::Caught(); 
173   Err << (char) 0;
174   jcas_ThrowException(env,Err.str().c_str());
175 }
176 }
177 alock.Release();
178 return thejret;
179 }
180
181
182
183 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_CloseCollector (JNIEnv *env, jobject theobj)
184 {
185
186 jcas_Locking alock(env);
187 {
188 try {
189 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
190 the_this->CloseCollector();
191
192 }
193 catch (Standard_Failure) {
194   Standard_SStream Err;
195   Err <<   Standard_Failure::Caught(); 
196   Err << (char) 0;
197   jcas_ThrowException(env,Err.str().c_str());
198 }
199 }
200 alock.Release();
201
202 }
203
204
205
206 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_OpenCollector (JNIEnv *env, jobject theobj)
207 {
208
209 jcas_Locking alock(env);
210 {
211 try {
212 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
213 the_this->OpenCollector();
214
215 }
216 catch (Standard_Failure) {
217   Standard_SStream Err;
218   Err <<   Standard_Failure::Caught(); 
219   Err << (char) 0;
220   jcas_ThrowException(env,Err.str().c_str());
221 }
222 }
223 alock.Release();
224
225 }
226
227
228
229 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetAutoActivateSelection (JNIEnv *env, jobject theobj, jboolean Auto)
230 {
231
232 jcas_Locking alock(env);
233 {
234 try {
235 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
236 the_this->SetAutoActivateSelection((Standard_Boolean) Auto);
237
238 }
239 catch (Standard_Failure) {
240   Standard_SStream Err;
241   Err <<   Standard_Failure::Caught(); 
242   Err << (char) 0;
243   jcas_ThrowException(env,Err.str().c_str());
244 }
245 }
246 alock.Release();
247
248 }
249
250
251
252 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_GetAutoActivateSelection (JNIEnv *env, jobject theobj)
253 {
254 jboolean thejret;
255
256 jcas_Locking alock(env);
257 {
258 try {
259 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
260  thejret = the_this->GetAutoActivateSelection();
261
262 }
263 catch (Standard_Failure) {
264   Standard_SStream Err;
265   Err <<   Standard_Failure::Caught(); 
266   Err << (char) 0;
267   jcas_ThrowException(env,Err.str().c_str());
268 }
269 }
270 alock.Release();
271 return thejret;
272 }
273
274
275
276 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Display_11 (JNIEnv *env, jobject theobj, jobject anIobj, jboolean updateviewer)
277 {
278
279 jcas_Locking alock(env);
280 {
281 try {
282  Handle( AIS_InteractiveObject ) the_anIobj;
283  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
284  
285  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
286
287 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
288 the_this->Display(the_anIobj,(Standard_Boolean) updateviewer);
289
290 }
291 catch (Standard_Failure) {
292   Standard_SStream Err;
293   Err <<   Standard_Failure::Caught(); 
294   Err << (char) 0;
295   jcas_ThrowException(env,Err.str().c_str());
296 }
297 }
298 alock.Release();
299
300 }
301
302
303
304 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Display_12 (JNIEnv *env, jobject theobj, jobject anIobj, jint amode, jint aSelectionMode, jboolean updateviewer, jboolean allowdecomposition)
305 {
306
307 jcas_Locking alock(env);
308 {
309 try {
310  Handle( AIS_InteractiveObject ) the_anIobj;
311  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
312  
313  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
314
315 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
316 the_this->Display(the_anIobj,(Standard_Integer) amode,(Standard_Integer) aSelectionMode,(Standard_Boolean) updateviewer,(Standard_Boolean) allowdecomposition);
317
318 }
319 catch (Standard_Failure) {
320   Standard_SStream Err;
321   Err <<   Standard_Failure::Caught(); 
322   Err << (char) 0;
323   jcas_ThrowException(env,Err.str().c_str());
324 }
325 }
326 alock.Release();
327
328 }
329
330
331
332 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Load (JNIEnv *env, jobject theobj, jobject aniobj, jint SelectionMode, jboolean AllowDecomp)
333 {
334
335 jcas_Locking alock(env);
336 {
337 try {
338  Handle( AIS_InteractiveObject ) the_aniobj;
339  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
340  
341  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
342
343 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
344 the_this->Load(the_aniobj,(Standard_Integer) SelectionMode,(Standard_Boolean) AllowDecomp);
345
346 }
347 catch (Standard_Failure) {
348   Standard_SStream Err;
349   Err <<   Standard_Failure::Caught(); 
350   Err << (char) 0;
351   jcas_ThrowException(env,Err.str().c_str());
352 }
353 }
354 alock.Release();
355
356 }
357
358
359
360 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Erase (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer, jboolean PutInCollector)
361 {
362
363 jcas_Locking alock(env);
364 {
365 try {
366  Handle( AIS_InteractiveObject ) the_aniobj;
367  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
368  
369  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
370
371 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
372 the_this->Erase(the_aniobj,(Standard_Boolean) updateviewer,(Standard_Boolean) PutInCollector);
373
374 }
375 catch (Standard_Failure) {
376   Standard_SStream Err;
377   Err <<   Standard_Failure::Caught(); 
378   Err << (char) 0;
379   jcas_ThrowException(env,Err.str().c_str());
380 }
381 }
382 alock.Release();
383
384 }
385
386
387
388 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_EraseMode (JNIEnv *env, jobject theobj, jobject aniobj, jint aMode, jboolean updateviewer)
389 {
390
391 jcas_Locking alock(env);
392 {
393 try {
394  Handle( AIS_InteractiveObject ) the_aniobj;
395  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
396  
397  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
398
399 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
400 the_this->EraseMode(the_aniobj,(Standard_Integer) aMode,(Standard_Boolean) updateviewer);
401
402 }
403 catch (Standard_Failure) {
404   Standard_SStream Err;
405   Err <<   Standard_Failure::Caught(); 
406   Err << (char) 0;
407   jcas_ThrowException(env,Err.str().c_str());
408 }
409 }
410 alock.Release();
411
412 }
413
414
415
416 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_EraseAll (JNIEnv *env, jobject theobj, jboolean PutInCollector, jboolean updateviewer)
417 {
418
419 jcas_Locking alock(env);
420 {
421 try {
422 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
423 the_this->EraseAll((Standard_Boolean) PutInCollector,(Standard_Boolean) updateviewer);
424
425 }
426 catch (Standard_Failure) {
427   Standard_SStream Err;
428   Err <<   Standard_Failure::Caught(); 
429   Err << (char) 0;
430   jcas_ThrowException(env,Err.str().c_str());
431 }
432 }
433 alock.Release();
434
435 }
436
437
438
439 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayAll (JNIEnv *env, jobject theobj, jboolean OnlyFromCollector, jboolean updateviewer)
440 {
441
442 jcas_Locking alock(env);
443 {
444 try {
445 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
446 the_this->DisplayAll((Standard_Boolean) OnlyFromCollector,(Standard_Boolean) updateviewer);
447
448 }
449 catch (Standard_Failure) {
450   Standard_SStream Err;
451   Err <<   Standard_Failure::Caught(); 
452   Err << (char) 0;
453   jcas_ThrowException(env,Err.str().c_str());
454 }
455 }
456 alock.Release();
457
458 }
459
460
461
462 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayFromCollector (JNIEnv *env, jobject theobj, jobject anIObj, jboolean updateviewer)
463 {
464
465 jcas_Locking alock(env);
466 {
467 try {
468  Handle( AIS_InteractiveObject ) the_anIObj;
469  void*                ptr_anIObj = jcas_GetHandle(env,anIObj);
470  
471  if ( ptr_anIObj != NULL ) the_anIObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIObj   );
472
473 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
474 the_this->DisplayFromCollector(the_anIObj,(Standard_Boolean) updateviewer);
475
476 }
477 catch (Standard_Failure) {
478   Standard_SStream Err;
479   Err <<   Standard_Failure::Caught(); 
480   Err << (char) 0;
481   jcas_ThrowException(env,Err.str().c_str());
482 }
483 }
484 alock.Release();
485
486 }
487
488
489
490 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_EraseSelected (JNIEnv *env, jobject theobj, jboolean PutInCollector, jboolean updateviewer)
491 {
492
493 jcas_Locking alock(env);
494 {
495 try {
496 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
497 the_this->EraseSelected((Standard_Boolean) PutInCollector,(Standard_Boolean) updateviewer);
498
499 }
500 catch (Standard_Failure) {
501   Standard_SStream Err;
502   Err <<   Standard_Failure::Caught(); 
503   Err << (char) 0;
504   jcas_ThrowException(env,Err.str().c_str());
505 }
506 }
507 alock.Release();
508
509 }
510
511
512
513 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplaySelected (JNIEnv *env, jobject theobj, jboolean updateviewer)
514 {
515
516 jcas_Locking alock(env);
517 {
518 try {
519 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
520 the_this->DisplaySelected((Standard_Boolean) updateviewer);
521
522 }
523 catch (Standard_Failure) {
524   Standard_SStream Err;
525   Err <<   Standard_Failure::Caught(); 
526   Err << (char) 0;
527   jcas_ThrowException(env,Err.str().c_str());
528 }
529 }
530 alock.Release();
531
532 }
533
534
535
536 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_KeepTemporary (JNIEnv *env, jobject theobj, jobject anIObj, jint InWhichLocal)
537 {
538 jboolean thejret;
539
540 jcas_Locking alock(env);
541 {
542 try {
543  Handle( AIS_InteractiveObject ) the_anIObj;
544  void*                ptr_anIObj = jcas_GetHandle(env,anIObj);
545  
546  if ( ptr_anIObj != NULL ) the_anIObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIObj   );
547
548 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
549  thejret = the_this->KeepTemporary(the_anIObj,(Standard_Integer) InWhichLocal);
550
551 }
552 catch (Standard_Failure) {
553   Standard_SStream Err;
554   Err <<   Standard_Failure::Caught(); 
555   Err << (char) 0;
556   jcas_ThrowException(env,Err.str().c_str());
557 }
558 }
559 alock.Release();
560 return thejret;
561 }
562
563
564
565 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Clear (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
566 {
567
568 jcas_Locking alock(env);
569 {
570 try {
571  Handle( AIS_InteractiveObject ) the_aniobj;
572  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
573  
574  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
575
576 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
577 the_this->Clear(the_aniobj,(Standard_Boolean) updateviewer);
578
579 }
580 catch (Standard_Failure) {
581   Standard_SStream Err;
582   Err <<   Standard_Failure::Caught(); 
583   Err << (char) 0;
584   jcas_ThrowException(env,Err.str().c_str());
585 }
586 }
587 alock.Release();
588
589 }
590
591
592
593 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_ClearPrs (JNIEnv *env, jobject theobj, jobject aniobj, jint aMode, jboolean updateviewer)
594 {
595
596 jcas_Locking alock(env);
597 {
598 try {
599  Handle( AIS_InteractiveObject ) the_aniobj;
600  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
601  
602  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
603
604 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
605 the_this->ClearPrs(the_aniobj,(Standard_Integer) aMode,(Standard_Boolean) updateviewer);
606
607 }
608 catch (Standard_Failure) {
609   Standard_SStream Err;
610   Err <<   Standard_Failure::Caught(); 
611   Err << (char) 0;
612   jcas_ThrowException(env,Err.str().c_str());
613 }
614 }
615 alock.Release();
616
617 }
618
619
620
621 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Remove (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
622 {
623
624 jcas_Locking alock(env);
625 {
626 try {
627  Handle( AIS_InteractiveObject ) the_aniobj;
628  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
629  
630  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
631
632 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
633 the_this->Remove(the_aniobj,(Standard_Boolean) updateviewer);
634
635 }
636 catch (Standard_Failure) {
637   Standard_SStream Err;
638   Err <<   Standard_Failure::Caught(); 
639   Err << (char) 0;
640   jcas_ThrowException(env,Err.str().c_str());
641 }
642 }
643 alock.Release();
644
645 }
646
647
648
649 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_RemoveAll (JNIEnv *env, jobject theobj, jboolean updateviewer)
650 {
651
652 jcas_Locking alock(env);
653 {
654 try {
655 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
656 the_this->RemoveAll((Standard_Boolean) updateviewer);
657
658 }
659 catch (Standard_Failure) {
660   Standard_SStream Err;
661   Err <<   Standard_Failure::Caught(); 
662   Err << (char) 0;
663   jcas_ThrowException(env,Err.str().c_str());
664 }
665 }
666 alock.Release();
667
668 }
669
670
671
672 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Hilight (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
673 {
674
675 jcas_Locking alock(env);
676 {
677 try {
678  Handle( AIS_InteractiveObject ) the_aniobj;
679  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
680  
681  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
682
683 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
684 the_this->Hilight(the_aniobj,(Standard_Boolean) updateviewer);
685
686 }
687 catch (Standard_Failure) {
688   Standard_SStream Err;
689   Err <<   Standard_Failure::Caught(); 
690   Err << (char) 0;
691   jcas_ThrowException(env,Err.str().c_str());
692 }
693 }
694 alock.Release();
695
696 }
697
698
699
700 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HilightWithColor (JNIEnv *env, jobject theobj, jobject aniobj, jshort aCol, jboolean updateviewer)
701 {
702
703 jcas_Locking alock(env);
704 {
705 try {
706  Handle( AIS_InteractiveObject ) the_aniobj;
707  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
708  
709  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
710
711 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
712 the_this->HilightWithColor(the_aniobj,(Quantity_NameOfColor) aCol,(Standard_Boolean) updateviewer);
713
714 }
715 catch (Standard_Failure) {
716   Standard_SStream Err;
717   Err <<   Standard_Failure::Caught(); 
718   Err << (char) 0;
719   jcas_ThrowException(env,Err.str().c_str());
720 }
721 }
722 alock.Release();
723
724 }
725
726
727
728 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Unhilight (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
729 {
730
731 jcas_Locking alock(env);
732 {
733 try {
734  Handle( AIS_InteractiveObject ) the_aniobj;
735  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
736  
737  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
738
739 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
740 the_this->Unhilight(the_aniobj,(Standard_Boolean) updateviewer);
741
742 }
743 catch (Standard_Failure) {
744   Standard_SStream Err;
745   Err <<   Standard_Failure::Caught(); 
746   Err << (char) 0;
747   jcas_ThrowException(env,Err.str().c_str());
748 }
749 }
750 alock.Release();
751
752 }
753
754
755
756 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetDisplayPriority (JNIEnv *env, jobject theobj, jobject anIobj, jint aPriority)
757 {
758
759 jcas_Locking alock(env);
760 {
761 try {
762  Handle( AIS_InteractiveObject ) the_anIobj;
763  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
764  
765  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
766
767 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
768 the_this->SetDisplayPriority(the_anIobj,(Standard_Integer) aPriority);
769
770 }
771 catch (Standard_Failure) {
772   Standard_SStream Err;
773   Err <<   Standard_Failure::Caught(); 
774   Err << (char) 0;
775   jcas_ThrowException(env,Err.str().c_str());
776 }
777 }
778 alock.Release();
779
780 }
781
782
783
784 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Redisplay_11 (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer, jboolean allmodes)
785 {
786
787 jcas_Locking alock(env);
788 {
789 try {
790  Handle( AIS_InteractiveObject ) the_aniobj;
791  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
792  
793  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
794
795 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
796 the_this->Redisplay(the_aniobj,(Standard_Boolean) updateviewer,(Standard_Boolean) allmodes);
797
798 }
799 catch (Standard_Failure) {
800   Standard_SStream Err;
801   Err <<   Standard_Failure::Caught(); 
802   Err << (char) 0;
803   jcas_ThrowException(env,Err.str().c_str());
804 }
805 }
806 alock.Release();
807
808 }
809
810
811
812 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Redisplay_12 (JNIEnv *env, jobject theobj, jshort aTypeOfObject, jint Signature, jboolean updateviewer)
813 {
814
815 jcas_Locking alock(env);
816 {
817 try {
818 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
819 the_this->Redisplay((AIS_KindOfInteractive) aTypeOfObject,(Standard_Integer) Signature,(Standard_Boolean) updateviewer);
820
821 }
822 catch (Standard_Failure) {
823   Standard_SStream Err;
824   Err <<   Standard_Failure::Caught(); 
825   Err << (char) 0;
826   jcas_ThrowException(env,Err.str().c_str());
827 }
828 }
829 alock.Release();
830
831 }
832
833
834
835 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_RecomputePrsOnly (JNIEnv *env, jobject theobj, jobject anIobj, jboolean updateviewer, jboolean allmodes)
836 {
837
838 jcas_Locking alock(env);
839 {
840 try {
841  Handle( AIS_InteractiveObject ) the_anIobj;
842  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
843  
844  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
845
846 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
847 the_this->RecomputePrsOnly(the_anIobj,(Standard_Boolean) updateviewer,(Standard_Boolean) allmodes);
848
849 }
850 catch (Standard_Failure) {
851   Standard_SStream Err;
852   Err <<   Standard_Failure::Caught(); 
853   Err << (char) 0;
854   jcas_ThrowException(env,Err.str().c_str());
855 }
856 }
857 alock.Release();
858
859 }
860
861
862
863 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_RecomputeSelectionOnly (JNIEnv *env, jobject theobj, jobject anIObj)
864 {
865
866 jcas_Locking alock(env);
867 {
868 try {
869  Handle( AIS_InteractiveObject ) the_anIObj;
870  void*                ptr_anIObj = jcas_GetHandle(env,anIObj);
871  
872  if ( ptr_anIObj != NULL ) the_anIObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIObj   );
873
874 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
875 the_this->RecomputeSelectionOnly(the_anIObj);
876
877 }
878 catch (Standard_Failure) {
879   Standard_SStream Err;
880   Err <<   Standard_Failure::Caught(); 
881   Err << (char) 0;
882   jcas_ThrowException(env,Err.str().c_str());
883 }
884 }
885 alock.Release();
886
887 }
888
889
890
891 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Update (JNIEnv *env, jobject theobj, jobject anIobj, jboolean updateviewer)
892 {
893
894 jcas_Locking alock(env);
895 {
896 try {
897  Handle( AIS_InteractiveObject ) the_anIobj;
898  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
899  
900  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
901
902 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
903 the_this->Update(the_anIobj,(Standard_Boolean) updateviewer);
904
905 }
906 catch (Standard_Failure) {
907   Standard_SStream Err;
908   Err <<   Standard_Failure::Caught(); 
909   Err << (char) 0;
910   jcas_ThrowException(env,Err.str().c_str());
911 }
912 }
913 alock.Release();
914
915 }
916
917
918
919 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDisplayMode_11 (JNIEnv *env, jobject theobj, jobject aniobj, jint aMode, jboolean updateviewer)
920 {
921
922 jcas_Locking alock(env);
923 {
924 try {
925  Handle( AIS_InteractiveObject ) the_aniobj;
926  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
927  
928  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
929
930 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
931 the_this->SetDisplayMode(the_aniobj,(Standard_Integer) aMode,(Standard_Boolean) updateviewer);
932
933 }
934 catch (Standard_Failure) {
935   Standard_SStream Err;
936   Err <<   Standard_Failure::Caught(); 
937   Err << (char) 0;
938   jcas_ThrowException(env,Err.str().c_str());
939 }
940 }
941 alock.Release();
942
943 }
944
945
946
947 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetDisplayMode (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
948 {
949
950 jcas_Locking alock(env);
951 {
952 try {
953  Handle( AIS_InteractiveObject ) the_aniobj;
954  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
955  
956  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
957
958 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
959 the_this->UnsetDisplayMode(the_aniobj,(Standard_Boolean) updateviewer);
960
961 }
962 catch (Standard_Failure) {
963   Standard_SStream Err;
964   Err <<   Standard_Failure::Caught(); 
965   Err << (char) 0;
966   jcas_ThrowException(env,Err.str().c_str());
967 }
968 }
969 alock.Release();
970
971 }
972
973
974
975 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetSelectionMode (JNIEnv *env, jobject theobj, jobject aniobj, jint aMode)
976 {
977
978 jcas_Locking alock(env);
979 {
980 try {
981  Handle( AIS_InteractiveObject ) the_aniobj;
982  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
983  
984  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
985
986 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
987 the_this->SetSelectionMode(the_aniobj,(Standard_Integer) aMode);
988
989 }
990 catch (Standard_Failure) {
991   Standard_SStream Err;
992   Err <<   Standard_Failure::Caught(); 
993   Err << (char) 0;
994   jcas_ThrowException(env,Err.str().c_str());
995 }
996 }
997 alock.Release();
998
999 }
1000
1001
1002
1003 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetSelectionMode (JNIEnv *env, jobject theobj, jobject aniobj)
1004 {
1005
1006 jcas_Locking alock(env);
1007 {
1008 try {
1009  Handle( AIS_InteractiveObject ) the_aniobj;
1010  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1011  
1012  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1013
1014 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1015 the_this->UnsetSelectionMode(the_aniobj);
1016
1017 }
1018 catch (Standard_Failure) {
1019   Standard_SStream Err;
1020   Err <<   Standard_Failure::Caught(); 
1021   Err << (char) 0;
1022   jcas_ThrowException(env,Err.str().c_str());
1023 }
1024 }
1025 alock.Release();
1026
1027 }
1028
1029
1030
1031 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetSensitivity_11 (JNIEnv *env, jobject theobj, jdouble aPrecision)
1032 {
1033
1034 jcas_Locking alock(env);
1035 {
1036 try {
1037 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1038 the_this->SetSensitivity((Standard_Real) aPrecision);
1039
1040 }
1041 catch (Standard_Failure) {
1042   Standard_SStream Err;
1043   Err <<   Standard_Failure::Caught(); 
1044   Err << (char) 0;
1045   jcas_ThrowException(env,Err.str().c_str());
1046 }
1047 }
1048 alock.Release();
1049
1050 }
1051
1052
1053
1054 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetSensitivity_12 (JNIEnv *env, jobject theobj, jint aPrecision)
1055 {
1056
1057 jcas_Locking alock(env);
1058 {
1059 try {
1060 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1061 the_this->SetSensitivity((Standard_Integer) aPrecision);
1062
1063 }
1064 catch (Standard_Failure) {
1065   Standard_SStream Err;
1066   Err <<   Standard_Failure::Caught(); 
1067   Err << (char) 0;
1068   jcas_ThrowException(env,Err.str().c_str());
1069 }
1070 }
1071 alock.Release();
1072
1073 }
1074
1075
1076
1077 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetLocation (JNIEnv *env, jobject theobj, jobject aniobj, jobject aLocation)
1078 {
1079
1080 jcas_Locking alock(env);
1081 {
1082 try {
1083  Handle( AIS_InteractiveObject ) the_aniobj;
1084  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1085  
1086  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1087
1088 TopLoc_Location* the_aLocation = (TopLoc_Location*) jcas_GetHandle(env,aLocation);
1089 if ( the_aLocation == NULL ) {
1090
1091  // The following assumes availability of the default constructor (what may not
1092  // always be the case). Therefore explicit exception is thrown if the null
1093  // object has been passed.
1094  // the_aLocation = new TopLoc_Location ();
1095  // jcas_SetHandle ( env, aLocation, the_aLocation );
1096  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1097
1098 }  // end if
1099 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1100 the_this->SetLocation(the_aniobj,*the_aLocation);
1101
1102 }
1103 catch (Standard_Failure) {
1104   Standard_SStream Err;
1105   Err <<   Standard_Failure::Caught(); 
1106   Err << (char) 0;
1107   jcas_ThrowException(env,Err.str().c_str());
1108 }
1109 }
1110 alock.Release();
1111
1112 }
1113
1114
1115
1116 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_ResetLocation (JNIEnv *env, jobject theobj, jobject aniobj)
1117 {
1118
1119 jcas_Locking alock(env);
1120 {
1121 try {
1122  Handle( AIS_InteractiveObject ) the_aniobj;
1123  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1124  
1125  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1126
1127 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1128 the_this->ResetLocation(the_aniobj);
1129
1130 }
1131 catch (Standard_Failure) {
1132   Standard_SStream Err;
1133   Err <<   Standard_Failure::Caught(); 
1134   Err << (char) 0;
1135   jcas_ThrowException(env,Err.str().c_str());
1136 }
1137 }
1138 alock.Release();
1139
1140 }
1141
1142
1143
1144 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HasLocation (JNIEnv *env, jobject theobj, jobject aniobj)
1145 {
1146 jboolean thejret;
1147
1148 jcas_Locking alock(env);
1149 {
1150 try {
1151  Handle( AIS_InteractiveObject ) the_aniobj;
1152  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1153  
1154  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1155
1156 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1157  thejret = the_this->HasLocation(the_aniobj);
1158
1159 }
1160 catch (Standard_Failure) {
1161   Standard_SStream Err;
1162   Err <<   Standard_Failure::Caught(); 
1163   Err << (char) 0;
1164   jcas_ThrowException(env,Err.str().c_str());
1165 }
1166 }
1167 alock.Release();
1168 return thejret;
1169 }
1170
1171
1172
1173 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Location (JNIEnv *env, jobject theobj, jobject aniobj)
1174 {
1175 jobject thejret;
1176
1177 jcas_Locking alock(env);
1178 {
1179 try {
1180  Handle( AIS_InteractiveObject ) the_aniobj;
1181  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1182  
1183  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1184
1185 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1186 const TopLoc_Location& theret = the_this->Location(the_aniobj);
1187 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopLoc_Location",&theret,0);
1188
1189 }
1190 catch (Standard_Failure) {
1191   Standard_SStream Err;
1192   Err <<   Standard_Failure::Caught(); 
1193   Err << (char) 0;
1194   jcas_ThrowException(env,Err.str().c_str());
1195 }
1196 }
1197 alock.Release();
1198 return thejret;
1199 }
1200
1201
1202
1203 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetCurrentFacingModel (JNIEnv *env, jobject theobj, jobject aniobj, jshort aModel)
1204 {
1205
1206 jcas_Locking alock(env);
1207 {
1208 try {
1209  Handle( AIS_InteractiveObject ) the_aniobj;
1210  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1211  
1212  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1213
1214 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1215 the_this->SetCurrentFacingModel(the_aniobj,(Aspect_TypeOfFacingModel) aModel);
1216
1217 }
1218 catch (Standard_Failure) {
1219   Standard_SStream Err;
1220   Err <<   Standard_Failure::Caught(); 
1221   Err << (char) 0;
1222   jcas_ThrowException(env,Err.str().c_str());
1223 }
1224 }
1225 alock.Release();
1226
1227 }
1228
1229
1230
1231 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetColor_11 (JNIEnv *env, jobject theobj, jobject aniobj, jshort aColor, jboolean updateviewer)
1232 {
1233
1234 jcas_Locking alock(env);
1235 {
1236 try {
1237  Handle( AIS_InteractiveObject ) the_aniobj;
1238  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1239  
1240  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1241
1242 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1243 the_this->SetColor(the_aniobj,(Quantity_NameOfColor) aColor,(Standard_Boolean) updateviewer);
1244
1245 }
1246 catch (Standard_Failure) {
1247   Standard_SStream Err;
1248   Err <<   Standard_Failure::Caught(); 
1249   Err << (char) 0;
1250   jcas_ThrowException(env,Err.str().c_str());
1251 }
1252 }
1253 alock.Release();
1254
1255 }
1256
1257
1258
1259 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetColor_12 (JNIEnv *env, jobject theobj, jobject aniobj, jobject aColor, jboolean updateviewer)
1260 {
1261
1262 jcas_Locking alock(env);
1263 {
1264 try {
1265  Handle( AIS_InteractiveObject ) the_aniobj;
1266  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1267  
1268  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1269
1270 Quantity_Color* the_aColor = (Quantity_Color*) jcas_GetHandle(env,aColor);
1271 if ( the_aColor == NULL ) {
1272
1273  // The following assumes availability of the default constructor (what may not
1274  // always be the case). Therefore explicit exception is thrown if the null
1275  // object has been passed.
1276  // the_aColor = new Quantity_Color ();
1277  // jcas_SetHandle ( env, aColor, the_aColor );
1278  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1279
1280 }  // end if
1281 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1282 the_this->SetColor(the_aniobj,*the_aColor,(Standard_Boolean) updateviewer);
1283
1284 }
1285 catch (Standard_Failure) {
1286   Standard_SStream Err;
1287   Err <<   Standard_Failure::Caught(); 
1288   Err << (char) 0;
1289   jcas_ThrowException(env,Err.str().c_str());
1290 }
1291 }
1292 alock.Release();
1293
1294 }
1295
1296
1297
1298 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetColor (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
1299 {
1300
1301 jcas_Locking alock(env);
1302 {
1303 try {
1304  Handle( AIS_InteractiveObject ) the_aniobj;
1305  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1306  
1307  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1308
1309 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1310 the_this->UnsetColor(the_aniobj,(Standard_Boolean) updateviewer);
1311
1312 }
1313 catch (Standard_Failure) {
1314   Standard_SStream Err;
1315   Err <<   Standard_Failure::Caught(); 
1316   Err << (char) 0;
1317   jcas_ThrowException(env,Err.str().c_str());
1318 }
1319 }
1320 alock.Release();
1321
1322 }
1323
1324
1325
1326 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetWidth (JNIEnv *env, jobject theobj, jobject aniobj, jdouble aValue, jboolean updateviewer)
1327 {
1328
1329 jcas_Locking alock(env);
1330 {
1331 try {
1332  Handle( AIS_InteractiveObject ) the_aniobj;
1333  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1334  
1335  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1336
1337 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1338 the_this->SetWidth(the_aniobj,(Standard_Real) aValue,(Standard_Boolean) updateviewer);
1339
1340 }
1341 catch (Standard_Failure) {
1342   Standard_SStream Err;
1343   Err <<   Standard_Failure::Caught(); 
1344   Err << (char) 0;
1345   jcas_ThrowException(env,Err.str().c_str());
1346 }
1347 }
1348 alock.Release();
1349
1350 }
1351
1352
1353
1354 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetWidth (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
1355 {
1356
1357 jcas_Locking alock(env);
1358 {
1359 try {
1360  Handle( AIS_InteractiveObject ) the_aniobj;
1361  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1362  
1363  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1364
1365 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1366 the_this->UnsetWidth(the_aniobj,(Standard_Boolean) updateviewer);
1367
1368 }
1369 catch (Standard_Failure) {
1370   Standard_SStream Err;
1371   Err <<   Standard_Failure::Caught(); 
1372   Err << (char) 0;
1373   jcas_ThrowException(env,Err.str().c_str());
1374 }
1375 }
1376 alock.Release();
1377
1378 }
1379
1380
1381
1382 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetMaterial (JNIEnv *env, jobject theobj, jobject aniobj, jshort aName, jboolean updateviewer)
1383 {
1384
1385 jcas_Locking alock(env);
1386 {
1387 try {
1388  Handle( AIS_InteractiveObject ) the_aniobj;
1389  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1390  
1391  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1392
1393 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1394 the_this->SetMaterial(the_aniobj,(Graphic3d_NameOfMaterial) aName,(Standard_Boolean) updateviewer);
1395
1396 }
1397 catch (Standard_Failure) {
1398   Standard_SStream Err;
1399   Err <<   Standard_Failure::Caught(); 
1400   Err << (char) 0;
1401   jcas_ThrowException(env,Err.str().c_str());
1402 }
1403 }
1404 alock.Release();
1405
1406 }
1407
1408
1409
1410 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetMaterial (JNIEnv *env, jobject theobj, jobject anObj, jboolean updateviewer)
1411 {
1412
1413 jcas_Locking alock(env);
1414 {
1415 try {
1416  Handle( AIS_InteractiveObject ) the_anObj;
1417  void*                ptr_anObj = jcas_GetHandle(env,anObj);
1418  
1419  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
1420
1421 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1422 the_this->UnsetMaterial(the_anObj,(Standard_Boolean) updateviewer);
1423
1424 }
1425 catch (Standard_Failure) {
1426   Standard_SStream Err;
1427   Err <<   Standard_Failure::Caught(); 
1428   Err << (char) 0;
1429   jcas_ThrowException(env,Err.str().c_str());
1430 }
1431 }
1432 alock.Release();
1433
1434 }
1435
1436
1437
1438 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetTransparency (JNIEnv *env, jobject theobj, jobject aniobj, jdouble aValue, jboolean updateviewer)
1439 {
1440
1441 jcas_Locking alock(env);
1442 {
1443 try {
1444  Handle( AIS_InteractiveObject ) the_aniobj;
1445  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1446  
1447  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1448
1449 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1450 the_this->SetTransparency(the_aniobj,(Standard_Real) aValue,(Standard_Boolean) updateviewer);
1451
1452 }
1453 catch (Standard_Failure) {
1454   Standard_SStream Err;
1455   Err <<   Standard_Failure::Caught(); 
1456   Err << (char) 0;
1457   jcas_ThrowException(env,Err.str().c_str());
1458 }
1459 }
1460 alock.Release();
1461
1462 }
1463
1464
1465
1466 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetTransparency (JNIEnv *env, jobject theobj, jobject aniobj, jboolean updateviewer)
1467 {
1468
1469 jcas_Locking alock(env);
1470 {
1471 try {
1472  Handle( AIS_InteractiveObject ) the_aniobj;
1473  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1474  
1475  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1476
1477 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1478 the_this->UnsetTransparency(the_aniobj,(Standard_Boolean) updateviewer);
1479
1480 }
1481 catch (Standard_Failure) {
1482   Standard_SStream Err;
1483   Err <<   Standard_Failure::Caught(); 
1484   Err << (char) 0;
1485   jcas_ThrowException(env,Err.str().c_str());
1486 }
1487 }
1488 alock.Release();
1489
1490 }
1491
1492
1493
1494 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDegenerateModel_11 (JNIEnv *env, jobject theobj, jobject aniobj, jshort aModel, jdouble aRatio)
1495 {
1496
1497 jcas_Locking alock(env);
1498 {
1499 try {
1500  Handle( AIS_InteractiveObject ) the_aniobj;
1501  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1502  
1503  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1504
1505 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1506 the_this->SetDegenerateModel(the_aniobj,(Aspect_TypeOfDegenerateModel) aModel,(Quantity_Ratio) aRatio);
1507
1508 }
1509 catch (Standard_Failure) {
1510   Standard_SStream Err;
1511   Err <<   Standard_Failure::Caught(); 
1512   Err << (char) 0;
1513   jcas_ThrowException(env,Err.str().c_str());
1514 }
1515 }
1516 alock.Release();
1517
1518 }
1519
1520
1521
1522 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDegenerateModel_12 (JNIEnv *env, jobject theobj, jshort aModel, jdouble aSkipRatio)
1523 {
1524
1525 jcas_Locking alock(env);
1526 {
1527 try {
1528 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1529 the_this->SetDegenerateModel((Aspect_TypeOfDegenerateModel) aModel,(Quantity_Ratio) aSkipRatio);
1530
1531 }
1532 catch (Standard_Failure) {
1533   Standard_SStream Err;
1534   Err <<   Standard_Failure::Caught(); 
1535   Err << (char) 0;
1536   jcas_ThrowException(env,Err.str().c_str());
1537 }
1538 }
1539 alock.Release();
1540
1541 }
1542
1543
1544
1545 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetLocalAttributes (JNIEnv *env, jobject theobj, jobject aniobj, jobject aDrawer, jboolean updateviewer)
1546 {
1547
1548 jcas_Locking alock(env);
1549 {
1550 try {
1551  Handle( AIS_InteractiveObject ) the_aniobj;
1552  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1553  
1554  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1555
1556  Handle( AIS_Drawer ) the_aDrawer;
1557  void*                ptr_aDrawer = jcas_GetHandle(env,aDrawer);
1558  
1559  if ( ptr_aDrawer != NULL ) the_aDrawer = *(   (  Handle( AIS_Drawer )*  )ptr_aDrawer   );
1560
1561 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1562 the_this->SetLocalAttributes(the_aniobj,the_aDrawer,(Standard_Boolean) updateviewer);
1563
1564 }
1565 catch (Standard_Failure) {
1566   Standard_SStream Err;
1567   Err <<   Standard_Failure::Caught(); 
1568   Err << (char) 0;
1569   jcas_ThrowException(env,Err.str().c_str());
1570 }
1571 }
1572 alock.Release();
1573
1574 }
1575
1576
1577
1578 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UnsetLocalAttributes (JNIEnv *env, jobject theobj, jobject anObj, jboolean updateviewer)
1579 {
1580
1581 jcas_Locking alock(env);
1582 {
1583 try {
1584  Handle( AIS_InteractiveObject ) the_anObj;
1585  void*                ptr_anObj = jcas_GetHandle(env,anObj);
1586  
1587  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
1588
1589 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1590 the_this->UnsetLocalAttributes(the_anObj,(Standard_Boolean) updateviewer);
1591
1592 }
1593 catch (Standard_Failure) {
1594   Standard_SStream Err;
1595   Err <<   Standard_Failure::Caught(); 
1596   Err << (char) 0;
1597   jcas_ThrowException(env,Err.str().c_str());
1598 }
1599 }
1600 alock.Release();
1601
1602 }
1603
1604
1605
1606 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetPolygonOffsets (JNIEnv *env, jobject theobj, jobject anObj, jint aMode, jdouble aFactor, jdouble aUnits, jboolean updateviewer)
1607 {
1608
1609 jcas_Locking alock(env);
1610 {
1611 try {
1612  Handle( AIS_InteractiveObject ) the_anObj;
1613  void*                ptr_anObj = jcas_GetHandle(env,anObj);
1614  
1615  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
1616
1617 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1618 the_this->SetPolygonOffsets(the_anObj,(Standard_Integer) aMode,(Standard_Real) aFactor,(Standard_Real) aUnits,(Standard_Boolean) updateviewer);
1619
1620 }
1621 catch (Standard_Failure) {
1622   Standard_SStream Err;
1623   Err <<   Standard_Failure::Caught(); 
1624   Err << (char) 0;
1625   jcas_ThrowException(env,Err.str().c_str());
1626 }
1627 }
1628 alock.Release();
1629
1630 }
1631
1632
1633
1634 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HasPolygonOffsets (JNIEnv *env, jobject theobj, jobject anObj)
1635 {
1636 jboolean thejret;
1637
1638 jcas_Locking alock(env);
1639 {
1640 try {
1641  Handle( AIS_InteractiveObject ) the_anObj;
1642  void*                ptr_anObj = jcas_GetHandle(env,anObj);
1643  
1644  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
1645
1646 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1647  thejret = the_this->HasPolygonOffsets(the_anObj);
1648
1649 }
1650 catch (Standard_Failure) {
1651   Standard_SStream Err;
1652   Err <<   Standard_Failure::Caught(); 
1653   Err << (char) 0;
1654   jcas_ThrowException(env,Err.str().c_str());
1655 }
1656 }
1657 alock.Release();
1658 return thejret;
1659 }
1660
1661
1662
1663 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_PolygonOffsets (JNIEnv *env, jobject theobj, jobject anObj, jobject aMode, jobject aFactor, jobject aUnits)
1664 {
1665
1666 jcas_Locking alock(env);
1667 {
1668 try {
1669  Handle( AIS_InteractiveObject ) the_anObj;
1670  void*                ptr_anObj = jcas_GetHandle(env,anObj);
1671  
1672  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
1673
1674 Standard_Integer the_aMode = jcas_GetInteger(env,aMode);
1675 Standard_Real the_aFactor = jcas_GetReal(env,aFactor);
1676 Standard_Real the_aUnits = jcas_GetReal(env,aUnits);
1677 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1678 the_this->PolygonOffsets(the_anObj,the_aMode,the_aFactor,the_aUnits);
1679 jcas_SetInteger(env,aMode,the_aMode);
1680 jcas_SetReal(env,aFactor,the_aFactor);
1681 jcas_SetReal(env,aUnits,the_aUnits);
1682
1683 }
1684 catch (Standard_Failure) {
1685   Standard_SStream Err;
1686   Err <<   Standard_Failure::Caught(); 
1687   Err << (char) 0;
1688   jcas_ThrowException(env,Err.str().c_str());
1689 }
1690 }
1691 alock.Release();
1692
1693 }
1694
1695
1696
1697 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetTrihedronSize (JNIEnv *env, jobject theobj, jdouble aSize, jboolean updateviewer)
1698 {
1699
1700 jcas_Locking alock(env);
1701 {
1702 try {
1703 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1704 the_this->SetTrihedronSize((Standard_Real) aSize,(Standard_Boolean) updateviewer);
1705
1706 }
1707 catch (Standard_Failure) {
1708   Standard_SStream Err;
1709   Err <<   Standard_Failure::Caught(); 
1710   Err << (char) 0;
1711   jcas_ThrowException(env,Err.str().c_str());
1712 }
1713 }
1714 alock.Release();
1715
1716 }
1717
1718
1719
1720 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_TrihedronSize (JNIEnv *env, jobject theobj)
1721 {
1722 jdouble thejret;
1723
1724 jcas_Locking alock(env);
1725 {
1726 try {
1727 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1728  thejret = the_this->TrihedronSize();
1729
1730 }
1731 catch (Standard_Failure) {
1732   Standard_SStream Err;
1733   Err <<   Standard_Failure::Caught(); 
1734   Err << (char) 0;
1735   jcas_ThrowException(env,Err.str().c_str());
1736 }
1737 }
1738 alock.Release();
1739 return thejret;
1740 }
1741
1742
1743
1744 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetPlaneSize_11 (JNIEnv *env, jobject theobj, jdouble aSizeX, jdouble aSizeY, jboolean updateviewer)
1745 {
1746
1747 jcas_Locking alock(env);
1748 {
1749 try {
1750 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1751 the_this->SetPlaneSize((Standard_Real) aSizeX,(Standard_Real) aSizeY,(Standard_Boolean) updateviewer);
1752
1753 }
1754 catch (Standard_Failure) {
1755   Standard_SStream Err;
1756   Err <<   Standard_Failure::Caught(); 
1757   Err << (char) 0;
1758   jcas_ThrowException(env,Err.str().c_str());
1759 }
1760 }
1761 alock.Release();
1762
1763 }
1764
1765
1766
1767 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetPlaneSize_12 (JNIEnv *env, jobject theobj, jdouble aSize, jboolean updateviewer)
1768 {
1769
1770 jcas_Locking alock(env);
1771 {
1772 try {
1773 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1774 the_this->SetPlaneSize((Standard_Real) aSize,(Standard_Boolean) updateviewer);
1775
1776 }
1777 catch (Standard_Failure) {
1778   Standard_SStream Err;
1779   Err <<   Standard_Failure::Caught(); 
1780   Err << (char) 0;
1781   jcas_ThrowException(env,Err.str().c_str());
1782 }
1783 }
1784 alock.Release();
1785
1786 }
1787
1788
1789
1790 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_PlaneSize (JNIEnv *env, jobject theobj, jobject XSize, jobject YSize)
1791 {
1792 jboolean thejret;
1793
1794 jcas_Locking alock(env);
1795 {
1796 try {
1797 Standard_Real the_XSize = jcas_GetReal(env,XSize);
1798 Standard_Real the_YSize = jcas_GetReal(env,YSize);
1799 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1800  thejret = the_this->PlaneSize(the_XSize,the_YSize);
1801 jcas_SetReal(env,XSize,the_XSize);
1802 jcas_SetReal(env,YSize,the_YSize);
1803
1804 }
1805 catch (Standard_Failure) {
1806   Standard_SStream Err;
1807   Err <<   Standard_Failure::Caught(); 
1808   Err << (char) 0;
1809   jcas_ThrowException(env,Err.str().c_str());
1810 }
1811 }
1812 alock.Release();
1813 return thejret;
1814 }
1815
1816
1817
1818 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayStatus (JNIEnv *env, jobject theobj, jobject anIobj)
1819 {
1820 jshort thejret;
1821
1822 jcas_Locking alock(env);
1823 {
1824 try {
1825  Handle( AIS_InteractiveObject ) the_anIobj;
1826  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
1827  
1828  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
1829
1830 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1831  thejret = the_this->DisplayStatus(the_anIobj);
1832
1833 }
1834 catch (Standard_Failure) {
1835   Standard_SStream Err;
1836   Err <<   Standard_Failure::Caught(); 
1837   Err << (char) 0;
1838   jcas_ThrowException(env,Err.str().c_str());
1839 }
1840 }
1841 alock.Release();
1842 return thejret;
1843 }
1844
1845
1846
1847 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayedModes (JNIEnv *env, jobject theobj, jobject aniobj)
1848 {
1849 jobject thejret;
1850
1851 jcas_Locking alock(env);
1852 {
1853 try {
1854  Handle( AIS_InteractiveObject ) the_aniobj;
1855  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1856  
1857  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1858
1859 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1860 const TColStd_ListOfInteger& theret = the_this->DisplayedModes(the_aniobj);
1861 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TColStd_ListOfInteger",&theret,0);
1862
1863 }
1864 catch (Standard_Failure) {
1865   Standard_SStream Err;
1866   Err <<   Standard_Failure::Caught(); 
1867   Err << (char) 0;
1868   jcas_ThrowException(env,Err.str().c_str());
1869 }
1870 }
1871 alock.Release();
1872 return thejret;
1873 }
1874
1875
1876
1877 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsDisplayed_11 (JNIEnv *env, jobject theobj, jobject anIobj)
1878 {
1879 jboolean thejret;
1880
1881 jcas_Locking alock(env);
1882 {
1883 try {
1884  Handle( AIS_InteractiveObject ) the_anIobj;
1885  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
1886  
1887  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
1888
1889 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1890  thejret = the_this->IsDisplayed(the_anIobj);
1891
1892 }
1893 catch (Standard_Failure) {
1894   Standard_SStream Err;
1895   Err <<   Standard_Failure::Caught(); 
1896   Err << (char) 0;
1897   jcas_ThrowException(env,Err.str().c_str());
1898 }
1899 }
1900 alock.Release();
1901 return thejret;
1902 }
1903
1904
1905
1906 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsDisplayed_12 (JNIEnv *env, jobject theobj, jobject aniobj, jint aMode)
1907 {
1908 jboolean thejret;
1909
1910 jcas_Locking alock(env);
1911 {
1912 try {
1913  Handle( AIS_InteractiveObject ) the_aniobj;
1914  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1915  
1916  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1917
1918 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1919  thejret = the_this->IsDisplayed(the_aniobj,(Standard_Integer) aMode);
1920
1921 }
1922 catch (Standard_Failure) {
1923   Standard_SStream Err;
1924   Err <<   Standard_Failure::Caught(); 
1925   Err << (char) 0;
1926   jcas_ThrowException(env,Err.str().c_str());
1927 }
1928 }
1929 alock.Release();
1930 return thejret;
1931 }
1932
1933
1934
1935 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsHilighted_11 (JNIEnv *env, jobject theobj, jobject aniobj)
1936 {
1937 jboolean thejret;
1938
1939 jcas_Locking alock(env);
1940 {
1941 try {
1942  Handle( AIS_InteractiveObject ) the_aniobj;
1943  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
1944  
1945  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
1946
1947 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1948  thejret = the_this->IsHilighted(the_aniobj);
1949
1950 }
1951 catch (Standard_Failure) {
1952   Standard_SStream Err;
1953   Err <<   Standard_Failure::Caught(); 
1954   Err << (char) 0;
1955   jcas_ThrowException(env,Err.str().c_str());
1956 }
1957 }
1958 alock.Release();
1959 return thejret;
1960 }
1961
1962
1963
1964 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsHilighted_12 (JNIEnv *env, jobject theobj, jobject anIobj, jobject WithColor, jobject theHiCol)
1965 {
1966 jboolean thejret;
1967
1968 jcas_Locking alock(env);
1969 {
1970 try {
1971  Handle( AIS_InteractiveObject ) the_anIobj;
1972  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
1973  
1974  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
1975
1976 Standard_Boolean the_WithColor = jcas_GetBoolean(env,WithColor);
1977 Quantity_NameOfColor the_theHiCol = ( Quantity_NameOfColor )jcas_GetShort ( env, theHiCol );
1978 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
1979  thejret = the_this->IsHilighted(the_anIobj,the_WithColor,the_theHiCol);
1980 jcas_SetBoolean(env,WithColor,the_WithColor);
1981 jcas_SetShort(env,theHiCol,the_theHiCol);
1982
1983 }
1984 catch (Standard_Failure) {
1985   Standard_SStream Err;
1986   Err <<   Standard_Failure::Caught(); 
1987   Err << (char) 0;
1988   jcas_ThrowException(env,Err.str().c_str());
1989 }
1990 }
1991 alock.Release();
1992 return thejret;
1993 }
1994
1995
1996
1997 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_IsInCollector (JNIEnv *env, jobject theobj, jobject anIObj)
1998 {
1999 jboolean thejret;
2000
2001 jcas_Locking alock(env);
2002 {
2003 try {
2004  Handle( AIS_InteractiveObject ) the_anIObj;
2005  void*                ptr_anIObj = jcas_GetHandle(env,anIObj);
2006  
2007  if ( ptr_anIObj != NULL ) the_anIObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIObj   );
2008
2009 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2010  thejret = the_this->IsInCollector(the_anIObj);
2011
2012 }
2013 catch (Standard_Failure) {
2014   Standard_SStream Err;
2015   Err <<   Standard_Failure::Caught(); 
2016   Err << (char) 0;
2017   jcas_ThrowException(env,Err.str().c_str());
2018 }
2019 }
2020 alock.Release();
2021 return thejret;
2022 }
2023
2024
2025
2026 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayPriority (JNIEnv *env, jobject theobj, jobject anIobj)
2027 {
2028 jint thejret;
2029
2030 jcas_Locking alock(env);
2031 {
2032 try {
2033  Handle( AIS_InteractiveObject ) the_anIobj;
2034  void*                ptr_anIobj = jcas_GetHandle(env,anIobj);
2035  
2036  if ( ptr_anIobj != NULL ) the_anIobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anIobj   );
2037
2038 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2039  thejret = the_this->DisplayPriority(the_anIobj);
2040
2041 }
2042 catch (Standard_Failure) {
2043   Standard_SStream Err;
2044   Err <<   Standard_Failure::Caught(); 
2045   Err << (char) 0;
2046   jcas_ThrowException(env,Err.str().c_str());
2047 }
2048 }
2049 alock.Release();
2050 return thejret;
2051 }
2052
2053
2054
2055 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HasColor (JNIEnv *env, jobject theobj, jobject aniobj)
2056 {
2057 jboolean thejret;
2058
2059 jcas_Locking alock(env);
2060 {
2061 try {
2062  Handle( AIS_InteractiveObject ) the_aniobj;
2063  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2064  
2065  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2066
2067 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2068  thejret = the_this->HasColor(the_aniobj);
2069
2070 }
2071 catch (Standard_Failure) {
2072   Standard_SStream Err;
2073   Err <<   Standard_Failure::Caught(); 
2074   Err << (char) 0;
2075   jcas_ThrowException(env,Err.str().c_str());
2076 }
2077 }
2078 alock.Release();
2079 return thejret;
2080 }
2081
2082
2083
2084 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Color_11 (JNIEnv *env, jobject theobj, jobject aniobj)
2085 {
2086 jshort thejret;
2087
2088 jcas_Locking alock(env);
2089 {
2090 try {
2091  Handle( AIS_InteractiveObject ) the_aniobj;
2092  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2093  
2094  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2095
2096 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2097  thejret = the_this->Color(the_aniobj);
2098
2099 }
2100 catch (Standard_Failure) {
2101   Standard_SStream Err;
2102   Err <<   Standard_Failure::Caught(); 
2103   Err << (char) 0;
2104   jcas_ThrowException(env,Err.str().c_str());
2105 }
2106 }
2107 alock.Release();
2108 return thejret;
2109 }
2110
2111
2112
2113 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Color_12 (JNIEnv *env, jobject theobj, jobject aniobj, jobject acolor)
2114 {
2115
2116 jcas_Locking alock(env);
2117 {
2118 try {
2119  Handle( AIS_InteractiveObject ) the_aniobj;
2120  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2121  
2122  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2123
2124 Quantity_Color* the_acolor = (Quantity_Color*) jcas_GetHandle(env,acolor);
2125 if ( the_acolor == NULL ) {
2126
2127  // The following assumes availability of the default constructor (what may not
2128  // always be the case). Therefore explicit exception is thrown if the null
2129  // object has been passed.
2130  // the_acolor = new Quantity_Color ();
2131  // jcas_SetHandle ( env, acolor, the_acolor );
2132  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
2133
2134 }  // end if
2135 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2136 the_this->Color(the_aniobj,*the_acolor);
2137
2138 }
2139 catch (Standard_Failure) {
2140   Standard_SStream Err;
2141   Err <<   Standard_Failure::Caught(); 
2142   Err << (char) 0;
2143   jcas_ThrowException(env,Err.str().c_str());
2144 }
2145 }
2146 alock.Release();
2147
2148 }
2149
2150
2151
2152 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Width (JNIEnv *env, jobject theobj, jobject aniobj)
2153 {
2154 jdouble thejret;
2155
2156 jcas_Locking alock(env);
2157 {
2158 try {
2159  Handle( AIS_InteractiveObject ) the_aniobj;
2160  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2161  
2162  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2163
2164 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2165  thejret = the_this->Width(the_aniobj);
2166
2167 }
2168 catch (Standard_Failure) {
2169   Standard_SStream Err;
2170   Err <<   Standard_Failure::Caught(); 
2171   Err << (char) 0;
2172   jcas_ThrowException(env,Err.str().c_str());
2173 }
2174 }
2175 alock.Release();
2176 return thejret;
2177 }
2178
2179
2180
2181 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_Status (JNIEnv *env, jobject theobj, jobject anObj, jobject astatus)
2182 {
2183
2184 jcas_Locking alock(env);
2185 {
2186 try {
2187  Handle( AIS_InteractiveObject ) the_anObj;
2188  void*                ptr_anObj = jcas_GetHandle(env,anObj);
2189  
2190  if ( ptr_anObj != NULL ) the_anObj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_anObj   );
2191
2192 TCollection_ExtendedString* the_astatus = (TCollection_ExtendedString*) jcas_GetHandle(env,astatus);
2193 if ( the_astatus == NULL ) {
2194
2195  // The following assumes availability of the default constructor (what may not
2196  // always be the case). Therefore explicit exception is thrown if the null
2197  // object has been passed.
2198  // the_astatus = new TCollection_ExtendedString ();
2199  // jcas_SetHandle ( env, astatus, the_astatus );
2200  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
2201
2202 }  // end if
2203 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2204 the_this->Status(the_anObj,*the_astatus);
2205
2206 }
2207 catch (Standard_Failure) {
2208   Standard_SStream Err;
2209   Err <<   Standard_Failure::Caught(); 
2210   Err << (char) 0;
2211   jcas_ThrowException(env,Err.str().c_str());
2212 }
2213 }
2214 alock.Release();
2215
2216 }
2217
2218
2219
2220 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UpdateCurrentViewer (JNIEnv *env, jobject theobj)
2221 {
2222
2223 jcas_Locking alock(env);
2224 {
2225 try {
2226 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2227 the_this->UpdateCurrentViewer();
2228
2229 }
2230 catch (Standard_Failure) {
2231   Standard_SStream Err;
2232   Err <<   Standard_Failure::Caught(); 
2233   Err << (char) 0;
2234   jcas_ThrowException(env,Err.str().c_str());
2235 }
2236 }
2237 alock.Release();
2238
2239 }
2240
2241
2242
2243 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_UpdateCollector (JNIEnv *env, jobject theobj)
2244 {
2245
2246 jcas_Locking alock(env);
2247 {
2248 try {
2249 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2250 the_this->UpdateCollector();
2251
2252 }
2253 catch (Standard_Failure) {
2254   Standard_SStream Err;
2255   Err <<   Standard_Failure::Caught(); 
2256   Err << (char) 0;
2257   jcas_ThrowException(env,Err.str().c_str());
2258 }
2259 }
2260 alock.Release();
2261
2262 }
2263
2264
2265
2266 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisplayMode (JNIEnv *env, jobject theobj)
2267 {
2268 jint thejret;
2269
2270 jcas_Locking alock(env);
2271 {
2272 try {
2273 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2274  thejret = the_this->DisplayMode();
2275
2276 }
2277 catch (Standard_Failure) {
2278   Standard_SStream Err;
2279   Err <<   Standard_Failure::Caught(); 
2280   Err << (char) 0;
2281   jcas_ThrowException(env,Err.str().c_str());
2282 }
2283 }
2284 alock.Release();
2285 return thejret;
2286 }
2287
2288
2289
2290 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HilightColor (JNIEnv *env, jobject theobj)
2291 {
2292 jshort thejret;
2293
2294 jcas_Locking alock(env);
2295 {
2296 try {
2297 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2298  thejret = the_this->HilightColor();
2299
2300 }
2301 catch (Standard_Failure) {
2302   Standard_SStream Err;
2303   Err <<   Standard_Failure::Caught(); 
2304   Err << (char) 0;
2305   jcas_ThrowException(env,Err.str().c_str());
2306 }
2307 }
2308 alock.Release();
2309 return thejret;
2310 }
2311
2312
2313
2314 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SelectionColor_11 (JNIEnv *env, jobject theobj)
2315 {
2316 jshort thejret;
2317
2318 jcas_Locking alock(env);
2319 {
2320 try {
2321 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2322  thejret = the_this->SelectionColor();
2323
2324 }
2325 catch (Standard_Failure) {
2326   Standard_SStream Err;
2327   Err <<   Standard_Failure::Caught(); 
2328   Err << (char) 0;
2329   jcas_ThrowException(env,Err.str().c_str());
2330 }
2331 }
2332 alock.Release();
2333 return thejret;
2334 }
2335
2336
2337
2338 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_PreSelectionColor (JNIEnv *env, jobject theobj)
2339 {
2340 jshort thejret;
2341
2342 jcas_Locking alock(env);
2343 {
2344 try {
2345 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2346  thejret = the_this->PreSelectionColor();
2347
2348 }
2349 catch (Standard_Failure) {
2350   Standard_SStream Err;
2351   Err <<   Standard_Failure::Caught(); 
2352   Err << (char) 0;
2353   jcas_ThrowException(env,Err.str().c_str());
2354 }
2355 }
2356 alock.Release();
2357 return thejret;
2358 }
2359
2360
2361
2362 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DefaultColor (JNIEnv *env, jobject theobj)
2363 {
2364 jshort thejret;
2365
2366 jcas_Locking alock(env);
2367 {
2368 try {
2369 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2370  thejret = the_this->DefaultColor();
2371
2372 }
2373 catch (Standard_Failure) {
2374   Standard_SStream Err;
2375   Err <<   Standard_Failure::Caught(); 
2376   Err << (char) 0;
2377   jcas_ThrowException(env,Err.str().c_str());
2378 }
2379 }
2380 alock.Release();
2381 return thejret;
2382 }
2383
2384
2385
2386 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SubIntensityColor (JNIEnv *env, jobject theobj)
2387 {
2388 jshort thejret;
2389
2390 jcas_Locking alock(env);
2391 {
2392 try {
2393 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2394  thejret = the_this->SubIntensityColor();
2395
2396 }
2397 catch (Standard_Failure) {
2398   Standard_SStream Err;
2399   Err <<   Standard_Failure::Caught(); 
2400   Err << (char) 0;
2401   jcas_ThrowException(env,Err.str().c_str());
2402 }
2403 }
2404 alock.Release();
2405 return thejret;
2406 }
2407
2408
2409
2410 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetHilightColor (JNIEnv *env, jobject theobj, jshort aHiCol)
2411 {
2412
2413 jcas_Locking alock(env);
2414 {
2415 try {
2416 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2417 the_this->SetHilightColor((Quantity_NameOfColor) aHiCol);
2418
2419 }
2420 catch (Standard_Failure) {
2421   Standard_SStream Err;
2422   Err <<   Standard_Failure::Caught(); 
2423   Err << (char) 0;
2424   jcas_ThrowException(env,Err.str().c_str());
2425 }
2426 }
2427 alock.Release();
2428
2429 }
2430
2431
2432
2433 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SelectionColor_12 (JNIEnv *env, jobject theobj, jshort aCol)
2434 {
2435
2436 jcas_Locking alock(env);
2437 {
2438 try {
2439 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2440 the_this->SelectionColor((Quantity_NameOfColor) aCol);
2441
2442 }
2443 catch (Standard_Failure) {
2444   Standard_SStream Err;
2445   Err <<   Standard_Failure::Caught(); 
2446   Err << (char) 0;
2447   jcas_ThrowException(env,Err.str().c_str());
2448 }
2449 }
2450 alock.Release();
2451
2452 }
2453
2454
2455
2456 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetPreselectionColor (JNIEnv *env, jobject theobj, jshort aCol)
2457 {
2458
2459 jcas_Locking alock(env);
2460 {
2461 try {
2462 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2463 the_this->SetPreselectionColor((Quantity_NameOfColor) aCol);
2464
2465 }
2466 catch (Standard_Failure) {
2467   Standard_SStream Err;
2468   Err <<   Standard_Failure::Caught(); 
2469   Err << (char) 0;
2470   jcas_ThrowException(env,Err.str().c_str());
2471 }
2472 }
2473 alock.Release();
2474
2475 }
2476
2477
2478
2479 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetSubIntensityColor (JNIEnv *env, jobject theobj, jshort aCol)
2480 {
2481
2482 jcas_Locking alock(env);
2483 {
2484 try {
2485 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2486 the_this->SetSubIntensityColor((Quantity_NameOfColor) aCol);
2487
2488 }
2489 catch (Standard_Failure) {
2490   Standard_SStream Err;
2491   Err <<   Standard_Failure::Caught(); 
2492   Err << (char) 0;
2493   jcas_ThrowException(env,Err.str().c_str());
2494 }
2495 }
2496 alock.Release();
2497
2498 }
2499
2500
2501
2502 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDisplayMode_12 (JNIEnv *env, jobject theobj, jshort AMode, jboolean updateviewer)
2503 {
2504
2505 jcas_Locking alock(env);
2506 {
2507 try {
2508 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2509 the_this->SetDisplayMode((AIS_DisplayMode) AMode,(Standard_Boolean) updateviewer);
2510
2511 }
2512 catch (Standard_Failure) {
2513   Standard_SStream Err;
2514   Err <<   Standard_Failure::Caught(); 
2515   Err << (char) 0;
2516   jcas_ThrowException(env,Err.str().c_str());
2517 }
2518 }
2519 alock.Release();
2520
2521 }
2522
2523
2524
2525 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDeviationCoefficient_11 (JNIEnv *env, jobject theobj, jobject aniobj, jdouble aCoefficient, jboolean updateviewer)
2526 {
2527
2528 jcas_Locking alock(env);
2529 {
2530 try {
2531  Handle( AIS_InteractiveObject ) the_aniobj;
2532  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2533  
2534  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2535
2536 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2537 the_this->SetDeviationCoefficient(the_aniobj,(Standard_Real) aCoefficient,(Standard_Boolean) updateviewer);
2538
2539 }
2540 catch (Standard_Failure) {
2541   Standard_SStream Err;
2542   Err <<   Standard_Failure::Caught(); 
2543   Err << (char) 0;
2544   jcas_ThrowException(env,Err.str().c_str());
2545 }
2546 }
2547 alock.Release();
2548
2549 }
2550
2551
2552
2553 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDeviationAngle_11 (JNIEnv *env, jobject theobj, jobject aniobj, jdouble anAngle, jboolean updateviewer)
2554 {
2555
2556 jcas_Locking alock(env);
2557 {
2558 try {
2559  Handle( AIS_InteractiveObject ) the_aniobj;
2560  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2561  
2562  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2563
2564 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2565 the_this->SetDeviationAngle(the_aniobj,(Standard_Real) anAngle,(Standard_Boolean) updateviewer);
2566
2567 }
2568 catch (Standard_Failure) {
2569   Standard_SStream Err;
2570   Err <<   Standard_Failure::Caught(); 
2571   Err << (char) 0;
2572   jcas_ThrowException(env,Err.str().c_str());
2573 }
2574 }
2575 alock.Release();
2576
2577 }
2578
2579
2580
2581 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetAngleAndDeviation (JNIEnv *env, jobject theobj, jobject aniobj, jdouble anAngle, jboolean updateviewer)
2582 {
2583
2584 jcas_Locking alock(env);
2585 {
2586 try {
2587  Handle( AIS_InteractiveObject ) the_aniobj;
2588  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2589  
2590  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2591
2592 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2593 the_this->SetAngleAndDeviation(the_aniobj,(Standard_Real) anAngle,(Standard_Boolean) updateviewer);
2594
2595 }
2596 catch (Standard_Failure) {
2597   Standard_SStream Err;
2598   Err <<   Standard_Failure::Caught(); 
2599   Err << (char) 0;
2600   jcas_ThrowException(env,Err.str().c_str());
2601 }
2602 }
2603 alock.Release();
2604
2605 }
2606
2607
2608
2609 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetHLRDeviationCoefficient_11 (JNIEnv *env, jobject theobj, jobject aniobj, jdouble aCoefficient, jboolean updateviewer)
2610 {
2611
2612 jcas_Locking alock(env);
2613 {
2614 try {
2615  Handle( AIS_InteractiveObject ) the_aniobj;
2616  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2617  
2618  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2619
2620 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2621 the_this->SetHLRDeviationCoefficient(the_aniobj,(Standard_Real) aCoefficient,(Standard_Boolean) updateviewer);
2622
2623 }
2624 catch (Standard_Failure) {
2625   Standard_SStream Err;
2626   Err <<   Standard_Failure::Caught(); 
2627   Err << (char) 0;
2628   jcas_ThrowException(env,Err.str().c_str());
2629 }
2630 }
2631 alock.Release();
2632
2633 }
2634
2635
2636
2637 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetHLRDeviationAngle (JNIEnv *env, jobject theobj, jobject aniobj, jdouble anAngle, jboolean updateviewer)
2638 {
2639
2640 jcas_Locking alock(env);
2641 {
2642 try {
2643  Handle( AIS_InteractiveObject ) the_aniobj;
2644  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2645  
2646  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2647
2648 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2649 the_this->SetHLRDeviationAngle(the_aniobj,(Standard_Real) anAngle,(Standard_Boolean) updateviewer);
2650
2651 }
2652 catch (Standard_Failure) {
2653   Standard_SStream Err;
2654   Err <<   Standard_Failure::Caught(); 
2655   Err << (char) 0;
2656   jcas_ThrowException(env,Err.str().c_str());
2657 }
2658 }
2659 alock.Release();
2660
2661 }
2662
2663
2664
2665 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetHLRAngleAndDeviation_11 (JNIEnv *env, jobject theobj, jobject aniobj, jdouble anAngle, jboolean updateviewer)
2666 {
2667
2668 jcas_Locking alock(env);
2669 {
2670 try {
2671  Handle( AIS_InteractiveObject ) the_aniobj;
2672  void*                ptr_aniobj = jcas_GetHandle(env,aniobj);
2673  
2674  if ( ptr_aniobj != NULL ) the_aniobj = *(   (  Handle( AIS_InteractiveObject )*  )ptr_aniobj   );
2675
2676 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2677 the_this->SetHLRAngleAndDeviation(the_aniobj,(Standard_Real) anAngle,(Standard_Boolean) updateviewer);
2678
2679 }
2680 catch (Standard_Failure) {
2681   Standard_SStream Err;
2682   Err <<   Standard_Failure::Caught(); 
2683   Err << (char) 0;
2684   jcas_ThrowException(env,Err.str().c_str());
2685 }
2686 }
2687 alock.Release();
2688
2689 }
2690
2691
2692
2693 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDeviationCoefficient_12 (JNIEnv *env, jobject theobj, jdouble aCoefficient)
2694 {
2695
2696 jcas_Locking alock(env);
2697 {
2698 try {
2699 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2700 the_this->SetDeviationCoefficient((Standard_Real) aCoefficient);
2701
2702 }
2703 catch (Standard_Failure) {
2704   Standard_SStream Err;
2705   Err <<   Standard_Failure::Caught(); 
2706   Err << (char) 0;
2707   jcas_ThrowException(env,Err.str().c_str());
2708 }
2709 }
2710 alock.Release();
2711
2712 }
2713
2714
2715
2716 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DeviationCoefficient (JNIEnv *env, jobject theobj)
2717 {
2718 jdouble thejret;
2719
2720 jcas_Locking alock(env);
2721 {
2722 try {
2723 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2724  thejret = the_this->DeviationCoefficient();
2725
2726 }
2727 catch (Standard_Failure) {
2728   Standard_SStream Err;
2729   Err <<   Standard_Failure::Caught(); 
2730   Err << (char) 0;
2731   jcas_ThrowException(env,Err.str().c_str());
2732 }
2733 }
2734 alock.Release();
2735 return thejret;
2736 }
2737
2738
2739
2740 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetDeviationAngle_12 (JNIEnv *env, jobject theobj, jdouble anAngle)
2741 {
2742
2743 jcas_Locking alock(env);
2744 {
2745 try {
2746 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2747 the_this->SetDeviationAngle((Standard_Real) anAngle);
2748
2749 }
2750 catch (Standard_Failure) {
2751   Standard_SStream Err;
2752   Err <<   Standard_Failure::Caught(); 
2753   Err << (char) 0;
2754   jcas_ThrowException(env,Err.str().c_str());
2755 }
2756 }
2757 alock.Release();
2758
2759 }
2760
2761
2762
2763 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DeviationAngle (JNIEnv *env, jobject theobj)
2764 {
2765 jdouble thejret;
2766
2767 jcas_Locking alock(env);
2768 {
2769 try {
2770 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2771  thejret = the_this->DeviationAngle();
2772
2773 }
2774 catch (Standard_Failure) {
2775   Standard_SStream Err;
2776   Err <<   Standard_Failure::Caught(); 
2777   Err << (char) 0;
2778   jcas_ThrowException(env,Err.str().c_str());
2779 }
2780 }
2781 alock.Release();
2782 return thejret;
2783 }
2784
2785
2786
2787 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetHLRDeviationCoefficient_12 (JNIEnv *env, jobject theobj, jdouble aCoefficient)
2788 {
2789
2790 jcas_Locking alock(env);
2791 {
2792 try {
2793 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2794 the_this->SetHLRDeviationCoefficient((Standard_Real) aCoefficient);
2795
2796 }
2797 catch (Standard_Failure) {
2798   Standard_SStream Err;
2799   Err <<   Standard_Failure::Caught(); 
2800   Err << (char) 0;
2801   jcas_ThrowException(env,Err.str().c_str());
2802 }
2803 }
2804 alock.Release();
2805
2806 }
2807
2808
2809
2810 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HLRDeviationCoefficient (JNIEnv *env, jobject theobj)
2811 {
2812 jdouble thejret;
2813
2814 jcas_Locking alock(env);
2815 {
2816 try {
2817 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2818  thejret = the_this->HLRDeviationCoefficient();
2819
2820 }
2821 catch (Standard_Failure) {
2822   Standard_SStream Err;
2823   Err <<   Standard_Failure::Caught(); 
2824   Err << (char) 0;
2825   jcas_ThrowException(env,Err.str().c_str());
2826 }
2827 }
2828 alock.Release();
2829 return thejret;
2830 }
2831
2832
2833
2834 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetHLRAngle (JNIEnv *env, jobject theobj, jdouble anAngle)
2835 {
2836
2837 jcas_Locking alock(env);
2838 {
2839 try {
2840 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2841 the_this->SetHLRAngle((Standard_Real) anAngle);
2842
2843 }
2844 catch (Standard_Failure) {
2845   Standard_SStream Err;
2846   Err <<   Standard_Failure::Caught(); 
2847   Err << (char) 0;
2848   jcas_ThrowException(env,Err.str().c_str());
2849 }
2850 }
2851 alock.Release();
2852
2853 }
2854
2855
2856
2857 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HLRAngle (JNIEnv *env, jobject theobj)
2858 {
2859 jdouble thejret;
2860
2861 jcas_Locking alock(env);
2862 {
2863 try {
2864 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2865  thejret = the_this->HLRAngle();
2866
2867 }
2868 catch (Standard_Failure) {
2869   Standard_SStream Err;
2870   Err <<   Standard_Failure::Caught(); 
2871   Err << (char) 0;
2872   jcas_ThrowException(env,Err.str().c_str());
2873 }
2874 }
2875 alock.Release();
2876 return thejret;
2877 }
2878
2879
2880
2881 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1SetHLRAngleAndDeviation_12 (JNIEnv *env, jobject theobj, jdouble anAngle)
2882 {
2883
2884 jcas_Locking alock(env);
2885 {
2886 try {
2887 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2888 the_this->SetHLRAngleAndDeviation((Standard_Real) anAngle);
2889
2890 }
2891 catch (Standard_Failure) {
2892   Standard_SStream Err;
2893   Err <<   Standard_Failure::Caught(); 
2894   Err << (char) 0;
2895   jcas_ThrowException(env,Err.str().c_str());
2896 }
2897 }
2898 alock.Release();
2899
2900 }
2901
2902
2903
2904 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HiddenLineAspect (JNIEnv *env, jobject theobj)
2905 {
2906 jobject thejret;
2907
2908 jcas_Locking alock(env);
2909 {
2910 try {
2911 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2912 Handle(Prs3d_LineAspect)* theret = new Handle(Prs3d_LineAspect);
2913 *theret = the_this->HiddenLineAspect();
2914 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Prs3d_LineAspect",theret);
2915
2916 }
2917 catch (Standard_Failure) {
2918   Standard_SStream Err;
2919   Err <<   Standard_Failure::Caught(); 
2920   Err << (char) 0;
2921   jcas_ThrowException(env,Err.str().c_str());
2922 }
2923 }
2924 alock.Release();
2925 return thejret;
2926 }
2927
2928
2929
2930 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetHiddenLineAspect (JNIEnv *env, jobject theobj, jobject anAspect)
2931 {
2932
2933 jcas_Locking alock(env);
2934 {
2935 try {
2936  Handle( Prs3d_LineAspect ) the_anAspect;
2937  void*                ptr_anAspect = jcas_GetHandle(env,anAspect);
2938  
2939  if ( ptr_anAspect != NULL ) the_anAspect = *(   (  Handle( Prs3d_LineAspect )*  )ptr_anAspect   );
2940
2941 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2942 the_this->SetHiddenLineAspect(the_anAspect);
2943
2944 }
2945 catch (Standard_Failure) {
2946   Standard_SStream Err;
2947   Err <<   Standard_Failure::Caught(); 
2948   Err << (char) 0;
2949   jcas_ThrowException(env,Err.str().c_str());
2950 }
2951 }
2952 alock.Release();
2953
2954 }
2955
2956
2957
2958 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DrawHiddenLine (JNIEnv *env, jobject theobj)
2959 {
2960 jboolean thejret;
2961
2962 jcas_Locking alock(env);
2963 {
2964 try {
2965 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2966  thejret = the_this->DrawHiddenLine();
2967
2968 }
2969 catch (Standard_Failure) {
2970   Standard_SStream Err;
2971   Err <<   Standard_Failure::Caught(); 
2972   Err << (char) 0;
2973   jcas_ThrowException(env,Err.str().c_str());
2974 }
2975 }
2976 alock.Release();
2977 return thejret;
2978 }
2979
2980
2981
2982 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_EnableDrawHiddenLine (JNIEnv *env, jobject theobj)
2983 {
2984
2985 jcas_Locking alock(env);
2986 {
2987 try {
2988 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
2989 the_this->EnableDrawHiddenLine();
2990
2991 }
2992 catch (Standard_Failure) {
2993   Standard_SStream Err;
2994   Err <<   Standard_Failure::Caught(); 
2995   Err << (char) 0;
2996   jcas_ThrowException(env,Err.str().c_str());
2997 }
2998 }
2999 alock.Release();
3000
3001 }
3002
3003
3004
3005 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_DisableDrawHiddenLine (JNIEnv *env, jobject theobj)
3006 {
3007
3008 jcas_Locking alock(env);
3009 {
3010 try {
3011 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3012 the_this->DisableDrawHiddenLine();
3013
3014 }
3015 catch (Standard_Failure) {
3016   Standard_SStream Err;
3017   Err <<   Standard_Failure::Caught(); 
3018   Err << (char) 0;
3019   jcas_ThrowException(env,Err.str().c_str());
3020 }
3021 }
3022 alock.Release();
3023
3024 }
3025
3026
3027
3028 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetIsoNumber (JNIEnv *env, jobject theobj, jint NbIsos, jshort WhichIsos)
3029 {
3030
3031 jcas_Locking alock(env);
3032 {
3033 try {
3034 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3035 the_this->SetIsoNumber((Standard_Integer) NbIsos,(AIS_TypeOfIso) WhichIsos);
3036
3037 }
3038 catch (Standard_Failure) {
3039   Standard_SStream Err;
3040   Err <<   Standard_Failure::Caught(); 
3041   Err << (char) 0;
3042   jcas_ThrowException(env,Err.str().c_str());
3043 }
3044 }
3045 alock.Release();
3046
3047 }
3048
3049
3050
3051 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_IsoNumber (JNIEnv *env, jobject theobj, jshort WhichIsos)
3052 {
3053 jint thejret;
3054
3055 jcas_Locking alock(env);
3056 {
3057 try {
3058 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3059  thejret = the_this->IsoNumber((AIS_TypeOfIso) WhichIsos);
3060
3061 }
3062 catch (Standard_Failure) {
3063   Standard_SStream Err;
3064   Err <<   Standard_Failure::Caught(); 
3065   Err << (char) 0;
3066   jcas_ThrowException(env,Err.str().c_str());
3067 }
3068 }
3069 alock.Release();
3070 return thejret;
3071 }
3072
3073
3074
3075 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsoOnPlane_11 (JNIEnv *env, jobject theobj, jboolean SwitchOn)
3076 {
3077
3078 jcas_Locking alock(env);
3079 {
3080 try {
3081 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3082 the_this->IsoOnPlane((Standard_Boolean) SwitchOn);
3083
3084 }
3085 catch (Standard_Failure) {
3086   Standard_SStream Err;
3087   Err <<   Standard_Failure::Caught(); 
3088   Err << (char) 0;
3089   jcas_ThrowException(env,Err.str().c_str());
3090 }
3091 }
3092 alock.Release();
3093
3094 }
3095
3096
3097
3098 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1IsoOnPlane_12 (JNIEnv *env, jobject theobj)
3099 {
3100 jboolean thejret;
3101
3102 jcas_Locking alock(env);
3103 {
3104 try {
3105 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3106  thejret = the_this->IsoOnPlane();
3107
3108 }
3109 catch (Standard_Failure) {
3110   Standard_SStream Err;
3111   Err <<   Standard_Failure::Caught(); 
3112   Err << (char) 0;
3113   jcas_ThrowException(env,Err.str().c_str());
3114 }
3115 }
3116 alock.Release();
3117 return thejret;
3118 }
3119
3120
3121
3122 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_SetSelectedAspect (JNIEnv *env, jobject theobj, jobject anAspect, jboolean globalChange, jboolean updateViewer)
3123 {
3124
3125 jcas_Locking alock(env);
3126 {
3127 try {
3128  Handle( Prs3d_BasicAspect ) the_anAspect;
3129  void*                ptr_anAspect = jcas_GetHandle(env,anAspect);
3130  
3131  if ( ptr_anAspect != NULL ) the_anAspect = *(   (  Handle( Prs3d_BasicAspect )*  )ptr_anAspect   );
3132
3133 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3134 the_this->SetSelectedAspect(the_anAspect,(Standard_Boolean) globalChange,(Standard_Boolean) updateViewer);
3135
3136 }
3137 catch (Standard_Failure) {
3138   Standard_SStream Err;
3139   Err <<   Standard_Failure::Caught(); 
3140   Err << (char) 0;
3141   jcas_ThrowException(env,Err.str().c_str());
3142 }
3143 }
3144 alock.Release();
3145
3146 }
3147
3148
3149
3150 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_MoveTo (JNIEnv *env, jobject theobj, jint XPix, jint YPix, jobject aView)
3151 {
3152 jshort thejret;
3153
3154 jcas_Locking alock(env);
3155 {
3156 try {
3157  Handle( V3d_View ) the_aView;
3158  void*                ptr_aView = jcas_GetHandle(env,aView);
3159  
3160  if ( ptr_aView != NULL ) the_aView = *(   (  Handle( V3d_View )*  )ptr_aView   );
3161
3162 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3163  thejret = the_this->MoveTo((Standard_Integer) XPix,(Standard_Integer) YPix,the_aView);
3164
3165 }
3166 catch (Standard_Failure) {
3167   Standard_SStream Err;
3168   Err <<   Standard_Failure::Caught(); 
3169   Err << (char) 0;
3170   jcas_ThrowException(env,Err.str().c_str());
3171 }
3172 }
3173 alock.Release();
3174 return thejret;
3175 }
3176
3177
3178
3179 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HasNextDetected (JNIEnv *env, jobject theobj)
3180 {
3181 jboolean thejret;
3182
3183 jcas_Locking alock(env);
3184 {
3185 try {
3186 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3187  thejret = the_this->HasNextDetected();
3188
3189 }
3190 catch (Standard_Failure) {
3191   Standard_SStream Err;
3192   Err <<   Standard_Failure::Caught(); 
3193   Err << (char) 0;
3194   jcas_ThrowException(env,Err.str().c_str());
3195 }
3196 }
3197 alock.Release();
3198 return thejret;
3199 }
3200
3201
3202
3203 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HilightNextDetected (JNIEnv *env, jobject theobj, jobject aView)
3204 {
3205 jint thejret;
3206
3207 jcas_Locking alock(env);
3208 {
3209 try {
3210  Handle( V3d_View ) the_aView;
3211  void*                ptr_aView = jcas_GetHandle(env,aView);
3212  
3213  if ( ptr_aView != NULL ) the_aView = *(   (  Handle( V3d_View )*  )ptr_aView   );
3214
3215 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3216  thejret = the_this->HilightNextDetected(the_aView);
3217
3218 }
3219 catch (Standard_Failure) {
3220   Standard_SStream Err;
3221   Err <<   Standard_Failure::Caught(); 
3222   Err << (char) 0;
3223   jcas_ThrowException(env,Err.str().c_str());
3224 }
3225 }
3226 alock.Release();
3227 return thejret;
3228 }
3229
3230
3231
3232 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_HilightPreviousDetected (JNIEnv *env, jobject theobj, jobject aView)
3233 {
3234 jint thejret;
3235
3236 jcas_Locking alock(env);
3237 {
3238 try {
3239  Handle( V3d_View ) the_aView;
3240  void*                ptr_aView = jcas_GetHandle(env,aView);
3241  
3242  if ( ptr_aView != NULL ) the_aView = *(   (  Handle( V3d_View )*  )ptr_aView   );
3243
3244 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3245  thejret = the_this->HilightPreviousDetected(the_aView);
3246
3247 }
3248 catch (Standard_Failure) {
3249   Standard_SStream Err;
3250   Err <<   Standard_Failure::Caught(); 
3251   Err << (char) 0;
3252   jcas_ThrowException(env,Err.str().c_str());
3253 }
3254 }
3255 alock.Release();
3256 return thejret;
3257 }
3258
3259
3260
3261 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Select_11 (JNIEnv *env, jobject theobj, jint XPMin, jint YPMin, jint XPMax, jint YPMax, jobject aView, jboolean updateviewer)
3262 {
3263 jshort thejret;
3264
3265 jcas_Locking alock(env);
3266 {
3267 try {
3268  Handle( V3d_View ) the_aView;
3269  void*                ptr_aView = jcas_GetHandle(env,aView);
3270  
3271  if ( ptr_aView != NULL ) the_aView = *(   (  Handle( V3d_View )*  )ptr_aView   );
3272
3273 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3274  thejret = the_this->Select((Standard_Integer) XPMin,(Standard_Integer) YPMin,(Standard_Integer) XPMax,(Standard_Integer) YPMax,the_aView,(Standard_Boolean) updateviewer);
3275
3276 }
3277 catch (Standard_Failure) {
3278   Standard_SStream Err;
3279   Err <<   Standard_Failure::Caught(); 
3280   Err << (char) 0;
3281   jcas_ThrowException(env,Err.str().c_str());
3282 }
3283 }
3284 alock.Release();
3285 return thejret;
3286 }
3287
3288
3289
3290 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveContext_AIS_1InteractiveContext_1Select_12 (JNIEnv *env, jobject theobj, jobject Polyline, jobject aView, jboolean updateviewer)
3291 {
3292 jshort thejret;
3293
3294 jcas_Locking alock(env);
3295 {
3296 try {
3297 TColgp_Array1OfPnt2d* the_Polyline = (TColgp_Array1OfPnt2d*) jcas_GetHandle(env,Polyline);
3298 if ( the_Polyline == NULL ) {
3299
3300  // The following assumes availability of the default constructor (what may not
3301  // always be the case). Therefore explicit exception is thrown if the null
3302  // object has been passed.
3303  // the_Polyline = new TColgp_Array1OfPnt2d ();
3304  // jcas_SetHandle ( env, Polyline, the_Polyline );
3305  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
3306
3307 }  // end if
3308  Handle( V3d_View ) the_aView;
3309  void*                ptr_aView = jcas_GetHandle(env,aView);
3310  
3311  if ( ptr_aView != NULL ) the_aView = *(   (  Handle( V3d_View )*  )ptr_aView   );
3312
3313 Handle(AIS_InteractiveContext) the_this = *((Handle(AIS_InteractiveContext)*) jcas_GetHandle(env,theobj));
3314  thejret = the_this->Select(*the_Polyline,the_aView,(Standard_Boolean) updateviewer);