Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_AIS_InteractiveObject_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_InteractiveObject.h>
22 #include <AIS_InteractiveObject.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 <AIS_KindOfInteractive.hxx>
30 #include <Standard_Integer.hxx>
31 #include <Standard_Boolean.hxx>
32 #include <Aspect_TypeOfFacingModel.hxx>
33 #include <Quantity_Color.hxx>
34 #include <Quantity_NameOfColor.hxx>
35 #include <Standard_Real.hxx>
36 #include <AIS_InteractiveContext.hxx>
37 #include <Standard_Transient.hxx>
38 #include <TColStd_ListOfTransient.hxx>
39 #include <Graphic3d_NameOfMaterial.hxx>
40 #include <Graphic3d_MaterialAspect.hxx>
41 #include <AIS_Drawer.hxx>
42 #include <Aspect_TypeOfDegenerateModel.hxx>
43 #include <Geom_Transformation.hxx>
44 #include <Prs3d_Presentation.hxx>
45 #include <Prs3d_BasicAspect.hxx>
46
47
48 extern "C" {
49
50
51 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Type (JNIEnv *env, jobject theobj)
52 {
53 jshort thejret;
54
55 jcas_Locking alock(env);
56 {
57 try {
58 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
59  thejret = the_this->Type();
60
61 }
62 catch (Standard_Failure) {
63   Standard_SStream Err;
64   Err <<   Standard_Failure::Caught(); 
65   Err << (char) 0;
66   jcas_ThrowException(env,Err.str().c_str());
67 }
68 }
69 alock.Release();
70 return thejret;
71 }
72
73
74
75 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Signature (JNIEnv *env, jobject theobj)
76 {
77 jint thejret;
78
79 jcas_Locking alock(env);
80 {
81 try {
82 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
83  thejret = the_this->Signature();
84
85 }
86 catch (Standard_Failure) {
87   Standard_SStream Err;
88   Err <<   Standard_Failure::Caught(); 
89   Err << (char) 0;
90   jcas_ThrowException(env,Err.str().c_str());
91 }
92 }
93 alock.Release();
94 return thejret;
95 }
96
97
98
99 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AcceptShapeDecomposition (JNIEnv *env, jobject theobj)
100 {
101 jboolean thejret;
102
103 jcas_Locking alock(env);
104 {
105 try {
106 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
107  thejret = the_this->AcceptShapeDecomposition();
108
109 }
110 catch (Standard_Failure) {
111   Standard_SStream Err;
112   Err <<   Standard_Failure::Caught(); 
113   Err << (char) 0;
114   jcas_ThrowException(env,Err.str().c_str());
115 }
116 }
117 alock.Release();
118 return thejret;
119 }
120
121
122
123 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetCurrentFacingModel (JNIEnv *env, jobject theobj, jshort aModel)
124 {
125
126 jcas_Locking alock(env);
127 {
128 try {
129 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
130 the_this->SetCurrentFacingModel((Aspect_TypeOfFacingModel) aModel);
131
132 }
133 catch (Standard_Failure) {
134   Standard_SStream Err;
135   Err <<   Standard_Failure::Caught(); 
136   Err << (char) 0;
137   jcas_ThrowException(env,Err.str().c_str());
138 }
139 }
140 alock.Release();
141
142 }
143
144
145
146 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_CurrentFacingModel (JNIEnv *env, jobject theobj)
147 {
148 jshort thejret;
149
150 jcas_Locking alock(env);
151 {
152 try {
153 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
154  thejret = the_this->CurrentFacingModel();
155
156 }
157 catch (Standard_Failure) {
158   Standard_SStream Err;
159   Err <<   Standard_Failure::Caught(); 
160   Err << (char) 0;
161   jcas_ThrowException(env,Err.str().c_str());
162 }
163 }
164 alock.Release();
165 return thejret;
166 }
167
168
169
170 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1SetColor_11 (JNIEnv *env, jobject theobj, jobject aColor)
171 {
172
173 jcas_Locking alock(env);
174 {
175 try {
176 Quantity_Color* the_aColor = (Quantity_Color*) jcas_GetHandle(env,aColor);
177 if ( the_aColor == NULL ) {
178
179  // The following assumes availability of the default constructor (what may not
180  // always be the case). Therefore explicit exception is thrown if the null
181  // object has been passed.
182  // the_aColor = new Quantity_Color ();
183  // jcas_SetHandle ( env, aColor, the_aColor );
184  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
185
186 }  // end if
187 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
188 the_this->SetColor(*the_aColor);
189
190 }
191 catch (Standard_Failure) {
192   Standard_SStream Err;
193   Err <<   Standard_Failure::Caught(); 
194   Err << (char) 0;
195   jcas_ThrowException(env,Err.str().c_str());
196 }
197 }
198 alock.Release();
199
200 }
201
202
203
204 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1SetColor_12 (JNIEnv *env, jobject theobj, jshort aColor)
205 {
206
207 jcas_Locking alock(env);
208 {
209 try {
210 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
211 the_this->SetColor((Quantity_NameOfColor) aColor);
212
213 }
214 catch (Standard_Failure) {
215   Standard_SStream Err;
216   Err <<   Standard_Failure::Caught(); 
217   Err << (char) 0;
218   jcas_ThrowException(env,Err.str().c_str());
219 }
220 }
221 alock.Release();
222
223 }
224
225
226
227 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetColor (JNIEnv *env, jobject theobj)
228 {
229
230 jcas_Locking alock(env);
231 {
232 try {
233 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
234 the_this->UnsetColor();
235
236 }
237 catch (Standard_Failure) {
238   Standard_SStream Err;
239   Err <<   Standard_Failure::Caught(); 
240   Err << (char) 0;
241   jcas_ThrowException(env,Err.str().c_str());
242 }
243 }
244 alock.Release();
245
246 }
247
248
249
250 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetWidth (JNIEnv *env, jobject theobj, jdouble aValue)
251 {
252
253 jcas_Locking alock(env);
254 {
255 try {
256 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
257 the_this->SetWidth((Standard_Real) aValue);
258
259 }
260 catch (Standard_Failure) {
261   Standard_SStream Err;
262   Err <<   Standard_Failure::Caught(); 
263   Err << (char) 0;
264   jcas_ThrowException(env,Err.str().c_str());
265 }
266 }
267 alock.Release();
268
269 }
270
271
272
273 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetWidth (JNIEnv *env, jobject theobj)
274 {
275
276 jcas_Locking alock(env);
277 {
278 try {
279 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
280 the_this->UnsetWidth();
281
282 }
283 catch (Standard_Failure) {
284   Standard_SStream Err;
285   Err <<   Standard_Failure::Caught(); 
286   Err << (char) 0;
287   jcas_ThrowException(env,Err.str().c_str());
288 }
289 }
290 alock.Release();
291
292 }
293
294
295
296 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AcceptDisplayMode (JNIEnv *env, jobject theobj, jint aMode)
297 {
298 jboolean thejret;
299
300 jcas_Locking alock(env);
301 {
302 try {
303 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
304  thejret = the_this->AcceptDisplayMode((Standard_Integer) aMode);
305
306 }
307 catch (Standard_Failure) {
308   Standard_SStream Err;
309   Err <<   Standard_Failure::Caught(); 
310   Err << (char) 0;
311   jcas_ThrowException(env,Err.str().c_str());
312 }
313 }
314 alock.Release();
315 return thejret;
316 }
317
318
319
320 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_DefaultDisplayMode (JNIEnv *env, jobject theobj)
321 {
322 jint thejret;
323
324 jcas_Locking alock(env);
325 {
326 try {
327 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
328  thejret = the_this->DefaultDisplayMode();
329
330 }
331 catch (Standard_Failure) {
332   Standard_SStream Err;
333   Err <<   Standard_Failure::Caught(); 
334   Err << (char) 0;
335   jcas_ThrowException(env,Err.str().c_str());
336 }
337 }
338 alock.Release();
339 return thejret;
340 }
341
342
343
344 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Redisplay (JNIEnv *env, jobject theobj, jboolean AllModes)
345 {
346
347 jcas_Locking alock(env);
348 {
349 try {
350 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
351 the_this->Redisplay((Standard_Boolean) AllModes);
352
353 }
354 catch (Standard_Failure) {
355   Standard_SStream Err;
356   Err <<   Standard_Failure::Caught(); 
357   Err << (char) 0;
358   jcas_ThrowException(env,Err.str().c_str());
359 }
360 }
361 alock.Release();
362
363 }
364
365
366
367 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetInfiniteState (JNIEnv *env, jobject theobj, jboolean aFlag)
368 {
369
370 jcas_Locking alock(env);
371 {
372 try {
373 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
374 the_this->SetInfiniteState((Standard_Boolean) aFlag);
375
376 }
377 catch (Standard_Failure) {
378   Standard_SStream Err;
379   Err <<   Standard_Failure::Caught(); 
380   Err << (char) 0;
381   jcas_ThrowException(env,Err.str().c_str());
382 }
383 }
384 alock.Release();
385
386 }
387
388
389
390 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_IsInfinite (JNIEnv *env, jobject theobj)
391 {
392 jboolean thejret;
393
394 jcas_Locking alock(env);
395 {
396 try {
397 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
398  thejret = the_this->IsInfinite();
399
400 }
401 catch (Standard_Failure) {
402   Standard_SStream Err;
403   Err <<   Standard_Failure::Caught(); 
404   Err << (char) 0;
405   jcas_ThrowException(env,Err.str().c_str());
406 }
407 }
408 alock.Release();
409 return thejret;
410 }
411
412
413
414 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasInteractiveContext (JNIEnv *env, jobject theobj)
415 {
416 jboolean thejret;
417
418 jcas_Locking alock(env);
419 {
420 try {
421 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
422  thejret = the_this->HasInteractiveContext();
423
424 }
425 catch (Standard_Failure) {
426   Standard_SStream Err;
427   Err <<   Standard_Failure::Caught(); 
428   Err << (char) 0;
429   jcas_ThrowException(env,Err.str().c_str());
430 }
431 }
432 alock.Release();
433 return thejret;
434 }
435
436
437
438 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_GetContext (JNIEnv *env, jobject theobj)
439 {
440 jobject thejret;
441
442 jcas_Locking alock(env);
443 {
444 try {
445 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
446 Handle(AIS_InteractiveContext)* theret = new Handle(AIS_InteractiveContext);
447 *theret = the_this->GetContext();
448 thejret = jcas_CreateObject(env,"CASCADESamplesJni/AIS_InteractiveContext",theret);
449
450 }
451 catch (Standard_Failure) {
452   Standard_SStream Err;
453   Err <<   Standard_Failure::Caught(); 
454   Err << (char) 0;
455   jcas_ThrowException(env,Err.str().c_str());
456 }
457 }
458 alock.Release();
459 return thejret;
460 }
461
462
463
464 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetContext (JNIEnv *env, jobject theobj, jobject aCtx)
465 {
466
467 jcas_Locking alock(env);
468 {
469 try {
470  Handle( AIS_InteractiveContext ) the_aCtx;
471  void*                ptr_aCtx = jcas_GetHandle(env,aCtx);
472  
473  if ( ptr_aCtx != NULL ) the_aCtx = *(   (  Handle( AIS_InteractiveContext )*  )ptr_aCtx   );
474
475 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
476 the_this->SetContext(the_aCtx);
477
478 }
479 catch (Standard_Failure) {
480   Standard_SStream Err;
481   Err <<   Standard_Failure::Caught(); 
482   Err << (char) 0;
483   jcas_ThrowException(env,Err.str().c_str());
484 }
485 }
486 alock.Release();
487
488 }
489
490
491
492 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasOwner (JNIEnv *env, jobject theobj)
493 {
494 jboolean thejret;
495
496 jcas_Locking alock(env);
497 {
498 try {
499 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
500  thejret = the_this->HasOwner();
501
502 }
503 catch (Standard_Failure) {
504   Standard_SStream Err;
505   Err <<   Standard_Failure::Caught(); 
506   Err << (char) 0;
507   jcas_ThrowException(env,Err.str().c_str());
508 }
509 }
510 alock.Release();
511 return thejret;
512 }
513
514
515
516 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_GetOwner (JNIEnv *env, jobject theobj)
517 {
518 jobject thejret;
519
520 jcas_Locking alock(env);
521 {
522 try {
523 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
524 Handle(Standard_Transient)* theret = new Handle(Standard_Transient);
525 *theret = the_this->GetOwner();
526 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Standard_Transient",theret);
527
528 }
529 catch (Standard_Failure) {
530   Standard_SStream Err;
531   Err <<   Standard_Failure::Caught(); 
532   Err << (char) 0;
533   jcas_ThrowException(env,Err.str().c_str());
534 }
535 }
536 alock.Release();
537 return thejret;
538 }
539
540
541
542 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetOwner (JNIEnv *env, jobject theobj, jobject ApplicativeEntity)
543 {
544
545 jcas_Locking alock(env);
546 {
547 try {
548  Handle( Standard_Transient ) the_ApplicativeEntity;
549  void*                ptr_ApplicativeEntity = jcas_GetHandle(env,ApplicativeEntity);
550  
551  if ( ptr_ApplicativeEntity != NULL ) the_ApplicativeEntity = *(   (  Handle( Standard_Transient )*  )ptr_ApplicativeEntity   );
552
553 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
554 the_this->SetOwner(the_ApplicativeEntity);
555
556 }
557 catch (Standard_Failure) {
558   Standard_SStream Err;
559   Err <<   Standard_Failure::Caught(); 
560   Err << (char) 0;
561   jcas_ThrowException(env,Err.str().c_str());
562 }
563 }
564 alock.Release();
565
566 }
567
568
569
570 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_ClearOwner (JNIEnv *env, jobject theobj)
571 {
572
573 jcas_Locking alock(env);
574 {
575 try {
576 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
577 the_this->ClearOwner();
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 jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasUsers (JNIEnv *env, jobject theobj)
594 {
595 jboolean thejret;
596
597 jcas_Locking alock(env);
598 {
599 try {
600 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
601  thejret = the_this->HasUsers();
602
603 }
604 catch (Standard_Failure) {
605   Standard_SStream Err;
606   Err <<   Standard_Failure::Caught(); 
607   Err << (char) 0;
608   jcas_ThrowException(env,Err.str().c_str());
609 }
610 }
611 alock.Release();
612 return thejret;
613 }
614
615
616
617 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Users (JNIEnv *env, jobject theobj)
618 {
619 jobject thejret;
620
621 jcas_Locking alock(env);
622 {
623 try {
624 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
625 const TColStd_ListOfTransient& theret = the_this->Users();
626 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TColStd_ListOfTransient",&theret,0);
627
628 }
629 catch (Standard_Failure) {
630   Standard_SStream Err;
631   Err <<   Standard_Failure::Caught(); 
632   Err << (char) 0;
633   jcas_ThrowException(env,Err.str().c_str());
634 }
635 }
636 alock.Release();
637 return thejret;
638 }
639
640
641
642 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AddUser (JNIEnv *env, jobject theobj, jobject aUser)
643 {
644
645 jcas_Locking alock(env);
646 {
647 try {
648  Handle( Standard_Transient ) the_aUser;
649  void*                ptr_aUser = jcas_GetHandle(env,aUser);
650  
651  if ( ptr_aUser != NULL ) the_aUser = *(   (  Handle( Standard_Transient )*  )ptr_aUser   );
652
653 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
654 the_this->AddUser(the_aUser);
655
656 }
657 catch (Standard_Failure) {
658   Standard_SStream Err;
659   Err <<   Standard_Failure::Caught(); 
660   Err << (char) 0;
661   jcas_ThrowException(env,Err.str().c_str());
662 }
663 }
664 alock.Release();
665
666 }
667
668
669
670 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_ClearUsers (JNIEnv *env, jobject theobj)
671 {
672
673 jcas_Locking alock(env);
674 {
675 try {
676 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
677 the_this->ClearUsers();
678
679 }
680 catch (Standard_Failure) {
681   Standard_SStream Err;
682   Err <<   Standard_Failure::Caught(); 
683   Err << (char) 0;
684   jcas_ThrowException(env,Err.str().c_str());
685 }
686 }
687 alock.Release();
688
689 }
690
691
692
693 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasDisplayMode (JNIEnv *env, jobject theobj)
694 {
695 jboolean thejret;
696
697 jcas_Locking alock(env);
698 {
699 try {
700 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
701  thejret = the_this->HasDisplayMode();
702
703 }
704 catch (Standard_Failure) {
705   Standard_SStream Err;
706   Err <<   Standard_Failure::Caught(); 
707   Err << (char) 0;
708   jcas_ThrowException(env,Err.str().c_str());
709 }
710 }
711 alock.Release();
712 return thejret;
713 }
714
715
716
717 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetDisplayMode (JNIEnv *env, jobject theobj, jint aMode)
718 {
719
720 jcas_Locking alock(env);
721 {
722 try {
723 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
724 the_this->SetDisplayMode((Standard_Integer) aMode);
725
726 }
727 catch (Standard_Failure) {
728   Standard_SStream Err;
729   Err <<   Standard_Failure::Caught(); 
730   Err << (char) 0;
731   jcas_ThrowException(env,Err.str().c_str());
732 }
733 }
734 alock.Release();
735
736 }
737
738
739
740 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetDisplayMode (JNIEnv *env, jobject theobj)
741 {
742
743 jcas_Locking alock(env);
744 {
745 try {
746 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
747 the_this->UnsetDisplayMode();
748
749 }
750 catch (Standard_Failure) {
751   Standard_SStream Err;
752   Err <<   Standard_Failure::Caught(); 
753   Err << (char) 0;
754   jcas_ThrowException(env,Err.str().c_str());
755 }
756 }
757 alock.Release();
758
759 }
760
761
762
763 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_DisplayMode (JNIEnv *env, jobject theobj)
764 {
765 jint thejret;
766
767 jcas_Locking alock(env);
768 {
769 try {
770 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
771  thejret = the_this->DisplayMode();
772
773 }
774 catch (Standard_Failure) {
775   Standard_SStream Err;
776   Err <<   Standard_Failure::Caught(); 
777   Err << (char) 0;
778   jcas_ThrowException(env,Err.str().c_str());
779 }
780 }
781 alock.Release();
782 return thejret;
783 }
784
785
786
787 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasSelectionMode (JNIEnv *env, jobject theobj)
788 {
789 jboolean thejret;
790
791 jcas_Locking alock(env);
792 {
793 try {
794 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
795  thejret = the_this->HasSelectionMode();
796
797 }
798 catch (Standard_Failure) {
799   Standard_SStream Err;
800   Err <<   Standard_Failure::Caught(); 
801   Err << (char) 0;
802   jcas_ThrowException(env,Err.str().c_str());
803 }
804 }
805 alock.Release();
806 return thejret;
807 }
808
809
810
811 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SelectionMode (JNIEnv *env, jobject theobj)
812 {
813 jint thejret;
814
815 jcas_Locking alock(env);
816 {
817 try {
818 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
819  thejret = the_this->SelectionMode();
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 return thejret;
831 }
832
833
834
835 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetSelectionMode (JNIEnv *env, jobject theobj, jint aMode)
836 {
837
838 jcas_Locking alock(env);
839 {
840 try {
841 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
842 the_this->SetSelectionMode((Standard_Integer) aMode);
843
844 }
845 catch (Standard_Failure) {
846   Standard_SStream Err;
847   Err <<   Standard_Failure::Caught(); 
848   Err << (char) 0;
849   jcas_ThrowException(env,Err.str().c_str());
850 }
851 }
852 alock.Release();
853
854 }
855
856
857
858 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetSelectionMode (JNIEnv *env, jobject theobj)
859 {
860
861 jcas_Locking alock(env);
862 {
863 try {
864 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
865 the_this->UnsetSelectionMode();
866
867 }
868 catch (Standard_Failure) {
869   Standard_SStream Err;
870   Err <<   Standard_Failure::Caught(); 
871   Err << (char) 0;
872   jcas_ThrowException(env,Err.str().c_str());
873 }
874 }
875 alock.Release();
876
877 }
878
879
880
881 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SelectionPriority (JNIEnv *env, jobject theobj)
882 {
883 jint thejret;
884
885 jcas_Locking alock(env);
886 {
887 try {
888 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
889  thejret = the_this->SelectionPriority();
890
891 }
892 catch (Standard_Failure) {
893   Standard_SStream Err;
894   Err <<   Standard_Failure::Caught(); 
895   Err << (char) 0;
896   jcas_ThrowException(env,Err.str().c_str());
897 }
898 }
899 alock.Release();
900 return thejret;
901 }
902
903
904
905 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetSelectionPriority (JNIEnv *env, jobject theobj, jint aPriority)
906 {
907
908 jcas_Locking alock(env);
909 {
910 try {
911 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
912 the_this->SetSelectionPriority((Standard_Integer) aPriority);
913
914 }
915 catch (Standard_Failure) {
916   Standard_SStream Err;
917   Err <<   Standard_Failure::Caught(); 
918   Err << (char) 0;
919   jcas_ThrowException(env,Err.str().c_str());
920 }
921 }
922 alock.Release();
923
924 }
925
926
927
928 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetSelectionPriority (JNIEnv *env, jobject theobj)
929 {
930
931 jcas_Locking alock(env);
932 {
933 try {
934 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
935 the_this->UnsetSelectionPriority();
936
937 }
938 catch (Standard_Failure) {
939   Standard_SStream Err;
940   Err <<   Standard_Failure::Caught(); 
941   Err << (char) 0;
942   jcas_ThrowException(env,Err.str().c_str());
943 }
944 }
945 alock.Release();
946
947 }
948
949
950
951 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasSelectionPriority (JNIEnv *env, jobject theobj)
952 {
953 jboolean thejret;
954
955 jcas_Locking alock(env);
956 {
957 try {
958 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
959  thejret = the_this->HasSelectionPriority();
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 return thejret;
971 }
972
973
974
975 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasHilightMode (JNIEnv *env, jobject theobj)
976 {
977 jboolean thejret;
978
979 jcas_Locking alock(env);
980 {
981 try {
982 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
983  thejret = the_this->HasHilightMode();
984
985 }
986 catch (Standard_Failure) {
987   Standard_SStream Err;
988   Err <<   Standard_Failure::Caught(); 
989   Err << (char) 0;
990   jcas_ThrowException(env,Err.str().c_str());
991 }
992 }
993 alock.Release();
994 return thejret;
995 }
996
997
998
999 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HilightMode (JNIEnv *env, jobject theobj)
1000 {
1001 jint thejret;
1002
1003 jcas_Locking alock(env);
1004 {
1005 try {
1006 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1007  thejret = the_this->HilightMode();
1008
1009 }
1010 catch (Standard_Failure) {
1011   Standard_SStream Err;
1012   Err <<   Standard_Failure::Caught(); 
1013   Err << (char) 0;
1014   jcas_ThrowException(env,Err.str().c_str());
1015 }
1016 }
1017 alock.Release();
1018 return thejret;
1019 }
1020
1021
1022
1023 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetHilightMode (JNIEnv *env, jobject theobj, jint anIndex)
1024 {
1025
1026 jcas_Locking alock(env);
1027 {
1028 try {
1029 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1030 the_this->SetHilightMode((Standard_Integer) anIndex);
1031
1032 }
1033 catch (Standard_Failure) {
1034   Standard_SStream Err;
1035   Err <<   Standard_Failure::Caught(); 
1036   Err << (char) 0;
1037   jcas_ThrowException(env,Err.str().c_str());
1038 }
1039 }
1040 alock.Release();
1041
1042 }
1043
1044
1045
1046 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetHilightMode (JNIEnv *env, jobject theobj)
1047 {
1048
1049 jcas_Locking alock(env);
1050 {
1051 try {
1052 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1053 the_this->UnsetHilightMode();
1054
1055 }
1056 catch (Standard_Failure) {
1057   Standard_SStream Err;
1058   Err <<   Standard_Failure::Caught(); 
1059   Err << (char) 0;
1060   jcas_ThrowException(env,Err.str().c_str());
1061 }
1062 }
1063 alock.Release();
1064
1065 }
1066
1067
1068
1069 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasColor (JNIEnv *env, jobject theobj)
1070 {
1071 jboolean thejret;
1072
1073 jcas_Locking alock(env);
1074 {
1075 try {
1076 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1077  thejret = the_this->HasColor();
1078
1079 }
1080 catch (Standard_Failure) {
1081   Standard_SStream Err;
1082   Err <<   Standard_Failure::Caught(); 
1083   Err << (char) 0;
1084   jcas_ThrowException(env,Err.str().c_str());
1085 }
1086 }
1087 alock.Release();
1088 return thejret;
1089 }
1090
1091
1092
1093 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1Color_11 (JNIEnv *env, jobject theobj)
1094 {
1095 jshort thejret;
1096
1097 jcas_Locking alock(env);
1098 {
1099 try {
1100 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1101  thejret = the_this->Color();
1102
1103 }
1104 catch (Standard_Failure) {
1105   Standard_SStream Err;
1106   Err <<   Standard_Failure::Caught(); 
1107   Err << (char) 0;
1108   jcas_ThrowException(env,Err.str().c_str());
1109 }
1110 }
1111 alock.Release();
1112 return thejret;
1113 }
1114
1115
1116
1117 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1Color_12 (JNIEnv *env, jobject theobj, jobject aColor)
1118 {
1119
1120 jcas_Locking alock(env);
1121 {
1122 try {
1123 Quantity_Color* the_aColor = (Quantity_Color*) jcas_GetHandle(env,aColor);
1124 if ( the_aColor == NULL ) {
1125
1126  // The following assumes availability of the default constructor (what may not
1127  // always be the case). Therefore explicit exception is thrown if the null
1128  // object has been passed.
1129  // the_aColor = new Quantity_Color ();
1130  // jcas_SetHandle ( env, aColor, the_aColor );
1131  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1132
1133 }  // end if
1134 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1135 the_this->Color(*the_aColor);
1136
1137 }
1138 catch (Standard_Failure) {
1139   Standard_SStream Err;
1140   Err <<   Standard_Failure::Caught(); 
1141   Err << (char) 0;
1142   jcas_ThrowException(env,Err.str().c_str());
1143 }
1144 }
1145 alock.Release();
1146
1147 }
1148
1149
1150
1151 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasWidth (JNIEnv *env, jobject theobj)
1152 {
1153 jboolean thejret;
1154
1155 jcas_Locking alock(env);
1156 {
1157 try {
1158 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1159  thejret = the_this->HasWidth();
1160
1161 }
1162 catch (Standard_Failure) {
1163   Standard_SStream Err;
1164   Err <<   Standard_Failure::Caught(); 
1165   Err << (char) 0;
1166   jcas_ThrowException(env,Err.str().c_str());
1167 }
1168 }
1169 alock.Release();
1170 return thejret;
1171 }
1172
1173
1174
1175 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Width (JNIEnv *env, jobject theobj)
1176 {
1177 jdouble thejret;
1178
1179 jcas_Locking alock(env);
1180 {
1181 try {
1182 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1183  thejret = the_this->Width();
1184
1185 }
1186 catch (Standard_Failure) {
1187   Standard_SStream Err;
1188   Err <<   Standard_Failure::Caught(); 
1189   Err << (char) 0;
1190   jcas_ThrowException(env,Err.str().c_str());
1191 }
1192 }
1193 alock.Release();
1194 return thejret;
1195 }
1196
1197
1198
1199 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasMaterial (JNIEnv *env, jobject theobj)
1200 {
1201 jboolean thejret;
1202
1203 jcas_Locking alock(env);
1204 {
1205 try {
1206 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1207  thejret = the_this->HasMaterial();
1208
1209 }
1210 catch (Standard_Failure) {
1211   Standard_SStream Err;
1212   Err <<   Standard_Failure::Caught(); 
1213   Err << (char) 0;
1214   jcas_ThrowException(env,Err.str().c_str());
1215 }
1216 }
1217 alock.Release();
1218 return thejret;
1219 }
1220
1221
1222
1223 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Material (JNIEnv *env, jobject theobj)
1224 {
1225 jshort thejret;
1226
1227 jcas_Locking alock(env);
1228 {
1229 try {
1230 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1231  thejret = the_this->Material();
1232
1233 }
1234 catch (Standard_Failure) {
1235   Standard_SStream Err;
1236   Err <<   Standard_Failure::Caught(); 
1237   Err << (char) 0;
1238   jcas_ThrowException(env,Err.str().c_str());
1239 }
1240 }
1241 alock.Release();
1242 return thejret;
1243 }
1244
1245
1246
1247 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1SetMaterial_11 (JNIEnv *env, jobject theobj, jshort aName)
1248 {
1249
1250 jcas_Locking alock(env);
1251 {
1252 try {
1253 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1254 the_this->SetMaterial((Graphic3d_NameOfMaterial) aName);
1255
1256 }
1257 catch (Standard_Failure) {
1258   Standard_SStream Err;
1259   Err <<   Standard_Failure::Caught(); 
1260   Err << (char) 0;
1261   jcas_ThrowException(env,Err.str().c_str());
1262 }
1263 }
1264 alock.Release();
1265
1266 }
1267
1268
1269
1270 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1SetMaterial_12 (JNIEnv *env, jobject theobj, jobject aName)
1271 {
1272
1273 jcas_Locking alock(env);
1274 {
1275 try {
1276 Graphic3d_MaterialAspect* the_aName = (Graphic3d_MaterialAspect*) jcas_GetHandle(env,aName);
1277 if ( the_aName == NULL ) {
1278
1279  // The following assumes availability of the default constructor (what may not
1280  // always be the case). Therefore explicit exception is thrown if the null
1281  // object has been passed.
1282  // the_aName = new Graphic3d_MaterialAspect ();
1283  // jcas_SetHandle ( env, aName, the_aName );
1284  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1285
1286 }  // end if
1287 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1288 the_this->SetMaterial(*the_aName);
1289
1290 }
1291 catch (Standard_Failure) {
1292   Standard_SStream Err;
1293   Err <<   Standard_Failure::Caught(); 
1294   Err << (char) 0;
1295   jcas_ThrowException(env,Err.str().c_str());
1296 }
1297 }
1298 alock.Release();
1299
1300 }
1301
1302
1303
1304 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetMaterial (JNIEnv *env, jobject theobj)
1305 {
1306
1307 jcas_Locking alock(env);
1308 {
1309 try {
1310 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1311 the_this->UnsetMaterial();
1312
1313 }
1314 catch (Standard_Failure) {
1315   Standard_SStream Err;
1316   Err <<   Standard_Failure::Caught(); 
1317   Err << (char) 0;
1318   jcas_ThrowException(env,Err.str().c_str());
1319 }
1320 }
1321 alock.Release();
1322
1323 }
1324
1325
1326
1327 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetTransparency (JNIEnv *env, jobject theobj, jdouble aValue)
1328 {
1329
1330 jcas_Locking alock(env);
1331 {
1332 try {
1333 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1334 the_this->SetTransparency((Standard_Real) aValue);
1335
1336 }
1337 catch (Standard_Failure) {
1338   Standard_SStream Err;
1339   Err <<   Standard_Failure::Caught(); 
1340   Err << (char) 0;
1341   jcas_ThrowException(env,Err.str().c_str());
1342 }
1343 }
1344 alock.Release();
1345
1346 }
1347
1348
1349
1350 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_IsTransparent (JNIEnv *env, jobject theobj)
1351 {
1352 jboolean thejret;
1353
1354 jcas_Locking alock(env);
1355 {
1356 try {
1357 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1358  thejret = the_this->IsTransparent();
1359
1360 }
1361 catch (Standard_Failure) {
1362   Standard_SStream Err;
1363   Err <<   Standard_Failure::Caught(); 
1364   Err << (char) 0;
1365   jcas_ThrowException(env,Err.str().c_str());
1366 }
1367 }
1368 alock.Release();
1369 return thejret;
1370 }
1371
1372
1373
1374 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Transparency (JNIEnv *env, jobject theobj)
1375 {
1376 jdouble thejret;
1377
1378 jcas_Locking alock(env);
1379 {
1380 try {
1381 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1382  thejret = the_this->Transparency();
1383
1384 }
1385 catch (Standard_Failure) {
1386   Standard_SStream Err;
1387   Err <<   Standard_Failure::Caught(); 
1388   Err << (char) 0;
1389   jcas_ThrowException(env,Err.str().c_str());
1390 }
1391 }
1392 alock.Release();
1393 return thejret;
1394 }
1395
1396
1397
1398 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetTransparency (JNIEnv *env, jobject theobj)
1399 {
1400
1401 jcas_Locking alock(env);
1402 {
1403 try {
1404 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1405 the_this->UnsetTransparency();
1406
1407 }
1408 catch (Standard_Failure) {
1409   Standard_SStream Err;
1410   Err <<   Standard_Failure::Caught(); 
1411   Err << (char) 0;
1412   jcas_ThrowException(env,Err.str().c_str());
1413 }
1414 }
1415 alock.Release();
1416
1417 }
1418
1419
1420
1421 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetAttributes (JNIEnv *env, jobject theobj, jobject aDrawer)
1422 {
1423
1424 jcas_Locking alock(env);
1425 {
1426 try {
1427  Handle( AIS_Drawer ) the_aDrawer;
1428  void*                ptr_aDrawer = jcas_GetHandle(env,aDrawer);
1429  
1430  if ( ptr_aDrawer != NULL ) the_aDrawer = *(   (  Handle( AIS_Drawer )*  )ptr_aDrawer   );
1431
1432 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1433 the_this->SetAttributes(the_aDrawer);
1434
1435 }
1436 catch (Standard_Failure) {
1437   Standard_SStream Err;
1438   Err <<   Standard_Failure::Caught(); 
1439   Err << (char) 0;
1440   jcas_ThrowException(env,Err.str().c_str());
1441 }
1442 }
1443 alock.Release();
1444
1445 }
1446
1447
1448
1449 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Attributes (JNIEnv *env, jobject theobj)
1450 {
1451 jobject thejret;
1452
1453 jcas_Locking alock(env);
1454 {
1455 try {
1456 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1457 Handle(AIS_Drawer)* theret = new Handle(AIS_Drawer);
1458 *theret = the_this->Attributes();
1459 thejret = jcas_CreateObject(env,"CASCADESamplesJni/AIS_Drawer",theret);
1460
1461 }
1462 catch (Standard_Failure) {
1463   Standard_SStream Err;
1464   Err <<   Standard_Failure::Caught(); 
1465   Err << (char) 0;
1466   jcas_ThrowException(env,Err.str().c_str());
1467 }
1468 }
1469 alock.Release();
1470 return thejret;
1471 }
1472
1473
1474
1475 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetAttributes (JNIEnv *env, jobject theobj)
1476 {
1477
1478 jcas_Locking alock(env);
1479 {
1480 try {
1481 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1482 the_this->UnsetAttributes();
1483
1484 }
1485 catch (Standard_Failure) {
1486   Standard_SStream Err;
1487   Err <<   Standard_Failure::Caught(); 
1488   Err << (char) 0;
1489   jcas_ThrowException(env,Err.str().c_str());
1490 }
1491 }
1492 alock.Release();
1493
1494 }
1495
1496
1497
1498 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1State_11 (JNIEnv *env, jobject theobj, jint theState)
1499 {
1500
1501 jcas_Locking alock(env);
1502 {
1503 try {
1504 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1505 the_this->State((Standard_Integer) theState);
1506
1507 }
1508 catch (Standard_Failure) {
1509   Standard_SStream Err;
1510   Err <<   Standard_Failure::Caught(); 
1511   Err << (char) 0;
1512   jcas_ThrowException(env,Err.str().c_str());
1513 }
1514 }
1515 alock.Release();
1516
1517 }
1518
1519
1520
1521 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_AIS_1InteractiveObject_1State_12 (JNIEnv *env, jobject theobj)
1522 {
1523 jint thejret;
1524
1525 jcas_Locking alock(env);
1526 {
1527 try {
1528 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1529  thejret = the_this->State();
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 return thejret;
1541 }
1542
1543
1544
1545 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetDegenerateModel (JNIEnv *env, jobject theobj, jshort aModel, jdouble aRatio)
1546 {
1547
1548 jcas_Locking alock(env);
1549 {
1550 try {
1551 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1552 the_this->SetDegenerateModel((Aspect_TypeOfDegenerateModel) aModel,(Quantity_Ratio) aRatio);
1553
1554 }
1555 catch (Standard_Failure) {
1556   Standard_SStream Err;
1557   Err <<   Standard_Failure::Caught(); 
1558   Err << (char) 0;
1559   jcas_ThrowException(env,Err.str().c_str());
1560 }
1561 }
1562 alock.Release();
1563
1564 }
1565
1566
1567
1568 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_DegenerateModel (JNIEnv *env, jobject theobj, jobject aRatio)
1569 {
1570 jshort thejret;
1571
1572 jcas_Locking alock(env);
1573 {
1574 try {
1575 Standard_Real the_aRatio = jcas_GetReal(env,aRatio);
1576 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1577  thejret = the_this->DegenerateModel(the_aRatio);
1578 jcas_SetReal(env,aRatio,the_aRatio);
1579
1580 }
1581 catch (Standard_Failure) {
1582   Standard_SStream Err;
1583   Err <<   Standard_Failure::Caught(); 
1584   Err << (char) 0;
1585   jcas_ThrowException(env,Err.str().c_str());
1586 }
1587 }
1588 alock.Release();
1589 return thejret;
1590 }
1591
1592
1593
1594 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetTransformation (JNIEnv *env, jobject theobj, jobject aTranformation, jboolean postConcatenate, jboolean updateSelection)
1595 {
1596
1597 jcas_Locking alock(env);
1598 {
1599 try {
1600  Handle( Geom_Transformation ) the_aTranformation;
1601  void*                ptr_aTranformation = jcas_GetHandle(env,aTranformation);
1602  
1603  if ( ptr_aTranformation != NULL ) the_aTranformation = *(   (  Handle( Geom_Transformation )*  )ptr_aTranformation   );
1604
1605 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1606 the_this->SetTransformation(the_aTranformation,(Standard_Boolean) postConcatenate,(Standard_Boolean) updateSelection);
1607
1608 }
1609 catch (Standard_Failure) {
1610   Standard_SStream Err;
1611   Err <<   Standard_Failure::Caught(); 
1612   Err << (char) 0;
1613   jcas_ThrowException(env,Err.str().c_str());
1614 }
1615 }
1616 alock.Release();
1617
1618 }
1619
1620
1621
1622 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_UnsetTransformation (JNIEnv *env, jobject theobj)
1623 {
1624
1625 jcas_Locking alock(env);
1626 {
1627 try {
1628 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1629 the_this->UnsetTransformation();
1630
1631 }
1632 catch (Standard_Failure) {
1633   Standard_SStream Err;
1634   Err <<   Standard_Failure::Caught(); 
1635   Err << (char) 0;
1636   jcas_ThrowException(env,Err.str().c_str());
1637 }
1638 }
1639 alock.Release();
1640
1641 }
1642
1643
1644
1645 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Transformation (JNIEnv *env, jobject theobj)
1646 {
1647 jobject thejret;
1648
1649 jcas_Locking alock(env);
1650 {
1651 try {
1652 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1653 Handle(Geom_Transformation)* theret = new Handle(Geom_Transformation);
1654 *theret = the_this->Transformation();
1655 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Geom_Transformation",theret);
1656
1657 }
1658 catch (Standard_Failure) {
1659   Standard_SStream Err;
1660   Err <<   Standard_Failure::Caught(); 
1661   Err << (char) 0;
1662   jcas_ThrowException(env,Err.str().c_str());
1663 }
1664 }
1665 alock.Release();
1666 return thejret;
1667 }
1668
1669
1670
1671 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasTransformation (JNIEnv *env, jobject theobj)
1672 {
1673 jboolean thejret;
1674
1675 jcas_Locking alock(env);
1676 {
1677 try {
1678 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1679  thejret = the_this->HasTransformation();
1680
1681 }
1682 catch (Standard_Failure) {
1683   Standard_SStream Err;
1684   Err <<   Standard_Failure::Caught(); 
1685   Err << (char) 0;
1686   jcas_ThrowException(env,Err.str().c_str());
1687 }
1688 }
1689 alock.Release();
1690 return thejret;
1691 }
1692
1693
1694
1695 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasPresentation (JNIEnv *env, jobject theobj)
1696 {
1697 jboolean thejret;
1698
1699 jcas_Locking alock(env);
1700 {
1701 try {
1702 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1703  thejret = the_this->HasPresentation();
1704
1705 }
1706 catch (Standard_Failure) {
1707   Standard_SStream Err;
1708   Err <<   Standard_Failure::Caught(); 
1709   Err << (char) 0;
1710   jcas_ThrowException(env,Err.str().c_str());
1711 }
1712 }
1713 alock.Release();
1714 return thejret;
1715 }
1716
1717
1718
1719 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_Presentation (JNIEnv *env, jobject theobj)
1720 {
1721 jobject thejret;
1722
1723 jcas_Locking alock(env);
1724 {
1725 try {
1726 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1727 Handle(Prs3d_Presentation)* theret = new Handle(Prs3d_Presentation);
1728 *theret = the_this->Presentation();
1729 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Prs3d_Presentation",theret);
1730
1731 }
1732 catch (Standard_Failure) {
1733   Standard_SStream Err;
1734   Err <<   Standard_Failure::Caught(); 
1735   Err << (char) 0;
1736   jcas_ThrowException(env,Err.str().c_str());
1737 }
1738 }
1739 alock.Release();
1740 return thejret;
1741 }
1742
1743
1744
1745 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetAspect (JNIEnv *env, jobject theobj, jobject anAspect, jboolean globalChange)
1746 {
1747
1748 jcas_Locking alock(env);
1749 {
1750 try {
1751  Handle( Prs3d_BasicAspect ) the_anAspect;
1752  void*                ptr_anAspect = jcas_GetHandle(env,anAspect);
1753  
1754  if ( ptr_anAspect != NULL ) the_anAspect = *(   (  Handle( Prs3d_BasicAspect )*  )ptr_anAspect   );
1755
1756 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1757 the_this->SetAspect(the_anAspect,(Standard_Boolean) globalChange);
1758
1759 }
1760 catch (Standard_Failure) {
1761   Standard_SStream Err;
1762   Err <<   Standard_Failure::Caught(); 
1763   Err << (char) 0;
1764   jcas_ThrowException(env,Err.str().c_str());
1765 }
1766 }
1767 alock.Release();
1768
1769 }
1770
1771
1772
1773 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_SetPolygonOffsets (JNIEnv *env, jobject theobj, jint aMode, jdouble aFactor, jdouble aUnits)
1774 {
1775
1776 jcas_Locking alock(env);
1777 {
1778 try {
1779 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1780 the_this->SetPolygonOffsets((Standard_Integer) aMode,(Standard_Real) aFactor,(Standard_Real) aUnits);
1781
1782 }
1783 catch (Standard_Failure) {
1784   Standard_SStream Err;
1785   Err <<   Standard_Failure::Caught(); 
1786   Err << (char) 0;
1787   jcas_ThrowException(env,Err.str().c_str());
1788 }
1789 }
1790 alock.Release();
1791
1792 }
1793
1794
1795
1796 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_HasPolygonOffsets (JNIEnv *env, jobject theobj)
1797 {
1798 jboolean thejret;
1799
1800 jcas_Locking alock(env);
1801 {
1802 try {
1803 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1804  thejret = the_this->HasPolygonOffsets();
1805
1806 }
1807 catch (Standard_Failure) {
1808   Standard_SStream Err;
1809   Err <<   Standard_Failure::Caught(); 
1810   Err << (char) 0;
1811   jcas_ThrowException(env,Err.str().c_str());
1812 }
1813 }
1814 alock.Release();
1815 return thejret;
1816 }
1817
1818
1819
1820 JNIEXPORT void JNICALL Java_CASCADESamplesJni_AIS_1InteractiveObject_PolygonOffsets (JNIEnv *env, jobject theobj, jobject aMode, jobject aFactor, jobject aUnits)
1821 {
1822
1823 jcas_Locking alock(env);
1824 {
1825 try {
1826 Standard_Integer the_aMode = jcas_GetInteger(env,aMode);
1827 Standard_Real the_aFactor = jcas_GetReal(env,aFactor);
1828 Standard_Real the_aUnits = jcas_GetReal(env,aUnits);
1829 Handle(AIS_InteractiveObject) the_this = *((Handle(AIS_InteractiveObject)*) jcas_GetHandle(env,theobj));
1830 the_this->PolygonOffsets(the_aMode,the_aFactor,the_aUnits);
1831 jcas_SetInteger(env,aMode,the_aMode);
1832 jcas_SetReal(env,aFactor,the_aFactor);
1833 jcas_SetReal(env,aUnits,the_aUnits);
1834
1835 }
1836 catch (Standard_Failure) {
1837   Standard_SStream Err;
1838   Err <<   Standard_Failure::Caught(); 
1839   Err << (char) 0;
1840   jcas_ThrowException(env,Err.str().c_str());
1841 }
1842 }
1843 alock.Release();
1844
1845 }
1846
1847
1848 }