Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_V3d_Viewer_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_V3d_Viewer.h>
22 #include <V3d_Viewer.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 <Aspect_GraphicDevice.hxx>
30 #include <Standard_ExtString.hxx>
31 #include <Standard_CString.hxx>
32 #include <Standard_Real.hxx>
33 #include <V3d_TypeOfOrientation.hxx>
34 #include <Quantity_NameOfColor.hxx>
35 #include <V3d_TypeOfVisualization.hxx>
36 #include <V3d_TypeOfShadingModel.hxx>
37 #include <V3d_TypeOfUpdate.hxx>
38 #include <Standard_Boolean.hxx>
39 #include <V3d_TypeOfSurfaceDetail.hxx>
40 #include <V3d_View.hxx>
41 #include <V3d_OrthographicView.hxx>
42 #include <V3d_PerspectiveView.hxx>
43 #include <Quantity_TypeOfColor.hxx>
44 #include <Quantity_Color.hxx>
45 #include <V3d_TypeOfView.hxx>
46 #include <gp_Ax3.hxx>
47 #include <V3d_Light.hxx>
48 #include <V3d_Plane.hxx>
49 #include <Visual3d_ViewManager.hxx>
50 #include <Aspect_GridType.hxx>
51 #include <Aspect_GridDrawMode.hxx>
52 #include <Graphic3d_AspectMarker3d.hxx>
53 #include <Aspect_Grid.hxx>
54 #include <Standard_Integer.hxx>
55
56
57 extern "C" {
58
59
60 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1Create_10 (JNIEnv *env, jobject theobj, jobject Device, jstring aName, jobject aDomain, jdouble ViewSize, jshort ViewProj, jshort ViewBackground, jshort Visualization, jshort ShadingModel, jshort UpdateMode, jboolean ComputedMode, jboolean DefaultComputedMode, jshort SurfaceDetail)
61 {
62
63 jcas_Locking alock(env);
64 {
65 try {
66  Handle( Aspect_GraphicDevice ) the_Device;
67  void*                ptr_Device = jcas_GetHandle(env,Device);
68  
69  if ( ptr_Device != NULL ) the_Device = *(   (  Handle( Aspect_GraphicDevice )*  )ptr_Device   );
70
71 Standard_ExtString the_aName = jcas_ConvertToExtString(env,aName);
72 Standard_CString the_aDomain = jcas_ConvertToCString(env,aDomain);
73 Handle(V3d_Viewer)* theret = new Handle(V3d_Viewer);
74 *theret = new V3d_Viewer(the_Device,the_aName,the_aDomain,(Quantity_Length) ViewSize,(V3d_TypeOfOrientation) ViewProj,(Quantity_NameOfColor) ViewBackground,(V3d_TypeOfVisualization) Visualization,(V3d_TypeOfShadingModel) ShadingModel,(V3d_TypeOfUpdate) UpdateMode,(Standard_Boolean) ComputedMode,(Standard_Boolean) DefaultComputedMode,(V3d_TypeOfSurfaceDetail) SurfaceDetail);
75 jcas_SetHandle(env,theobj,theret);
76
77 }
78 catch (Standard_Failure) {
79   Standard_SStream Err;
80   Err <<   Standard_Failure::Caught(); 
81   Err << (char) 0;
82   jcas_ThrowException(env,Err.str().c_str());
83 }
84 }
85 alock.Release();
86
87 }
88
89
90
91 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_CreateView (JNIEnv *env, jobject theobj)
92 {
93 jobject thejret;
94
95 jcas_Locking alock(env);
96 {
97 try {
98 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
99 Handle(V3d_View)* theret = new Handle(V3d_View);
100 *theret = the_this->CreateView();
101 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_View",theret);
102
103 }
104 catch (Standard_Failure) {
105   Standard_SStream Err;
106   Err <<   Standard_Failure::Caught(); 
107   Err << (char) 0;
108   jcas_ThrowException(env,Err.str().c_str());
109 }
110 }
111 alock.Release();
112 return thejret;
113 }
114
115
116
117 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultOrthographicView (JNIEnv *env, jobject theobj)
118 {
119 jobject thejret;
120
121 jcas_Locking alock(env);
122 {
123 try {
124 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
125 Handle(V3d_OrthographicView)* theret = new Handle(V3d_OrthographicView);
126 *theret = the_this->DefaultOrthographicView();
127 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_OrthographicView",theret);
128
129 }
130 catch (Standard_Failure) {
131   Standard_SStream Err;
132   Err <<   Standard_Failure::Caught(); 
133   Err << (char) 0;
134   jcas_ThrowException(env,Err.str().c_str());
135 }
136 }
137 alock.Release();
138 return thejret;
139 }
140
141
142
143 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultPerspectiveView (JNIEnv *env, jobject theobj)
144 {
145 jobject thejret;
146
147 jcas_Locking alock(env);
148 {
149 try {
150 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
151 Handle(V3d_PerspectiveView)* theret = new Handle(V3d_PerspectiveView);
152 *theret = the_this->DefaultPerspectiveView();
153 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_PerspectiveView",theret);
154
155 }
156 catch (Standard_Failure) {
157   Standard_SStream Err;
158   Err <<   Standard_Failure::Caught(); 
159   Err << (char) 0;
160   jcas_ThrowException(env,Err.str().c_str());
161 }
162 }
163 alock.Release();
164 return thejret;
165 }
166
167
168
169 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetViewOn_11 (JNIEnv *env, jobject theobj)
170 {
171
172 jcas_Locking alock(env);
173 {
174 try {
175 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
176 the_this->SetViewOn();
177
178 }
179 catch (Standard_Failure) {
180   Standard_SStream Err;
181   Err <<   Standard_Failure::Caught(); 
182   Err << (char) 0;
183   jcas_ThrowException(env,Err.str().c_str());
184 }
185 }
186 alock.Release();
187
188 }
189
190
191
192 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetViewOn_12 (JNIEnv *env, jobject theobj, jobject View)
193 {
194
195 jcas_Locking alock(env);
196 {
197 try {
198  Handle( V3d_View ) the_View;
199  void*                ptr_View = jcas_GetHandle(env,View);
200  
201  if ( ptr_View != NULL ) the_View = *(   (  Handle( V3d_View )*  )ptr_View   );
202
203 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
204 the_this->SetViewOn(the_View);
205
206 }
207 catch (Standard_Failure) {
208   Standard_SStream Err;
209   Err <<   Standard_Failure::Caught(); 
210   Err << (char) 0;
211   jcas_ThrowException(env,Err.str().c_str());
212 }
213 }
214 alock.Release();
215
216 }
217
218
219
220 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetViewOff_11 (JNIEnv *env, jobject theobj)
221 {
222
223 jcas_Locking alock(env);
224 {
225 try {
226 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
227 the_this->SetViewOff();
228
229 }
230 catch (Standard_Failure) {
231   Standard_SStream Err;
232   Err <<   Standard_Failure::Caught(); 
233   Err << (char) 0;
234   jcas_ThrowException(env,Err.str().c_str());
235 }
236 }
237 alock.Release();
238
239 }
240
241
242
243 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetViewOff_12 (JNIEnv *env, jobject theobj, jobject View)
244 {
245
246 jcas_Locking alock(env);
247 {
248 try {
249  Handle( V3d_View ) the_View;
250  void*                ptr_View = jcas_GetHandle(env,View);
251  
252  if ( ptr_View != NULL ) the_View = *(   (  Handle( V3d_View )*  )ptr_View   );
253
254 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
255 the_this->SetViewOff(the_View);
256
257 }
258 catch (Standard_Failure) {
259   Standard_SStream Err;
260   Err <<   Standard_Failure::Caught(); 
261   Err << (char) 0;
262   jcas_ThrowException(env,Err.str().c_str());
263 }
264 }
265 alock.Release();
266
267 }
268
269
270
271 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Update (JNIEnv *env, jobject theobj)
272 {
273
274 jcas_Locking alock(env);
275 {
276 try {
277 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
278 the_this->Update();
279
280 }
281 catch (Standard_Failure) {
282   Standard_SStream Err;
283   Err <<   Standard_Failure::Caught(); 
284   Err << (char) 0;
285   jcas_ThrowException(env,Err.str().c_str());
286 }
287 }
288 alock.Release();
289
290 }
291
292
293
294 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_UpdateLights (JNIEnv *env, jobject theobj)
295 {
296
297 jcas_Locking alock(env);
298 {
299 try {
300 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
301 the_this->UpdateLights();
302
303 }
304 catch (Standard_Failure) {
305   Standard_SStream Err;
306   Err <<   Standard_Failure::Caught(); 
307   Err << (char) 0;
308   jcas_ThrowException(env,Err.str().c_str());
309 }
310 }
311 alock.Release();
312
313 }
314
315
316
317 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Redraw (JNIEnv *env, jobject theobj)
318 {
319
320 jcas_Locking alock(env);
321 {
322 try {
323 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
324 the_this->Redraw();
325
326 }
327 catch (Standard_Failure) {
328   Standard_SStream Err;
329   Err <<   Standard_Failure::Caught(); 
330   Err << (char) 0;
331   jcas_ThrowException(env,Err.str().c_str());
332 }
333 }
334 alock.Release();
335
336 }
337
338
339
340 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Remove (JNIEnv *env, jobject theobj)
341 {
342
343 jcas_Locking alock(env);
344 {
345 try {
346 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
347 the_this->Remove();
348
349 }
350 catch (Standard_Failure) {
351   Standard_SStream Err;
352   Err <<   Standard_Failure::Caught(); 
353   Err << (char) 0;
354   jcas_ThrowException(env,Err.str().c_str());
355 }
356 }
357 alock.Release();
358
359 }
360
361
362
363 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Erase (JNIEnv *env, jobject theobj)
364 {
365
366 jcas_Locking alock(env);
367 {
368 try {
369 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
370 the_this->Erase();
371
372 }
373 catch (Standard_Failure) {
374   Standard_SStream Err;
375   Err <<   Standard_Failure::Caught(); 
376   Err << (char) 0;
377   jcas_ThrowException(env,Err.str().c_str());
378 }
379 }
380 alock.Release();
381
382 }
383
384
385
386 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_UnHighlight (JNIEnv *env, jobject theobj)
387 {
388
389 jcas_Locking alock(env);
390 {
391 try {
392 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
393 the_this->UnHighlight();
394
395 }
396 catch (Standard_Failure) {
397   Standard_SStream Err;
398   Err <<   Standard_Failure::Caught(); 
399   Err << (char) 0;
400   jcas_ThrowException(env,Err.str().c_str());
401 }
402 }
403 alock.Release();
404
405 }
406
407
408
409 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetDefaultBackgroundColor_11 (JNIEnv *env, jobject theobj, jshort Type, jdouble V1, jdouble V2, jdouble V3)
410 {
411
412 jcas_Locking alock(env);
413 {
414 try {
415 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
416 the_this->SetDefaultBackgroundColor((Quantity_TypeOfColor) Type,(Quantity_Parameter) V1,(Quantity_Parameter) V2,(Quantity_Parameter) V3);
417
418 }
419 catch (Standard_Failure) {
420   Standard_SStream Err;
421   Err <<   Standard_Failure::Caught(); 
422   Err << (char) 0;
423   jcas_ThrowException(env,Err.str().c_str());
424 }
425 }
426 alock.Release();
427
428 }
429
430
431
432 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetDefaultBackgroundColor_12 (JNIEnv *env, jobject theobj, jshort Name)
433 {
434
435 jcas_Locking alock(env);
436 {
437 try {
438 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
439 the_this->SetDefaultBackgroundColor((Quantity_NameOfColor) Name);
440
441 }
442 catch (Standard_Failure) {
443   Standard_SStream Err;
444   Err <<   Standard_Failure::Caught(); 
445   Err << (char) 0;
446   jcas_ThrowException(env,Err.str().c_str());
447 }
448 }
449 alock.Release();
450
451 }
452
453
454
455 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetDefaultBackgroundColor_13 (JNIEnv *env, jobject theobj, jobject Color)
456 {
457
458 jcas_Locking alock(env);
459 {
460 try {
461 Quantity_Color* the_Color = (Quantity_Color*) jcas_GetHandle(env,Color);
462 if ( the_Color == NULL ) {
463
464  // The following assumes availability of the default constructor (what may not
465  // always be the case). Therefore explicit exception is thrown if the null
466  // object has been passed.
467  // the_Color = new Quantity_Color ();
468  // jcas_SetHandle ( env, Color, the_Color );
469  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
470
471 }  // end if
472 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
473 the_this->SetDefaultBackgroundColor(*the_Color);
474
475 }
476 catch (Standard_Failure) {
477   Standard_SStream Err;
478   Err <<   Standard_Failure::Caught(); 
479   Err << (char) 0;
480   jcas_ThrowException(env,Err.str().c_str());
481 }
482 }
483 alock.Release();
484
485 }
486
487
488
489 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultViewSize (JNIEnv *env, jobject theobj, jdouble Size)
490 {
491
492 jcas_Locking alock(env);
493 {
494 try {
495 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
496 the_this->SetDefaultViewSize((Quantity_Length) Size);
497
498 }
499 catch (Standard_Failure) {
500   Standard_SStream Err;
501   Err <<   Standard_Failure::Caught(); 
502   Err << (char) 0;
503   jcas_ThrowException(env,Err.str().c_str());
504 }
505 }
506 alock.Release();
507
508 }
509
510
511
512 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultViewProj (JNIEnv *env, jobject theobj, jshort Orientation)
513 {
514
515 jcas_Locking alock(env);
516 {
517 try {
518 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
519 the_this->SetDefaultViewProj((V3d_TypeOfOrientation) Orientation);
520
521 }
522 catch (Standard_Failure) {
523   Standard_SStream Err;
524   Err <<   Standard_Failure::Caught(); 
525   Err << (char) 0;
526   jcas_ThrowException(env,Err.str().c_str());
527 }
528 }
529 alock.Release();
530
531 }
532
533
534
535 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultVisualization (JNIEnv *env, jobject theobj, jshort Type)
536 {
537
538 jcas_Locking alock(env);
539 {
540 try {
541 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
542 the_this->SetDefaultVisualization((V3d_TypeOfVisualization) Type);
543
544 }
545 catch (Standard_Failure) {
546   Standard_SStream Err;
547   Err <<   Standard_Failure::Caught(); 
548   Err << (char) 0;
549   jcas_ThrowException(env,Err.str().c_str());
550 }
551 }
552 alock.Release();
553
554 }
555
556
557
558 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetZBufferManagment (JNIEnv *env, jobject theobj, jboolean Automatic)
559 {
560
561 jcas_Locking alock(env);
562 {
563 try {
564 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
565 the_this->SetZBufferManagment((Standard_Boolean) Automatic);
566
567 }
568 catch (Standard_Failure) {
569   Standard_SStream Err;
570   Err <<   Standard_Failure::Caught(); 
571   Err << (char) 0;
572   jcas_ThrowException(env,Err.str().c_str());
573 }
574 }
575 alock.Release();
576
577 }
578
579
580
581 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ZBufferManagment (JNIEnv *env, jobject theobj)
582 {
583 jboolean thejret;
584
585 jcas_Locking alock(env);
586 {
587 try {
588 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
589  thejret = the_this->ZBufferManagment();
590
591 }
592 catch (Standard_Failure) {
593   Standard_SStream Err;
594   Err <<   Standard_Failure::Caught(); 
595   Err << (char) 0;
596   jcas_ThrowException(env,Err.str().c_str());
597 }
598 }
599 alock.Release();
600 return thejret;
601 }
602
603
604
605 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultShadingModel (JNIEnv *env, jobject theobj, jshort Type)
606 {
607
608 jcas_Locking alock(env);
609 {
610 try {
611 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
612 the_this->SetDefaultShadingModel((V3d_TypeOfShadingModel) Type);
613
614 }
615 catch (Standard_Failure) {
616   Standard_SStream Err;
617   Err <<   Standard_Failure::Caught(); 
618   Err << (char) 0;
619   jcas_ThrowException(env,Err.str().c_str());
620 }
621 }
622 alock.Release();
623
624 }
625
626
627
628 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultSurfaceDetail (JNIEnv *env, jobject theobj, jshort Type)
629 {
630
631 jcas_Locking alock(env);
632 {
633 try {
634 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
635 the_this->SetDefaultSurfaceDetail((V3d_TypeOfSurfaceDetail) Type);
636
637 }
638 catch (Standard_Failure) {
639   Standard_SStream Err;
640   Err <<   Standard_Failure::Caught(); 
641   Err << (char) 0;
642   jcas_ThrowException(env,Err.str().c_str());
643 }
644 }
645 alock.Release();
646
647 }
648
649
650
651 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultAngle (JNIEnv *env, jobject theobj, jdouble Angle)
652 {
653
654 jcas_Locking alock(env);
655 {
656 try {
657 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
658 the_this->SetDefaultAngle((Quantity_PlaneAngle) Angle);
659
660 }
661 catch (Standard_Failure) {
662   Standard_SStream Err;
663   Err <<   Standard_Failure::Caught(); 
664   Err << (char) 0;
665   jcas_ThrowException(env,Err.str().c_str());
666 }
667 }
668 alock.Release();
669
670 }
671
672
673
674 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetUpdateMode (JNIEnv *env, jobject theobj, jshort Mode)
675 {
676
677 jcas_Locking alock(env);
678 {
679 try {
680 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
681 the_this->SetUpdateMode((V3d_TypeOfUpdate) Mode);
682
683 }
684 catch (Standard_Failure) {
685   Standard_SStream Err;
686   Err <<   Standard_Failure::Caught(); 
687   Err << (char) 0;
688   jcas_ThrowException(env,Err.str().c_str());
689 }
690 }
691 alock.Release();
692
693 }
694
695
696
697 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultTypeOfView (JNIEnv *env, jobject theobj, jshort Type)
698 {
699
700 jcas_Locking alock(env);
701 {
702 try {
703 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
704 the_this->SetDefaultTypeOfView((V3d_TypeOfView) Type);
705
706 }
707 catch (Standard_Failure) {
708   Standard_SStream Err;
709   Err <<   Standard_Failure::Caught(); 
710   Err << (char) 0;
711   jcas_ThrowException(env,Err.str().c_str());
712 }
713 }
714 alock.Release();
715
716 }
717
718
719
720 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetPrivilegedPlane (JNIEnv *env, jobject theobj, jobject aPlane)
721 {
722
723 jcas_Locking alock(env);
724 {
725 try {
726 gp_Ax3* the_aPlane = (gp_Ax3*) jcas_GetHandle(env,aPlane);
727 if ( the_aPlane == NULL ) {
728
729  // The following assumes availability of the default constructor (what may not
730  // always be the case). Therefore explicit exception is thrown if the null
731  // object has been passed.
732  // the_aPlane = new gp_Ax3 ();
733  // jcas_SetHandle ( env, aPlane, the_aPlane );
734  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
735
736 }  // end if
737 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
738 the_this->SetPrivilegedPlane(*the_aPlane);
739
740 }
741 catch (Standard_Failure) {
742   Standard_SStream Err;
743   Err <<   Standard_Failure::Caught(); 
744   Err << (char) 0;
745   jcas_ThrowException(env,Err.str().c_str());
746 }
747 }
748 alock.Release();
749
750 }
751
752
753
754 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_PrivilegedPlane (JNIEnv *env, jobject theobj)
755 {
756 jobject thejret;
757
758 jcas_Locking alock(env);
759 {
760 try {
761 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
762 gp_Ax3* theret = new gp_Ax3(the_this->PrivilegedPlane());
763 thejret = jcas_CreateObject(env,"CASCADESamplesJni/gp_Ax3",theret);
764
765 }
766 catch (Standard_Failure) {
767   Standard_SStream Err;
768   Err <<   Standard_Failure::Caught(); 
769   Err << (char) 0;
770   jcas_ThrowException(env,Err.str().c_str());
771 }
772 }
773 alock.Release();
774 return thejret;
775 }
776
777
778
779 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DisplayPrivilegedPlane (JNIEnv *env, jobject theobj, jboolean OnOff, jdouble aSize)
780 {
781
782 jcas_Locking alock(env);
783 {
784 try {
785 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
786 the_this->DisplayPrivilegedPlane((Standard_Boolean) OnOff,(Quantity_Length) aSize);
787
788 }
789 catch (Standard_Failure) {
790   Standard_SStream Err;
791   Err <<   Standard_Failure::Caught(); 
792   Err << (char) 0;
793   jcas_ThrowException(env,Err.str().c_str());
794 }
795 }
796 alock.Release();
797
798 }
799
800
801
802 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetLightOn_11 (JNIEnv *env, jobject theobj, jobject MyLight)
803 {
804
805 jcas_Locking alock(env);
806 {
807 try {
808  Handle( V3d_Light ) the_MyLight;
809  void*                ptr_MyLight = jcas_GetHandle(env,MyLight);
810  
811  if ( ptr_MyLight != NULL ) the_MyLight = *(   (  Handle( V3d_Light )*  )ptr_MyLight   );
812
813 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
814 the_this->SetLightOn(the_MyLight);
815
816 }
817 catch (Standard_Failure) {
818   Standard_SStream Err;
819   Err <<   Standard_Failure::Caught(); 
820   Err << (char) 0;
821   jcas_ThrowException(env,Err.str().c_str());
822 }
823 }
824 alock.Release();
825
826 }
827
828
829
830 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetLightOn_12 (JNIEnv *env, jobject theobj)
831 {
832
833 jcas_Locking alock(env);
834 {
835 try {
836 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
837 the_this->SetLightOn();
838
839 }
840 catch (Standard_Failure) {
841   Standard_SStream Err;
842   Err <<   Standard_Failure::Caught(); 
843   Err << (char) 0;
844   jcas_ThrowException(env,Err.str().c_str());
845 }
846 }
847 alock.Release();
848
849 }
850
851
852
853 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetLightOff_11 (JNIEnv *env, jobject theobj, jobject MyLight)
854 {
855
856 jcas_Locking alock(env);
857 {
858 try {
859  Handle( V3d_Light ) the_MyLight;
860  void*                ptr_MyLight = jcas_GetHandle(env,MyLight);
861  
862  if ( ptr_MyLight != NULL ) the_MyLight = *(   (  Handle( V3d_Light )*  )ptr_MyLight   );
863
864 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
865 the_this->SetLightOff(the_MyLight);
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 void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetLightOff_12 (JNIEnv *env, jobject theobj)
882 {
883
884 jcas_Locking alock(env);
885 {
886 try {
887 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
888 the_this->SetLightOff();
889
890 }
891 catch (Standard_Failure) {
892   Standard_SStream Err;
893   Err <<   Standard_Failure::Caught(); 
894   Err << (char) 0;
895   jcas_ThrowException(env,Err.str().c_str());
896 }
897 }
898 alock.Release();
899
900 }
901
902
903
904 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DelLight (JNIEnv *env, jobject theobj, jobject MyLight)
905 {
906
907 jcas_Locking alock(env);
908 {
909 try {
910  Handle( V3d_Light ) the_MyLight;
911  void*                ptr_MyLight = jcas_GetHandle(env,MyLight);
912  
913  if ( ptr_MyLight != NULL ) the_MyLight = *(   (  Handle( V3d_Light )*  )ptr_MyLight   );
914
915 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
916 the_this->DelLight(the_MyLight);
917
918 }
919 catch (Standard_Failure) {
920   Standard_SStream Err;
921   Err <<   Standard_Failure::Caught(); 
922   Err << (char) 0;
923   jcas_ThrowException(env,Err.str().c_str());
924 }
925 }
926 alock.Release();
927
928 }
929
930
931
932 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetCurrentSelectedLight (JNIEnv *env, jobject theobj, jobject TheLight)
933 {
934
935 jcas_Locking alock(env);
936 {
937 try {
938  Handle( V3d_Light ) the_TheLight;
939  void*                ptr_TheLight = jcas_GetHandle(env,TheLight);
940  
941  if ( ptr_TheLight != NULL ) the_TheLight = *(   (  Handle( V3d_Light )*  )ptr_TheLight   );
942
943 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
944 the_this->SetCurrentSelectedLight(the_TheLight);
945
946 }
947 catch (Standard_Failure) {
948   Standard_SStream Err;
949   Err <<   Standard_Failure::Caught(); 
950   Err << (char) 0;
951   jcas_ThrowException(env,Err.str().c_str());
952 }
953 }
954 alock.Release();
955
956 }
957
958
959
960 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ClearCurrentSelectedLight (JNIEnv *env, jobject theobj)
961 {
962
963 jcas_Locking alock(env);
964 {
965 try {
966 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
967 the_this->ClearCurrentSelectedLight();
968
969 }
970 catch (Standard_Failure) {
971   Standard_SStream Err;
972   Err <<   Standard_Failure::Caught(); 
973   Err << (char) 0;
974   jcas_ThrowException(env,Err.str().c_str());
975 }
976 }
977 alock.Release();
978
979 }
980
981
982
983 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1DefaultBackgroundColor_11 (JNIEnv *env, jobject theobj, jshort Type, jobject V1, jobject V2, jobject V3)
984 {
985
986 jcas_Locking alock(env);
987 {
988 try {
989 Standard_Real the_V1 = jcas_GetReal(env,V1);
990 Standard_Real the_V2 = jcas_GetReal(env,V2);
991 Standard_Real the_V3 = jcas_GetReal(env,V3);
992 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
993 the_this->DefaultBackgroundColor((Quantity_TypeOfColor) Type,the_V1,the_V2,the_V3);
994 jcas_SetReal(env,V1,the_V1);
995 jcas_SetReal(env,V2,the_V2);
996 jcas_SetReal(env,V3,the_V3);
997
998 }
999 catch (Standard_Failure) {
1000   Standard_SStream Err;
1001   Err <<   Standard_Failure::Caught(); 
1002   Err << (char) 0;
1003   jcas_ThrowException(env,Err.str().c_str());
1004 }
1005 }
1006 alock.Release();
1007
1008 }
1009
1010
1011
1012 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1DefaultBackgroundColor_12 (JNIEnv *env, jobject theobj)
1013 {
1014 jobject thejret;
1015
1016 jcas_Locking alock(env);
1017 {
1018 try {
1019 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1020 Quantity_Color* theret = new Quantity_Color(the_this->DefaultBackgroundColor());
1021 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Quantity_Color",theret);
1022
1023 }
1024 catch (Standard_Failure) {
1025   Standard_SStream Err;
1026   Err <<   Standard_Failure::Caught(); 
1027   Err << (char) 0;
1028   jcas_ThrowException(env,Err.str().c_str());
1029 }
1030 }
1031 alock.Release();
1032 return thejret;
1033 }
1034
1035
1036
1037 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultViewSize (JNIEnv *env, jobject theobj)
1038 {
1039 jdouble thejret;
1040
1041 jcas_Locking alock(env);
1042 {
1043 try {
1044 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1045  thejret = the_this->DefaultViewSize();
1046
1047 }
1048 catch (Standard_Failure) {
1049   Standard_SStream Err;
1050   Err <<   Standard_Failure::Caught(); 
1051   Err << (char) 0;
1052   jcas_ThrowException(env,Err.str().c_str());
1053 }
1054 }
1055 alock.Release();
1056 return thejret;
1057 }
1058
1059
1060
1061 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultViewProj (JNIEnv *env, jobject theobj)
1062 {
1063 jshort thejret;
1064
1065 jcas_Locking alock(env);
1066 {
1067 try {
1068 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1069  thejret = the_this->DefaultViewProj();
1070
1071 }
1072 catch (Standard_Failure) {
1073   Standard_SStream Err;
1074   Err <<   Standard_Failure::Caught(); 
1075   Err << (char) 0;
1076   jcas_ThrowException(env,Err.str().c_str());
1077 }
1078 }
1079 alock.Release();
1080 return thejret;
1081 }
1082
1083
1084
1085 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultVisualization (JNIEnv *env, jobject theobj)
1086 {
1087 jshort thejret;
1088
1089 jcas_Locking alock(env);
1090 {
1091 try {
1092 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1093  thejret = the_this->DefaultVisualization();
1094
1095 }
1096 catch (Standard_Failure) {
1097   Standard_SStream Err;
1098   Err <<   Standard_Failure::Caught(); 
1099   Err << (char) 0;
1100   jcas_ThrowException(env,Err.str().c_str());
1101 }
1102 }
1103 alock.Release();
1104 return thejret;
1105 }
1106
1107
1108
1109 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultShadingModel (JNIEnv *env, jobject theobj)
1110 {
1111 jshort thejret;
1112
1113 jcas_Locking alock(env);
1114 {
1115 try {
1116 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1117  thejret = the_this->DefaultShadingModel();
1118
1119 }
1120 catch (Standard_Failure) {
1121   Standard_SStream Err;
1122   Err <<   Standard_Failure::Caught(); 
1123   Err << (char) 0;
1124   jcas_ThrowException(env,Err.str().c_str());
1125 }
1126 }
1127 alock.Release();
1128 return thejret;
1129 }
1130
1131
1132
1133 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultSurfaceDetail (JNIEnv *env, jobject theobj)
1134 {
1135 jshort thejret;
1136
1137 jcas_Locking alock(env);
1138 {
1139 try {
1140 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1141  thejret = the_this->DefaultSurfaceDetail();
1142
1143 }
1144 catch (Standard_Failure) {
1145   Standard_SStream Err;
1146   Err <<   Standard_Failure::Caught(); 
1147   Err << (char) 0;
1148   jcas_ThrowException(env,Err.str().c_str());
1149 }
1150 }
1151 alock.Release();
1152 return thejret;
1153 }
1154
1155
1156
1157 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultAngle (JNIEnv *env, jobject theobj)
1158 {
1159 jdouble thejret;
1160
1161 jcas_Locking alock(env);
1162 {
1163 try {
1164 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1165  thejret = the_this->DefaultAngle();
1166
1167 }
1168 catch (Standard_Failure) {
1169   Standard_SStream Err;
1170   Err <<   Standard_Failure::Caught(); 
1171   Err << (char) 0;
1172   jcas_ThrowException(env,Err.str().c_str());
1173 }
1174 }
1175 alock.Release();
1176 return thejret;
1177 }
1178
1179
1180
1181 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_UpdateMode (JNIEnv *env, jobject theobj)
1182 {
1183 jshort thejret;
1184
1185 jcas_Locking alock(env);
1186 {
1187 try {
1188 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1189  thejret = the_this->UpdateMode();
1190
1191 }
1192 catch (Standard_Failure) {
1193   Standard_SStream Err;
1194   Err <<   Standard_Failure::Caught(); 
1195   Err << (char) 0;
1196   jcas_ThrowException(env,Err.str().c_str());
1197 }
1198 }
1199 alock.Release();
1200 return thejret;
1201 }
1202
1203
1204
1205 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_IfMoreViews (JNIEnv *env, jobject theobj)
1206 {
1207 jboolean thejret;
1208
1209 jcas_Locking alock(env);
1210 {
1211 try {
1212 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1213  thejret = the_this->IfMoreViews();
1214
1215 }
1216 catch (Standard_Failure) {
1217   Standard_SStream Err;
1218   Err <<   Standard_Failure::Caught(); 
1219   Err << (char) 0;
1220   jcas_ThrowException(env,Err.str().c_str());
1221 }
1222 }
1223 alock.Release();
1224 return thejret;
1225 }
1226
1227
1228
1229 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_InitActiveViews (JNIEnv *env, jobject theobj)
1230 {
1231
1232 jcas_Locking alock(env);
1233 {
1234 try {
1235 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1236 the_this->InitActiveViews();
1237
1238 }
1239 catch (Standard_Failure) {
1240   Standard_SStream Err;
1241   Err <<   Standard_Failure::Caught(); 
1242   Err << (char) 0;
1243   jcas_ThrowException(env,Err.str().c_str());
1244 }
1245 }
1246 alock.Release();
1247
1248 }
1249
1250
1251
1252 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_MoreActiveViews (JNIEnv *env, jobject theobj)
1253 {
1254 jboolean thejret;
1255
1256 jcas_Locking alock(env);
1257 {
1258 try {
1259 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1260  thejret = the_this->MoreActiveViews();
1261
1262 }
1263 catch (Standard_Failure) {
1264   Standard_SStream Err;
1265   Err <<   Standard_Failure::Caught(); 
1266   Err << (char) 0;
1267   jcas_ThrowException(env,Err.str().c_str());
1268 }
1269 }
1270 alock.Release();
1271 return thejret;
1272 }
1273
1274
1275
1276 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_NextActiveViews (JNIEnv *env, jobject theobj)
1277 {
1278
1279 jcas_Locking alock(env);
1280 {
1281 try {
1282 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1283 the_this->NextActiveViews();
1284
1285 }
1286 catch (Standard_Failure) {
1287   Standard_SStream Err;
1288   Err <<   Standard_Failure::Caught(); 
1289   Err << (char) 0;
1290   jcas_ThrowException(env,Err.str().c_str());
1291 }
1292 }
1293 alock.Release();
1294
1295 }
1296
1297
1298
1299 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ActiveView (JNIEnv *env, jobject theobj)
1300 {
1301 jobject thejret;
1302
1303 jcas_Locking alock(env);
1304 {
1305 try {
1306 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1307 Handle(V3d_View)* theret = new Handle(V3d_View);
1308 *theret = the_this->ActiveView();
1309 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_View",theret);
1310
1311 }
1312 catch (Standard_Failure) {
1313   Standard_SStream Err;
1314   Err <<   Standard_Failure::Caught(); 
1315   Err << (char) 0;
1316   jcas_ThrowException(env,Err.str().c_str());
1317 }
1318 }
1319 alock.Release();
1320 return thejret;
1321 }
1322
1323
1324
1325 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_LastActiveView (JNIEnv *env, jobject theobj)
1326 {
1327 jboolean thejret;
1328
1329 jcas_Locking alock(env);
1330 {
1331 try {
1332 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1333  thejret = the_this->LastActiveView();
1334
1335 }
1336 catch (Standard_Failure) {
1337   Standard_SStream Err;
1338   Err <<   Standard_Failure::Caught(); 
1339   Err << (char) 0;
1340   jcas_ThrowException(env,Err.str().c_str());
1341 }
1342 }
1343 alock.Release();
1344 return thejret;
1345 }
1346
1347
1348
1349 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_InitDefinedViews (JNIEnv *env, jobject theobj)
1350 {
1351
1352 jcas_Locking alock(env);
1353 {
1354 try {
1355 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1356 the_this->InitDefinedViews();
1357
1358 }
1359 catch (Standard_Failure) {
1360   Standard_SStream Err;
1361   Err <<   Standard_Failure::Caught(); 
1362   Err << (char) 0;
1363   jcas_ThrowException(env,Err.str().c_str());
1364 }
1365 }
1366 alock.Release();
1367
1368 }
1369
1370
1371
1372 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_MoreDefinedViews (JNIEnv *env, jobject theobj)
1373 {
1374 jboolean thejret;
1375
1376 jcas_Locking alock(env);
1377 {
1378 try {
1379 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1380  thejret = the_this->MoreDefinedViews();
1381
1382 }
1383 catch (Standard_Failure) {
1384   Standard_SStream Err;
1385   Err <<   Standard_Failure::Caught(); 
1386   Err << (char) 0;
1387   jcas_ThrowException(env,Err.str().c_str());
1388 }
1389 }
1390 alock.Release();
1391 return thejret;
1392 }
1393
1394
1395
1396 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_NextDefinedViews (JNIEnv *env, jobject theobj)
1397 {
1398
1399 jcas_Locking alock(env);
1400 {
1401 try {
1402 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1403 the_this->NextDefinedViews();
1404
1405 }
1406 catch (Standard_Failure) {
1407   Standard_SStream Err;
1408   Err <<   Standard_Failure::Caught(); 
1409   Err << (char) 0;
1410   jcas_ThrowException(env,Err.str().c_str());
1411 }
1412 }
1413 alock.Release();
1414
1415 }
1416
1417
1418
1419 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefinedView (JNIEnv *env, jobject theobj)
1420 {
1421 jobject thejret;
1422
1423 jcas_Locking alock(env);
1424 {
1425 try {
1426 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1427 Handle(V3d_View)* theret = new Handle(V3d_View);
1428 *theret = the_this->DefinedView();
1429 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_View",theret);
1430
1431 }
1432 catch (Standard_Failure) {
1433   Standard_SStream Err;
1434   Err <<   Standard_Failure::Caught(); 
1435   Err << (char) 0;
1436   jcas_ThrowException(env,Err.str().c_str());
1437 }
1438 }
1439 alock.Release();
1440 return thejret;
1441 }
1442
1443
1444
1445 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_InitActiveLights (JNIEnv *env, jobject theobj)
1446 {
1447
1448 jcas_Locking alock(env);
1449 {
1450 try {
1451 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1452 the_this->InitActiveLights();
1453
1454 }
1455 catch (Standard_Failure) {
1456   Standard_SStream Err;
1457   Err <<   Standard_Failure::Caught(); 
1458   Err << (char) 0;
1459   jcas_ThrowException(env,Err.str().c_str());
1460 }
1461 }
1462 alock.Release();
1463
1464 }
1465
1466
1467
1468 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_MoreActiveLights (JNIEnv *env, jobject theobj)
1469 {
1470 jboolean thejret;
1471
1472 jcas_Locking alock(env);
1473 {
1474 try {
1475 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1476  thejret = the_this->MoreActiveLights();
1477
1478 }
1479 catch (Standard_Failure) {
1480   Standard_SStream Err;
1481   Err <<   Standard_Failure::Caught(); 
1482   Err << (char) 0;
1483   jcas_ThrowException(env,Err.str().c_str());
1484 }
1485 }
1486 alock.Release();
1487 return thejret;
1488 }
1489
1490
1491
1492 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_NextActiveLights (JNIEnv *env, jobject theobj)
1493 {
1494
1495 jcas_Locking alock(env);
1496 {
1497 try {
1498 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1499 the_this->NextActiveLights();
1500
1501 }
1502 catch (Standard_Failure) {
1503   Standard_SStream Err;
1504   Err <<   Standard_Failure::Caught(); 
1505   Err << (char) 0;
1506   jcas_ThrowException(env,Err.str().c_str());
1507 }
1508 }
1509 alock.Release();
1510
1511 }
1512
1513
1514
1515 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ActiveLight (JNIEnv *env, jobject theobj)
1516 {
1517 jobject thejret;
1518
1519 jcas_Locking alock(env);
1520 {
1521 try {
1522 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1523 Handle(V3d_Light)* theret = new Handle(V3d_Light);
1524 *theret = the_this->ActiveLight();
1525 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Light",theret);
1526
1527 }
1528 catch (Standard_Failure) {
1529   Standard_SStream Err;
1530   Err <<   Standard_Failure::Caught(); 
1531   Err << (char) 0;
1532   jcas_ThrowException(env,Err.str().c_str());
1533 }
1534 }
1535 alock.Release();
1536 return thejret;
1537 }
1538
1539
1540
1541 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_InitDefinedLights (JNIEnv *env, jobject theobj)
1542 {
1543
1544 jcas_Locking alock(env);
1545 {
1546 try {
1547 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1548 the_this->InitDefinedLights();
1549
1550 }
1551 catch (Standard_Failure) {
1552   Standard_SStream Err;
1553   Err <<   Standard_Failure::Caught(); 
1554   Err << (char) 0;
1555   jcas_ThrowException(env,Err.str().c_str());
1556 }
1557 }
1558 alock.Release();
1559
1560 }
1561
1562
1563
1564 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_MoreDefinedLights (JNIEnv *env, jobject theobj)
1565 {
1566 jboolean thejret;
1567
1568 jcas_Locking alock(env);
1569 {
1570 try {
1571 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1572  thejret = the_this->MoreDefinedLights();
1573
1574 }
1575 catch (Standard_Failure) {
1576   Standard_SStream Err;
1577   Err <<   Standard_Failure::Caught(); 
1578   Err << (char) 0;
1579   jcas_ThrowException(env,Err.str().c_str());
1580 }
1581 }
1582 alock.Release();
1583 return thejret;
1584 }
1585
1586
1587
1588 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_NextDefinedLights (JNIEnv *env, jobject theobj)
1589 {
1590
1591 jcas_Locking alock(env);
1592 {
1593 try {
1594 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1595 the_this->NextDefinedLights();
1596
1597 }
1598 catch (Standard_Failure) {
1599   Standard_SStream Err;
1600   Err <<   Standard_Failure::Caught(); 
1601   Err << (char) 0;
1602   jcas_ThrowException(env,Err.str().c_str());
1603 }
1604 }
1605 alock.Release();
1606
1607 }
1608
1609
1610
1611 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefinedLight (JNIEnv *env, jobject theobj)
1612 {
1613 jobject thejret;
1614
1615 jcas_Locking alock(env);
1616 {
1617 try {
1618 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1619 Handle(V3d_Light)* theret = new Handle(V3d_Light);
1620 *theret = the_this->DefinedLight();
1621 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Light",theret);
1622
1623 }
1624 catch (Standard_Failure) {
1625   Standard_SStream Err;
1626   Err <<   Standard_Failure::Caught(); 
1627   Err << (char) 0;
1628   jcas_ThrowException(env,Err.str().c_str());
1629 }
1630 }
1631 alock.Release();
1632 return thejret;
1633 }
1634
1635
1636
1637 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_InitDefinedPlanes (JNIEnv *env, jobject theobj)
1638 {
1639
1640 jcas_Locking alock(env);
1641 {
1642 try {
1643 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1644 the_this->InitDefinedPlanes();
1645
1646 }
1647 catch (Standard_Failure) {
1648   Standard_SStream Err;
1649   Err <<   Standard_Failure::Caught(); 
1650   Err << (char) 0;
1651   jcas_ThrowException(env,Err.str().c_str());
1652 }
1653 }
1654 alock.Release();
1655
1656 }
1657
1658
1659
1660 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_MoreDefinedPlanes (JNIEnv *env, jobject theobj)
1661 {
1662 jboolean thejret;
1663
1664 jcas_Locking alock(env);
1665 {
1666 try {
1667 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1668  thejret = the_this->MoreDefinedPlanes();
1669
1670 }
1671 catch (Standard_Failure) {
1672   Standard_SStream Err;
1673   Err <<   Standard_Failure::Caught(); 
1674   Err << (char) 0;
1675   jcas_ThrowException(env,Err.str().c_str());
1676 }
1677 }
1678 alock.Release();
1679 return thejret;
1680 }
1681
1682
1683
1684 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_NextDefinedPlanes (JNIEnv *env, jobject theobj)
1685 {
1686
1687 jcas_Locking alock(env);
1688 {
1689 try {
1690 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1691 the_this->NextDefinedPlanes();
1692
1693 }
1694 catch (Standard_Failure) {
1695   Standard_SStream Err;
1696   Err <<   Standard_Failure::Caught(); 
1697   Err << (char) 0;
1698   jcas_ThrowException(env,Err.str().c_str());
1699 }
1700 }
1701 alock.Release();
1702
1703 }
1704
1705
1706
1707 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefinedPlane (JNIEnv *env, jobject theobj)
1708 {
1709 jobject thejret;
1710
1711 jcas_Locking alock(env);
1712 {
1713 try {
1714 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1715 Handle(V3d_Plane)* theret = new Handle(V3d_Plane);
1716 *theret = the_this->DefinedPlane();
1717 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Plane",theret);
1718
1719 }
1720 catch (Standard_Failure) {
1721   Standard_SStream Err;
1722   Err <<   Standard_Failure::Caught(); 
1723   Err << (char) 0;
1724   jcas_ThrowException(env,Err.str().c_str());
1725 }
1726 }
1727 alock.Release();
1728 return thejret;
1729 }
1730
1731
1732
1733 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Viewer (JNIEnv *env, jobject theobj)
1734 {
1735 jobject thejret;
1736
1737 jcas_Locking alock(env);
1738 {
1739 try {
1740 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1741 Handle(Visual3d_ViewManager)* theret = new Handle(Visual3d_ViewManager);
1742 *theret = the_this->Viewer();
1743 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Visual3d_ViewManager",theret);
1744
1745 }
1746 catch (Standard_Failure) {
1747   Standard_SStream Err;
1748   Err <<   Standard_Failure::Caught(); 
1749   Err << (char) 0;
1750   jcas_ThrowException(env,Err.str().c_str());
1751 }
1752 }
1753 alock.Release();
1754 return thejret;
1755 }
1756
1757
1758
1759 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_CurrentSelectedLight (JNIEnv *env, jobject theobj)
1760 {
1761 jobject thejret;
1762
1763 jcas_Locking alock(env);
1764 {
1765 try {
1766 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1767 Handle(V3d_Light)* theret = new Handle(V3d_Light);
1768 *theret = the_this->CurrentSelectedLight();
1769 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Light",theret);
1770
1771 }
1772 catch (Standard_Failure) {
1773   Standard_SStream Err;
1774   Err <<   Standard_Failure::Caught(); 
1775   Err << (char) 0;
1776   jcas_ThrowException(env,Err.str().c_str());
1777 }
1778 }
1779 alock.Release();
1780 return thejret;
1781 }
1782
1783
1784
1785 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_IsGlobalLight (JNIEnv *env, jobject theobj, jobject TheLight)
1786 {
1787 jboolean thejret;
1788
1789 jcas_Locking alock(env);
1790 {
1791 try {
1792  Handle( V3d_Light ) the_TheLight;
1793  void*                ptr_TheLight = jcas_GetHandle(env,TheLight);
1794  
1795  if ( ptr_TheLight != NULL ) the_TheLight = *(   (  Handle( V3d_Light )*  )ptr_TheLight   );
1796
1797 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1798  thejret = the_this->IsGlobalLight(the_TheLight);
1799
1800 }
1801 catch (Standard_Failure) {
1802   Standard_SStream Err;
1803   Err <<   Standard_Failure::Caught(); 
1804   Err << (char) 0;
1805   jcas_ThrowException(env,Err.str().c_str());
1806 }
1807 }
1808 alock.Release();
1809 return thejret;
1810 }
1811
1812
1813
1814 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ComputedMode (JNIEnv *env, jobject theobj)
1815 {
1816 jboolean thejret;
1817
1818 jcas_Locking alock(env);
1819 {
1820 try {
1821 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1822  thejret = the_this->ComputedMode();
1823
1824 }
1825 catch (Standard_Failure) {
1826   Standard_SStream Err;
1827   Err <<   Standard_Failure::Caught(); 
1828   Err << (char) 0;
1829   jcas_ThrowException(env,Err.str().c_str());
1830 }
1831 }
1832 alock.Release();
1833 return thejret;
1834 }
1835
1836
1837
1838 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DefaultComputedMode (JNIEnv *env, jobject theobj)
1839 {
1840 jboolean thejret;
1841
1842 jcas_Locking alock(env);
1843 {
1844 try {
1845 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1846  thejret = the_this->DefaultComputedMode();
1847
1848 }
1849 catch (Standard_Failure) {
1850   Standard_SStream Err;
1851   Err <<   Standard_Failure::Caught(); 
1852   Err << (char) 0;
1853   jcas_ThrowException(env,Err.str().c_str());
1854 }
1855 }
1856 alock.Release();
1857 return thejret;
1858 }
1859
1860
1861
1862 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_ActivateGrid (JNIEnv *env, jobject theobj, jshort aGridType, jshort aGridDrawMode)
1863 {
1864
1865 jcas_Locking alock(env);
1866 {
1867 try {
1868 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1869 the_this->ActivateGrid((Aspect_GridType) aGridType,(Aspect_GridDrawMode) aGridDrawMode);
1870
1871 }
1872 catch (Standard_Failure) {
1873   Standard_SStream Err;
1874   Err <<   Standard_Failure::Caught(); 
1875   Err << (char) 0;
1876   jcas_ThrowException(env,Err.str().c_str());
1877 }
1878 }
1879 alock.Release();
1880
1881 }
1882
1883
1884
1885 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_DeactivateGrid (JNIEnv *env, jobject theobj)
1886 {
1887
1888 jcas_Locking alock(env);
1889 {
1890 try {
1891 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1892 the_this->DeactivateGrid();
1893
1894 }
1895 catch (Standard_Failure) {
1896   Standard_SStream Err;
1897   Err <<   Standard_Failure::Caught(); 
1898   Err << (char) 0;
1899   jcas_ThrowException(env,Err.str().c_str());
1900 }
1901 }
1902 alock.Release();
1903
1904 }
1905
1906
1907
1908 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetGridEcho_11 (JNIEnv *env, jobject theobj, jboolean showGrid)
1909 {
1910
1911 jcas_Locking alock(env);
1912 {
1913 try {
1914 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1915 the_this->SetGridEcho((Standard_Boolean) showGrid);
1916
1917 }
1918 catch (Standard_Failure) {
1919   Standard_SStream Err;
1920   Err <<   Standard_Failure::Caught(); 
1921   Err << (char) 0;
1922   jcas_ThrowException(env,Err.str().c_str());
1923 }
1924 }
1925 alock.Release();
1926
1927 }
1928
1929
1930
1931 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1SetGridEcho_12 (JNIEnv *env, jobject theobj, jobject aMarker)
1932 {
1933
1934 jcas_Locking alock(env);
1935 {
1936 try {
1937  Handle( Graphic3d_AspectMarker3d ) the_aMarker;
1938  void*                ptr_aMarker = jcas_GetHandle(env,aMarker);
1939  
1940  if ( ptr_aMarker != NULL ) the_aMarker = *(   (  Handle( Graphic3d_AspectMarker3d )*  )ptr_aMarker   );
1941
1942 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1943 the_this->SetGridEcho(the_aMarker);
1944
1945 }
1946 catch (Standard_Failure) {
1947   Standard_SStream Err;
1948   Err <<   Standard_Failure::Caught(); 
1949   Err << (char) 0;
1950   jcas_ThrowException(env,Err.str().c_str());
1951 }
1952 }
1953 alock.Release();
1954
1955 }
1956
1957
1958
1959 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_GridEcho (JNIEnv *env, jobject theobj)
1960 {
1961 jboolean thejret;
1962
1963 jcas_Locking alock(env);
1964 {
1965 try {
1966 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1967  thejret = the_this->GridEcho();
1968
1969 }
1970 catch (Standard_Failure) {
1971   Standard_SStream Err;
1972   Err <<   Standard_Failure::Caught(); 
1973   Err << (char) 0;
1974   jcas_ThrowException(env,Err.str().c_str());
1975 }
1976 }
1977 alock.Release();
1978 return thejret;
1979 }
1980
1981
1982
1983 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1Viewer_V3d_1Viewer_1IsActive_11 (JNIEnv *env, jobject theobj)
1984 {
1985 jboolean thejret;
1986
1987 jcas_Locking alock(env);
1988 {
1989 try {
1990 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
1991  thejret = the_this->IsActive();
1992
1993 }
1994 catch (Standard_Failure) {
1995   Standard_SStream Err;
1996   Err <<   Standard_Failure::Caught(); 
1997   Err << (char) 0;
1998   jcas_ThrowException(env,Err.str().c_str());
1999 }
2000 }
2001 alock.Release();
2002 return thejret;
2003 }
2004
2005
2006
2007 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Grid (JNIEnv *env, jobject theobj)
2008 {
2009 jobject thejret;
2010
2011 jcas_Locking alock(env);
2012 {
2013 try {
2014 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2015 Handle(Aspect_Grid)* theret = new Handle(Aspect_Grid);
2016 *theret = the_this->Grid();
2017 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_Grid",theret);
2018
2019 }
2020 catch (Standard_Failure) {
2021   Standard_SStream Err;
2022   Err <<   Standard_Failure::Caught(); 
2023   Err << (char) 0;
2024   jcas_ThrowException(env,Err.str().c_str());
2025 }
2026 }
2027 alock.Release();
2028 return thejret;
2029 }
2030
2031
2032
2033 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_GridType (JNIEnv *env, jobject theobj)
2034 {
2035 jshort thejret;
2036
2037 jcas_Locking alock(env);
2038 {
2039 try {
2040 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2041  thejret = the_this->GridType();
2042
2043 }
2044 catch (Standard_Failure) {
2045   Standard_SStream Err;
2046   Err <<   Standard_Failure::Caught(); 
2047   Err << (char) 0;
2048   jcas_ThrowException(env,Err.str().c_str());
2049 }
2050 }
2051 alock.Release();
2052 return thejret;
2053 }
2054
2055
2056
2057 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1Viewer_GridDrawMode (JNIEnv *env, jobject theobj)
2058 {
2059 jshort thejret;
2060
2061 jcas_Locking alock(env);
2062 {
2063 try {
2064 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2065  thejret = the_this->GridDrawMode();
2066
2067 }
2068 catch (Standard_Failure) {
2069   Standard_SStream Err;
2070   Err <<   Standard_Failure::Caught(); 
2071   Err << (char) 0;
2072   jcas_ThrowException(env,Err.str().c_str());
2073 }
2074 }
2075 alock.Release();
2076 return thejret;
2077 }
2078
2079
2080
2081 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_RectangularGridValues (JNIEnv *env, jobject theobj, jobject XOrigin, jobject YOrigin, jobject XStep, jobject YStep, jobject RotationAngle)
2082 {
2083
2084 jcas_Locking alock(env);
2085 {
2086 try {
2087 Standard_Real the_XOrigin = jcas_GetReal(env,XOrigin);
2088 Standard_Real the_YOrigin = jcas_GetReal(env,YOrigin);
2089 Standard_Real the_XStep = jcas_GetReal(env,XStep);
2090 Standard_Real the_YStep = jcas_GetReal(env,YStep);
2091 Standard_Real the_RotationAngle = jcas_GetReal(env,RotationAngle);
2092 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2093 the_this->RectangularGridValues(the_XOrigin,the_YOrigin,the_XStep,the_YStep,the_RotationAngle);
2094 jcas_SetReal(env,XOrigin,the_XOrigin);
2095 jcas_SetReal(env,YOrigin,the_YOrigin);
2096 jcas_SetReal(env,XStep,the_XStep);
2097 jcas_SetReal(env,YStep,the_YStep);
2098 jcas_SetReal(env,RotationAngle,the_RotationAngle);
2099
2100 }
2101 catch (Standard_Failure) {
2102   Standard_SStream Err;
2103   Err <<   Standard_Failure::Caught(); 
2104   Err << (char) 0;
2105   jcas_ThrowException(env,Err.str().c_str());
2106 }
2107 }
2108 alock.Release();
2109
2110 }
2111
2112
2113
2114 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetRectangularGridValues (JNIEnv *env, jobject theobj, jdouble XOrigin, jdouble YOrigin, jdouble XStep, jdouble YStep, jdouble RotationAngle)
2115 {
2116
2117 jcas_Locking alock(env);
2118 {
2119 try {
2120 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2121 the_this->SetRectangularGridValues((Quantity_Length) XOrigin,(Quantity_Length) YOrigin,(Quantity_Length) XStep,(Quantity_Length) YStep,(Quantity_PlaneAngle) RotationAngle);
2122
2123 }
2124 catch (Standard_Failure) {
2125   Standard_SStream Err;
2126   Err <<   Standard_Failure::Caught(); 
2127   Err << (char) 0;
2128   jcas_ThrowException(env,Err.str().c_str());
2129 }
2130 }
2131 alock.Release();
2132
2133 }
2134
2135
2136
2137 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_CircularGridValues (JNIEnv *env, jobject theobj, jobject XOrigin, jobject YOrigin, jobject RadiusStep, jobject DivisionNumber, jobject RotationAngle)
2138 {
2139
2140 jcas_Locking alock(env);
2141 {
2142 try {
2143 Standard_Real the_XOrigin = jcas_GetReal(env,XOrigin);
2144 Standard_Real the_YOrigin = jcas_GetReal(env,YOrigin);
2145 Standard_Real the_RadiusStep = jcas_GetReal(env,RadiusStep);
2146 Standard_Integer the_DivisionNumber = jcas_GetInteger(env,DivisionNumber);
2147 Standard_Real the_RotationAngle = jcas_GetReal(env,RotationAngle);
2148 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2149 the_this->CircularGridValues(the_XOrigin,the_YOrigin,the_RadiusStep,the_DivisionNumber,the_RotationAngle);
2150 jcas_SetReal(env,XOrigin,the_XOrigin);
2151 jcas_SetReal(env,YOrigin,the_YOrigin);
2152 jcas_SetReal(env,RadiusStep,the_RadiusStep);
2153 jcas_SetInteger(env,DivisionNumber,the_DivisionNumber);
2154 jcas_SetReal(env,RotationAngle,the_RotationAngle);
2155
2156 }
2157 catch (Standard_Failure) {
2158   Standard_SStream Err;
2159   Err <<   Standard_Failure::Caught(); 
2160   Err << (char) 0;
2161   jcas_ThrowException(env,Err.str().c_str());
2162 }
2163 }
2164 alock.Release();
2165
2166 }
2167
2168
2169
2170 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetCircularGridValues (JNIEnv *env, jobject theobj, jdouble XOrigin, jdouble YOrigin, jdouble RadiusStep, jint DivisionNumber, jdouble RotationAngle)
2171 {
2172
2173 jcas_Locking alock(env);
2174 {
2175 try {
2176 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2177 the_this->SetCircularGridValues((Quantity_Length) XOrigin,(Quantity_Length) YOrigin,(Quantity_Length) RadiusStep,(Standard_Integer) DivisionNumber,(Quantity_PlaneAngle) RotationAngle);
2178
2179 }
2180 catch (Standard_Failure) {
2181   Standard_SStream Err;
2182   Err <<   Standard_Failure::Caught(); 
2183   Err << (char) 0;
2184   jcas_ThrowException(env,Err.str().c_str());
2185 }
2186 }
2187 alock.Release();
2188
2189 }
2190
2191
2192
2193 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_CircularGridGraphicValues (JNIEnv *env, jobject theobj, jobject Radius, jobject OffSet)
2194 {
2195
2196 jcas_Locking alock(env);
2197 {
2198 try {
2199 Standard_Real the_Radius = jcas_GetReal(env,Radius);
2200 Standard_Real the_OffSet = jcas_GetReal(env,OffSet);
2201 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2202 the_this->CircularGridGraphicValues(the_Radius,the_OffSet);
2203 jcas_SetReal(env,Radius,the_Radius);
2204 jcas_SetReal(env,OffSet,the_OffSet);
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_V3d_1Viewer_SetCircularGridGraphicValues (JNIEnv *env, jobject theobj, jdouble Radius, jdouble OffSet)
2221 {
2222
2223 jcas_Locking alock(env);
2224 {
2225 try {
2226 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2227 the_this->SetCircularGridGraphicValues((Quantity_Length) Radius,(Quantity_Length) OffSet);
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_V3d_1Viewer_RectangularGridGraphicValues (JNIEnv *env, jobject theobj, jobject XSize, jobject YSize, jobject OffSet)
2244 {
2245
2246 jcas_Locking alock(env);
2247 {
2248 try {
2249 Standard_Real the_XSize = jcas_GetReal(env,XSize);
2250 Standard_Real the_YSize = jcas_GetReal(env,YSize);
2251 Standard_Real the_OffSet = jcas_GetReal(env,OffSet);
2252 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2253 the_this->RectangularGridGraphicValues(the_XSize,the_YSize,the_OffSet);
2254 jcas_SetReal(env,XSize,the_XSize);
2255 jcas_SetReal(env,YSize,the_YSize);
2256 jcas_SetReal(env,OffSet,the_OffSet);
2257
2258 }
2259 catch (Standard_Failure) {
2260   Standard_SStream Err;
2261   Err <<   Standard_Failure::Caught(); 
2262   Err << (char) 0;
2263   jcas_ThrowException(env,Err.str().c_str());
2264 }
2265 }
2266 alock.Release();
2267
2268 }
2269
2270
2271
2272 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetRectangularGridGraphicValues (JNIEnv *env, jobject theobj, jdouble XSize, jdouble YSize, jdouble OffSet)
2273 {
2274
2275 jcas_Locking alock(env);
2276 {
2277 try {
2278 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2279 the_this->SetRectangularGridGraphicValues((Quantity_Length) XSize,(Quantity_Length) YSize,(Quantity_Length) OffSet);
2280
2281 }
2282 catch (Standard_Failure) {
2283   Standard_SStream Err;
2284   Err <<   Standard_Failure::Caught(); 
2285   Err << (char) 0;
2286   jcas_ThrowException(env,Err.str().c_str());
2287 }
2288 }
2289 alock.Release();
2290
2291 }
2292
2293
2294
2295 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_SetDefaultLights (JNIEnv *env, jobject theobj)
2296 {
2297
2298 jcas_Locking alock(env);
2299 {
2300 try {
2301 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2302 the_this->SetDefaultLights();
2303
2304 }
2305 catch (Standard_Failure) {
2306   Standard_SStream Err;
2307   Err <<   Standard_Failure::Caught(); 
2308   Err << (char) 0;
2309   jcas_ThrowException(env,Err.str().c_str());
2310 }
2311 }
2312 alock.Release();
2313
2314 }
2315
2316
2317
2318 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1Viewer_Init (JNIEnv *env, jobject theobj)
2319 {
2320
2321 jcas_Locking alock(env);
2322 {
2323 try {
2324 Handle(V3d_Viewer) the_this = *((Handle(V3d_Viewer)*) jcas_GetHandle(env,theobj));
2325 the_this->Init();
2326
2327 }
2328 catch (Standard_Failure) {
2329   Standard_SStream Err;
2330   Err <<   Standard_Failure::Caught(); 
2331   Err << (char) 0;
2332   jcas_ThrowException(env,Err.str().c_str());
2333 }
2334 }
2335 alock.Release();
2336
2337 }
2338
2339
2340 }