Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_V3d_View_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_View.h>
22 #include <V3d_View.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_Window.hxx>
30 #include <Standard_Integer.hxx>
31 #include <Standard_Boolean.hxx>
32 #include <Quantity_TypeOfColor.hxx>
33 #include <Standard_Real.hxx>
34 #include <Quantity_Color.hxx>
35 #include <Quantity_NameOfColor.hxx>
36 #include <Standard_CString.hxx>
37 #include <Aspect_FillMethod.hxx>
38 #include <V3d_TypeOfShadingModel.hxx>
39 #include <V3d_TypeOfSurfaceDetail.hxx>
40 #include <Graphic3d_TextureEnv.hxx>
41 #include <V3d_TypeOfVisualization.hxx>
42 #include <V3d_TypeOfZclipping.hxx>
43 #include <V3d_Light.hxx>
44 #include <V3d_Plane.hxx>
45 #include <Aspect_TypeOfTriedronPosition.hxx>
46 #include <Aspect_TypeOfTriedronEcho.hxx>
47 #include <Aspect_ColorScale.hxx>
48 #include <V3d_TypeOfAxe.hxx>
49 #include <V3d_TypeOfOrientation.hxx>
50 #include <V3d_Viewer.hxx>
51 #include <V3d_TypeOfView.hxx>
52 #include <Visual3d_View.hxx>
53 #include <Graphic3d_Plotter.hxx>
54 #include <gp_Ax3.hxx>
55 #include <Aspect_Grid.hxx>
56 #include <PlotMgt_PlotterDriver.hxx>
57 #include <Aspect_FormatOfSheetPaper.hxx>
58 #include <Aspect_PixMap.hxx>
59 #include <V3d_TypeOfProjectionModel.hxx>
60 #include <V3d_TypeOfBackfacingModel.hxx>
61
62
63 extern "C" {
64
65
66 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetWindow_11 (JNIEnv *env, jobject theobj, jobject IdWin)
67 {
68
69 jcas_Locking alock(env);
70 {
71 try {
72  Handle( Aspect_Window ) the_IdWin;
73  void*                ptr_IdWin = jcas_GetHandle(env,IdWin);
74  
75  if ( ptr_IdWin != NULL ) the_IdWin = *(   (  Handle( Aspect_Window )*  )ptr_IdWin   );
76
77 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
78 the_this->SetWindow(the_IdWin);
79
80 }
81 catch (Standard_Failure) {
82   Standard_SStream Err;
83   Err <<   Standard_Failure::Caught(); 
84   Err << (char) 0;
85   jcas_ThrowException(env,Err.str().c_str());
86 }
87 }
88 alock.Release();
89
90 }
91
92
93
94 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetMagnify (JNIEnv *env, jobject theobj, jobject IdWin, jobject aPreviousView, jint x1, jint y1, jint x2, jint y2)
95 {
96
97 jcas_Locking alock(env);
98 {
99 try {
100  Handle( Aspect_Window ) the_IdWin;
101  void*                ptr_IdWin = jcas_GetHandle(env,IdWin);
102  
103  if ( ptr_IdWin != NULL ) the_IdWin = *(   (  Handle( Aspect_Window )*  )ptr_IdWin   );
104
105  Handle( V3d_View ) the_aPreviousView;
106  void*                ptr_aPreviousView = jcas_GetHandle(env,aPreviousView);
107  
108  if ( ptr_aPreviousView != NULL ) the_aPreviousView = *(   (  Handle( V3d_View )*  )ptr_aPreviousView   );
109
110 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
111 the_this->SetMagnify(the_IdWin,the_aPreviousView,(Standard_Integer) x1,(Standard_Integer) y1,(Standard_Integer) x2,(Standard_Integer) y2);
112
113 }
114 catch (Standard_Failure) {
115   Standard_SStream Err;
116   Err <<   Standard_Failure::Caught(); 
117   Err << (char) 0;
118   jcas_ThrowException(env,Err.str().c_str());
119 }
120 }
121 alock.Release();
122
123 }
124
125
126
127 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Remove (JNIEnv *env, jobject theobj)
128 {
129
130 jcas_Locking alock(env);
131 {
132 try {
133 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
134 the_this->Remove();
135
136 }
137 catch (Standard_Failure) {
138   Standard_SStream Err;
139   Err <<   Standard_Failure::Caught(); 
140   Err << (char) 0;
141   jcas_ThrowException(env,Err.str().c_str());
142 }
143 }
144 alock.Release();
145
146 }
147
148
149
150 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Update (JNIEnv *env, jobject theobj)
151 {
152
153 jcas_Locking alock(env);
154 {
155 try {
156 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
157 the_this->Update();
158
159 }
160 catch (Standard_Failure) {
161   Standard_SStream Err;
162   Err <<   Standard_Failure::Caught(); 
163   Err << (char) 0;
164   jcas_ThrowException(env,Err.str().c_str());
165 }
166 }
167 alock.Release();
168
169 }
170
171
172
173 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Redraw_11 (JNIEnv *env, jobject theobj)
174 {
175
176 jcas_Locking alock(env);
177 {
178 try {
179 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
180 the_this->Redraw();
181
182 }
183 catch (Standard_Failure) {
184   Standard_SStream Err;
185   Err <<   Standard_Failure::Caught(); 
186   Err << (char) 0;
187   jcas_ThrowException(env,Err.str().c_str());
188 }
189 }
190 alock.Release();
191
192 }
193
194
195
196 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Redraw_12 (JNIEnv *env, jobject theobj, jint x, jint y, jint width, jint height)
197 {
198
199 jcas_Locking alock(env);
200 {
201 try {
202 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
203 the_this->Redraw((Standard_Integer) x,(Standard_Integer) y,(Standard_Integer) width,(Standard_Integer) height);
204
205 }
206 catch (Standard_Failure) {
207   Standard_SStream Err;
208   Err <<   Standard_Failure::Caught(); 
209   Err << (char) 0;
210   jcas_ThrowException(env,Err.str().c_str());
211 }
212 }
213 alock.Release();
214
215 }
216
217
218
219 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_MustBeResized (JNIEnv *env, jobject theobj)
220 {
221
222 jcas_Locking alock(env);
223 {
224 try {
225 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
226 the_this->MustBeResized();
227
228 }
229 catch (Standard_Failure) {
230   Standard_SStream Err;
231   Err <<   Standard_Failure::Caught(); 
232   Err << (char) 0;
233   jcas_ThrowException(env,Err.str().c_str());
234 }
235 }
236 alock.Release();
237
238 }
239
240
241
242 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_DoMapping (JNIEnv *env, jobject theobj)
243 {
244
245 jcas_Locking alock(env);
246 {
247 try {
248 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
249 the_this->DoMapping();
250
251 }
252 catch (Standard_Failure) {
253   Standard_SStream Err;
254   Err <<   Standard_Failure::Caught(); 
255   Err << (char) 0;
256   jcas_ThrowException(env,Err.str().c_str());
257 }
258 }
259 alock.Release();
260
261 }
262
263
264
265 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IsEmpty (JNIEnv *env, jobject theobj)
266 {
267 jboolean thejret;
268
269 jcas_Locking alock(env);
270 {
271 try {
272 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
273  thejret = the_this->IsEmpty();
274
275 }
276 catch (Standard_Failure) {
277   Standard_SStream Err;
278   Err <<   Standard_Failure::Caught(); 
279   Err << (char) 0;
280   jcas_ThrowException(env,Err.str().c_str());
281 }
282 }
283 alock.Release();
284 return thejret;
285 }
286
287
288
289 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_UpdateLights (JNIEnv *env, jobject theobj)
290 {
291
292 jcas_Locking alock(env);
293 {
294 try {
295 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
296 the_this->UpdateLights();
297
298 }
299 catch (Standard_Failure) {
300   Standard_SStream Err;
301   Err <<   Standard_Failure::Caught(); 
302   Err << (char) 0;
303   jcas_ThrowException(env,Err.str().c_str());
304 }
305 }
306 alock.Release();
307
308 }
309
310
311
312 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetBackgroundColor_11 (JNIEnv *env, jobject theobj, jshort Type, jdouble V1, jdouble V2, jdouble V3)
313 {
314
315 jcas_Locking alock(env);
316 {
317 try {
318 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
319 the_this->SetBackgroundColor((Quantity_TypeOfColor) Type,(Quantity_Parameter) V1,(Quantity_Parameter) V2,(Quantity_Parameter) V3);
320
321 }
322 catch (Standard_Failure) {
323   Standard_SStream Err;
324   Err <<   Standard_Failure::Caught(); 
325   Err << (char) 0;
326   jcas_ThrowException(env,Err.str().c_str());
327 }
328 }
329 alock.Release();
330
331 }
332
333
334
335 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetBackgroundColor_12 (JNIEnv *env, jobject theobj, jobject Color)
336 {
337
338 jcas_Locking alock(env);
339 {
340 try {
341 Quantity_Color* the_Color = (Quantity_Color*) jcas_GetHandle(env,Color);
342 if ( the_Color == NULL ) {
343
344  // The following assumes availability of the default constructor (what may not
345  // always be the case). Therefore explicit exception is thrown if the null
346  // object has been passed.
347  // the_Color = new Quantity_Color ();
348  // jcas_SetHandle ( env, Color, the_Color );
349  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
350
351 }  // end if
352 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
353 the_this->SetBackgroundColor(*the_Color);
354
355 }
356 catch (Standard_Failure) {
357   Standard_SStream Err;
358   Err <<   Standard_Failure::Caught(); 
359   Err << (char) 0;
360   jcas_ThrowException(env,Err.str().c_str());
361 }
362 }
363 alock.Release();
364
365 }
366
367
368
369 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetBackgroundColor_13 (JNIEnv *env, jobject theobj, jshort Name)
370 {
371
372 jcas_Locking alock(env);
373 {
374 try {
375 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
376 the_this->SetBackgroundColor((Quantity_NameOfColor) Name);
377
378 }
379 catch (Standard_Failure) {
380   Standard_SStream Err;
381   Err <<   Standard_Failure::Caught(); 
382   Err << (char) 0;
383   jcas_ThrowException(env,Err.str().c_str());
384 }
385 }
386 alock.Release();
387
388 }
389
390
391
392 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetBackgroundImage (JNIEnv *env, jobject theobj, jobject FileName, jshort FillStyle, jboolean update)
393 {
394
395 jcas_Locking alock(env);
396 {
397 try {
398 Standard_CString the_FileName = jcas_ConvertToCString(env,FileName);
399 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
400 the_this->SetBackgroundImage(the_FileName,(Aspect_FillMethod) FillStyle,(Standard_Boolean) update);
401
402 }
403 catch (Standard_Failure) {
404   Standard_SStream Err;
405   Err <<   Standard_Failure::Caught(); 
406   Err << (char) 0;
407   jcas_ThrowException(env,Err.str().c_str());
408 }
409 }
410 alock.Release();
411
412 }
413
414
415
416 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetBgImageStyle (JNIEnv *env, jobject theobj, jshort FillStyle, jboolean update)
417 {
418
419 jcas_Locking alock(env);
420 {
421 try {
422 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
423 the_this->SetBgImageStyle((Aspect_FillMethod) FillStyle,(Standard_Boolean) update);
424
425 }
426 catch (Standard_Failure) {
427   Standard_SStream Err;
428   Err <<   Standard_Failure::Caught(); 
429   Err << (char) 0;
430   jcas_ThrowException(env,Err.str().c_str());
431 }
432 }
433 alock.Release();
434
435 }
436
437
438
439 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetAxis (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z, jdouble Vx, jdouble Vy, jdouble Vz)
440 {
441
442 jcas_Locking alock(env);
443 {
444 try {
445 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
446 the_this->SetAxis((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,(Quantity_Parameter) Vx,(Quantity_Parameter) Vy,(Quantity_Parameter) Vz);
447
448 }
449 catch (Standard_Failure) {
450   Standard_SStream Err;
451   Err <<   Standard_Failure::Caught(); 
452   Err << (char) 0;
453   jcas_ThrowException(env,Err.str().c_str());
454 }
455 }
456 alock.Release();
457
458 }
459
460
461
462 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetShadingModel (JNIEnv *env, jobject theobj, jshort Model)
463 {
464
465 jcas_Locking alock(env);
466 {
467 try {
468 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
469 the_this->SetShadingModel((V3d_TypeOfShadingModel) Model);
470
471 }
472 catch (Standard_Failure) {
473   Standard_SStream Err;
474   Err <<   Standard_Failure::Caught(); 
475   Err << (char) 0;
476   jcas_ThrowException(env,Err.str().c_str());
477 }
478 }
479 alock.Release();
480
481 }
482
483
484
485 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetSurfaceDetail (JNIEnv *env, jobject theobj, jshort SurfaceDetail)
486 {
487
488 jcas_Locking alock(env);
489 {
490 try {
491 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
492 the_this->SetSurfaceDetail((V3d_TypeOfSurfaceDetail) SurfaceDetail);
493
494 }
495 catch (Standard_Failure) {
496   Standard_SStream Err;
497   Err <<   Standard_Failure::Caught(); 
498   Err << (char) 0;
499   jcas_ThrowException(env,Err.str().c_str());
500 }
501 }
502 alock.Release();
503
504 }
505
506
507
508 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetTextureEnv (JNIEnv *env, jobject theobj, jobject ATexture)
509 {
510
511 jcas_Locking alock(env);
512 {
513 try {
514  Handle( Graphic3d_TextureEnv ) the_ATexture;
515  void*                ptr_ATexture = jcas_GetHandle(env,ATexture);
516  
517  if ( ptr_ATexture != NULL ) the_ATexture = *(   (  Handle( Graphic3d_TextureEnv )*  )ptr_ATexture   );
518
519 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
520 the_this->SetTextureEnv(the_ATexture);
521
522 }
523 catch (Standard_Failure) {
524   Standard_SStream Err;
525   Err <<   Standard_Failure::Caught(); 
526   Err << (char) 0;
527   jcas_ThrowException(env,Err.str().c_str());
528 }
529 }
530 alock.Release();
531
532 }
533
534
535
536 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetVisualization (JNIEnv *env, jobject theobj, jshort Mode)
537 {
538
539 jcas_Locking alock(env);
540 {
541 try {
542 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
543 the_this->SetVisualization((V3d_TypeOfVisualization) Mode);
544
545 }
546 catch (Standard_Failure) {
547   Standard_SStream Err;
548   Err <<   Standard_Failure::Caught(); 
549   Err << (char) 0;
550   jcas_ThrowException(env,Err.str().c_str());
551 }
552 }
553 alock.Release();
554
555 }
556
557
558
559 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetAntialiasingOn (JNIEnv *env, jobject theobj)
560 {
561
562 jcas_Locking alock(env);
563 {
564 try {
565 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
566 the_this->SetAntialiasingOn();
567
568 }
569 catch (Standard_Failure) {
570   Standard_SStream Err;
571   Err <<   Standard_Failure::Caught(); 
572   Err << (char) 0;
573   jcas_ThrowException(env,Err.str().c_str());
574 }
575 }
576 alock.Release();
577
578 }
579
580
581
582 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetAntialiasingOff (JNIEnv *env, jobject theobj)
583 {
584
585 jcas_Locking alock(env);
586 {
587 try {
588 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
589 the_this->SetAntialiasingOff();
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
601 }
602
603
604
605 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetZClippingDepth (JNIEnv *env, jobject theobj, jdouble Depth)
606 {
607
608 jcas_Locking alock(env);
609 {
610 try {
611 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
612 the_this->SetZClippingDepth((Quantity_Length) Depth);
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_1View_SetZClippingWidth (JNIEnv *env, jobject theobj, jdouble Width)
629 {
630
631 jcas_Locking alock(env);
632 {
633 try {
634 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
635 the_this->SetZClippingWidth((Quantity_Length) Width);
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_1View_SetZClippingType (JNIEnv *env, jobject theobj, jshort Type)
652 {
653
654 jcas_Locking alock(env);
655 {
656 try {
657 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
658 the_this->SetZClippingType((V3d_TypeOfZclipping) Type);
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_1View_SetZCueingDepth (JNIEnv *env, jobject theobj, jdouble Depth)
675 {
676
677 jcas_Locking alock(env);
678 {
679 try {
680 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
681 the_this->SetZCueingDepth((Quantity_Length) Depth);
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_1View_SetZCueingWidth (JNIEnv *env, jobject theobj, jdouble Width)
698 {
699
700 jcas_Locking alock(env);
701 {
702 try {
703 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
704 the_this->SetZCueingWidth((Quantity_Length) Width);
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_1View_SetZCueingOn (JNIEnv *env, jobject theobj)
721 {
722
723 jcas_Locking alock(env);
724 {
725 try {
726 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
727 the_this->SetZCueingOn();
728
729 }
730 catch (Standard_Failure) {
731   Standard_SStream Err;
732   Err <<   Standard_Failure::Caught(); 
733   Err << (char) 0;
734   jcas_ThrowException(env,Err.str().c_str());
735 }
736 }
737 alock.Release();
738
739 }
740
741
742
743 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetZCueingOff (JNIEnv *env, jobject theobj)
744 {
745
746 jcas_Locking alock(env);
747 {
748 try {
749 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
750 the_this->SetZCueingOff();
751
752 }
753 catch (Standard_Failure) {
754   Standard_SStream Err;
755   Err <<   Standard_Failure::Caught(); 
756   Err << (char) 0;
757   jcas_ThrowException(env,Err.str().c_str());
758 }
759 }
760 alock.Release();
761
762 }
763
764
765
766 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetLightOn_11 (JNIEnv *env, jobject theobj, jobject MyLight)
767 {
768
769 jcas_Locking alock(env);
770 {
771 try {
772  Handle( V3d_Light ) the_MyLight;
773  void*                ptr_MyLight = jcas_GetHandle(env,MyLight);
774  
775  if ( ptr_MyLight != NULL ) the_MyLight = *(   (  Handle( V3d_Light )*  )ptr_MyLight   );
776
777 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
778 the_this->SetLightOn(the_MyLight);
779
780 }
781 catch (Standard_Failure) {
782   Standard_SStream Err;
783   Err <<   Standard_Failure::Caught(); 
784   Err << (char) 0;
785   jcas_ThrowException(env,Err.str().c_str());
786 }
787 }
788 alock.Release();
789
790 }
791
792
793
794 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetLightOn_12 (JNIEnv *env, jobject theobj)
795 {
796
797 jcas_Locking alock(env);
798 {
799 try {
800 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
801 the_this->SetLightOn();
802
803 }
804 catch (Standard_Failure) {
805   Standard_SStream Err;
806   Err <<   Standard_Failure::Caught(); 
807   Err << (char) 0;
808   jcas_ThrowException(env,Err.str().c_str());
809 }
810 }
811 alock.Release();
812
813 }
814
815
816
817 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetLightOff_11 (JNIEnv *env, jobject theobj, jobject MyLight)
818 {
819
820 jcas_Locking alock(env);
821 {
822 try {
823  Handle( V3d_Light ) the_MyLight;
824  void*                ptr_MyLight = jcas_GetHandle(env,MyLight);
825  
826  if ( ptr_MyLight != NULL ) the_MyLight = *(   (  Handle( V3d_Light )*  )ptr_MyLight   );
827
828 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
829 the_this->SetLightOff(the_MyLight);
830
831 }
832 catch (Standard_Failure) {
833   Standard_SStream Err;
834   Err <<   Standard_Failure::Caught(); 
835   Err << (char) 0;
836   jcas_ThrowException(env,Err.str().c_str());
837 }
838 }
839 alock.Release();
840
841 }
842
843
844
845 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetLightOff_12 (JNIEnv *env, jobject theobj)
846 {
847
848 jcas_Locking alock(env);
849 {
850 try {
851 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
852 the_this->SetLightOff();
853
854 }
855 catch (Standard_Failure) {
856   Standard_SStream Err;
857   Err <<   Standard_Failure::Caught(); 
858   Err << (char) 0;
859   jcas_ThrowException(env,Err.str().c_str());
860 }
861 }
862 alock.Release();
863
864 }
865
866
867
868 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IsActiveLight (JNIEnv *env, jobject theobj, jobject aLight)
869 {
870 jboolean thejret;
871
872 jcas_Locking alock(env);
873 {
874 try {
875  Handle( V3d_Light ) the_aLight;
876  void*                ptr_aLight = jcas_GetHandle(env,aLight);
877  
878  if ( ptr_aLight != NULL ) the_aLight = *(   (  Handle( V3d_Light )*  )ptr_aLight   );
879
880 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
881  thejret = the_this->IsActiveLight(the_aLight);
882
883 }
884 catch (Standard_Failure) {
885   Standard_SStream Err;
886   Err <<   Standard_Failure::Caught(); 
887   Err << (char) 0;
888   jcas_ThrowException(env,Err.str().c_str());
889 }
890 }
891 alock.Release();
892 return thejret;
893 }
894
895
896
897 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetTransparency (JNIEnv *env, jobject theobj, jboolean AnActivity)
898 {
899
900 jcas_Locking alock(env);
901 {
902 try {
903 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
904 the_this->SetTransparency((Standard_Boolean) AnActivity);
905
906 }
907 catch (Standard_Failure) {
908   Standard_SStream Err;
909   Err <<   Standard_Failure::Caught(); 
910   Err << (char) 0;
911   jcas_ThrowException(env,Err.str().c_str());
912 }
913 }
914 alock.Release();
915
916 }
917
918
919
920 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetPlaneOn_11 (JNIEnv *env, jobject theobj, jobject MyPlane)
921 {
922
923 jcas_Locking alock(env);
924 {
925 try {
926  Handle( V3d_Plane ) the_MyPlane;
927  void*                ptr_MyPlane = jcas_GetHandle(env,MyPlane);
928  
929  if ( ptr_MyPlane != NULL ) the_MyPlane = *(   (  Handle( V3d_Plane )*  )ptr_MyPlane   );
930
931 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
932 the_this->SetPlaneOn(the_MyPlane);
933
934 }
935 catch (Standard_Failure) {
936   Standard_SStream Err;
937   Err <<   Standard_Failure::Caught(); 
938   Err << (char) 0;
939   jcas_ThrowException(env,Err.str().c_str());
940 }
941 }
942 alock.Release();
943
944 }
945
946
947
948 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetPlaneOn_12 (JNIEnv *env, jobject theobj)
949 {
950
951 jcas_Locking alock(env);
952 {
953 try {
954 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
955 the_this->SetPlaneOn();
956
957 }
958 catch (Standard_Failure) {
959   Standard_SStream Err;
960   Err <<   Standard_Failure::Caught(); 
961   Err << (char) 0;
962   jcas_ThrowException(env,Err.str().c_str());
963 }
964 }
965 alock.Release();
966
967 }
968
969
970
971 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetPlaneOff_11 (JNIEnv *env, jobject theobj, jobject MyPlane)
972 {
973
974 jcas_Locking alock(env);
975 {
976 try {
977  Handle( V3d_Plane ) the_MyPlane;
978  void*                ptr_MyPlane = jcas_GetHandle(env,MyPlane);
979  
980  if ( ptr_MyPlane != NULL ) the_MyPlane = *(   (  Handle( V3d_Plane )*  )ptr_MyPlane   );
981
982 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
983 the_this->SetPlaneOff(the_MyPlane);
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
995 }
996
997
998
999 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetPlaneOff_12 (JNIEnv *env, jobject theobj)
1000 {
1001
1002 jcas_Locking alock(env);
1003 {
1004 try {
1005 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1006 the_this->SetPlaneOff();
1007
1008 }
1009 catch (Standard_Failure) {
1010   Standard_SStream Err;
1011   Err <<   Standard_Failure::Caught(); 
1012   Err << (char) 0;
1013   jcas_ThrowException(env,Err.str().c_str());
1014 }
1015 }
1016 alock.Release();
1017
1018 }
1019
1020
1021
1022 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IsActivePlane (JNIEnv *env, jobject theobj, jobject aPlane)
1023 {
1024 jboolean thejret;
1025
1026 jcas_Locking alock(env);
1027 {
1028 try {
1029  Handle( V3d_Plane ) the_aPlane;
1030  void*                ptr_aPlane = jcas_GetHandle(env,aPlane);
1031  
1032  if ( ptr_aPlane != NULL ) the_aPlane = *(   (  Handle( V3d_Plane )*  )ptr_aPlane   );
1033
1034 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1035  thejret = the_this->IsActivePlane(the_aPlane);
1036
1037 }
1038 catch (Standard_Failure) {
1039   Standard_SStream Err;
1040   Err <<   Standard_Failure::Caught(); 
1041   Err << (char) 0;
1042   jcas_ThrowException(env,Err.str().c_str());
1043 }
1044 }
1045 alock.Release();
1046 return thejret;
1047 }
1048
1049
1050
1051 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ZBufferTriedronSetup (JNIEnv *env, jobject theobj, jshort XColor, jshort YColor, jshort ZColor, jdouble SizeRatio, jdouble AxisDiametr, jint NbFacettes)
1052 {
1053
1054 jcas_Locking alock(env);
1055 {
1056 try {
1057 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1058 the_this->ZBufferTriedronSetup((Quantity_NameOfColor) XColor,(Quantity_NameOfColor) YColor,(Quantity_NameOfColor) ZColor,(Standard_Real) SizeRatio,(Standard_Real) AxisDiametr,(Standard_Integer) NbFacettes);
1059
1060 }
1061 catch (Standard_Failure) {
1062   Standard_SStream Err;
1063   Err <<   Standard_Failure::Caught(); 
1064   Err << (char) 0;
1065   jcas_ThrowException(env,Err.str().c_str());
1066 }
1067 }
1068 alock.Release();
1069
1070 }
1071
1072
1073
1074 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_TriedronDisplay (JNIEnv *env, jobject theobj, jshort APosition, jshort AColor, jdouble AScale, jshort AMode)
1075 {
1076
1077 jcas_Locking alock(env);
1078 {
1079 try {
1080 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1081 the_this->TriedronDisplay((Aspect_TypeOfTriedronPosition) APosition,(Quantity_NameOfColor) AColor,(Standard_Real) AScale,(V3d_TypeOfVisualization) AMode);
1082
1083 }
1084 catch (Standard_Failure) {
1085   Standard_SStream Err;
1086   Err <<   Standard_Failure::Caught(); 
1087   Err << (char) 0;
1088   jcas_ThrowException(env,Err.str().c_str());
1089 }
1090 }
1091 alock.Release();
1092
1093 }
1094
1095
1096
1097 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_TriedronErase (JNIEnv *env, jobject theobj)
1098 {
1099
1100 jcas_Locking alock(env);
1101 {
1102 try {
1103 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1104 the_this->TriedronErase();
1105
1106 }
1107 catch (Standard_Failure) {
1108   Standard_SStream Err;
1109   Err <<   Standard_Failure::Caught(); 
1110   Err << (char) 0;
1111   jcas_ThrowException(env,Err.str().c_str());
1112 }
1113 }
1114 alock.Release();
1115
1116 }
1117
1118
1119
1120 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_TriedronEcho (JNIEnv *env, jobject theobj, jshort AType)
1121 {
1122
1123 jcas_Locking alock(env);
1124 {
1125 try {
1126 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1127 the_this->TriedronEcho((Aspect_TypeOfTriedronEcho) AType);
1128
1129 }
1130 catch (Standard_Failure) {
1131   Standard_SStream Err;
1132   Err <<   Standard_Failure::Caught(); 
1133   Err << (char) 0;
1134   jcas_ThrowException(env,Err.str().c_str());
1135 }
1136 }
1137 alock.Release();
1138
1139 }
1140
1141
1142
1143 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ColorScaleDisplay (JNIEnv *env, jobject theobj)
1144 {
1145
1146 jcas_Locking alock(env);
1147 {
1148 try {
1149 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1150 the_this->ColorScaleDisplay();
1151
1152 }
1153 catch (Standard_Failure) {
1154   Standard_SStream Err;
1155   Err <<   Standard_Failure::Caught(); 
1156   Err << (char) 0;
1157   jcas_ThrowException(env,Err.str().c_str());
1158 }
1159 }
1160 alock.Release();
1161
1162 }
1163
1164
1165
1166 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ColorScaleErase (JNIEnv *env, jobject theobj)
1167 {
1168
1169 jcas_Locking alock(env);
1170 {
1171 try {
1172 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1173 the_this->ColorScaleErase();
1174
1175 }
1176 catch (Standard_Failure) {
1177   Standard_SStream Err;
1178   Err <<   Standard_Failure::Caught(); 
1179   Err << (char) 0;
1180   jcas_ThrowException(env,Err.str().c_str());
1181 }
1182 }
1183 alock.Release();
1184
1185 }
1186
1187
1188
1189 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_ColorScaleIsDisplayed (JNIEnv *env, jobject theobj)
1190 {
1191 jboolean thejret;
1192
1193 jcas_Locking alock(env);
1194 {
1195 try {
1196 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1197  thejret = the_this->ColorScaleIsDisplayed();
1198
1199 }
1200 catch (Standard_Failure) {
1201   Standard_SStream Err;
1202   Err <<   Standard_Failure::Caught(); 
1203   Err << (char) 0;
1204   jcas_ThrowException(env,Err.str().c_str());
1205 }
1206 }
1207 alock.Release();
1208 return thejret;
1209 }
1210
1211
1212
1213 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_ColorScale (JNIEnv *env, jobject theobj)
1214 {
1215 jobject thejret;
1216
1217 jcas_Locking alock(env);
1218 {
1219 try {
1220 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1221 Handle(Aspect_ColorScale)* theret = new Handle(Aspect_ColorScale);
1222 *theret = the_this->ColorScale();
1223 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_ColorScale",theret);
1224
1225 }
1226 catch (Standard_Failure) {
1227   Standard_SStream Err;
1228   Err <<   Standard_Failure::Caught(); 
1229   Err << (char) 0;
1230   jcas_ThrowException(env,Err.str().c_str());
1231 }
1232 }
1233 alock.Release();
1234 return thejret;
1235 }
1236
1237
1238
1239 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetFront (JNIEnv *env, jobject theobj)
1240 {
1241
1242 jcas_Locking alock(env);
1243 {
1244 try {
1245 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1246 the_this->SetFront();
1247
1248 }
1249 catch (Standard_Failure) {
1250   Standard_SStream Err;
1251   Err <<   Standard_Failure::Caught(); 
1252   Err << (char) 0;
1253   jcas_ThrowException(env,Err.str().c_str());
1254 }
1255 }
1256 alock.Release();
1257
1258 }
1259
1260
1261
1262 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Rotate_11 (JNIEnv *env, jobject theobj, jdouble Ax, jdouble Ay, jdouble Az, jboolean Start)
1263 {
1264
1265 jcas_Locking alock(env);
1266 {
1267 try {
1268 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1269 the_this->Rotate((Quantity_PlaneAngle) Ax,(Quantity_PlaneAngle) Ay,(Quantity_PlaneAngle) Az,(Standard_Boolean) Start);
1270
1271 }
1272 catch (Standard_Failure) {
1273   Standard_SStream Err;
1274   Err <<   Standard_Failure::Caught(); 
1275   Err << (char) 0;
1276   jcas_ThrowException(env,Err.str().c_str());
1277 }
1278 }
1279 alock.Release();
1280
1281 }
1282
1283
1284
1285 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Rotate_12 (JNIEnv *env, jobject theobj, jdouble Ax, jdouble Ay, jdouble Az, jdouble X, jdouble Y, jdouble Z, jboolean Start)
1286 {
1287
1288 jcas_Locking alock(env);
1289 {
1290 try {
1291 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1292 the_this->Rotate((Quantity_PlaneAngle) Ax,(Quantity_PlaneAngle) Ay,(Quantity_PlaneAngle) Az,(V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,(Standard_Boolean) Start);
1293
1294 }
1295 catch (Standard_Failure) {
1296   Standard_SStream Err;
1297   Err <<   Standard_Failure::Caught(); 
1298   Err << (char) 0;
1299   jcas_ThrowException(env,Err.str().c_str());
1300 }
1301 }
1302 alock.Release();
1303
1304 }
1305
1306
1307
1308 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Rotate_13 (JNIEnv *env, jobject theobj, jshort Axe, jdouble Angle, jdouble X, jdouble Y, jdouble Z, jboolean Start)
1309 {
1310
1311 jcas_Locking alock(env);
1312 {
1313 try {
1314 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1315 the_this->Rotate((V3d_TypeOfAxe) Axe,(Quantity_PlaneAngle) Angle,(V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,(Standard_Boolean) Start);
1316
1317 }
1318 catch (Standard_Failure) {
1319   Standard_SStream Err;
1320   Err <<   Standard_Failure::Caught(); 
1321   Err << (char) 0;
1322   jcas_ThrowException(env,Err.str().c_str());
1323 }
1324 }
1325 alock.Release();
1326
1327 }
1328
1329
1330
1331 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Rotate_14 (JNIEnv *env, jobject theobj, jshort Axe, jdouble Angle, jboolean Start)
1332 {
1333
1334 jcas_Locking alock(env);
1335 {
1336 try {
1337 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1338 the_this->Rotate((V3d_TypeOfAxe) Axe,(Quantity_PlaneAngle) Angle,(Standard_Boolean) Start);
1339
1340 }
1341 catch (Standard_Failure) {
1342   Standard_SStream Err;
1343   Err <<   Standard_Failure::Caught(); 
1344   Err << (char) 0;
1345   jcas_ThrowException(env,Err.str().c_str());
1346 }
1347 }
1348 alock.Release();
1349
1350 }
1351
1352
1353
1354 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Rotate_15 (JNIEnv *env, jobject theobj, jdouble Angle, jboolean Start)
1355 {
1356
1357 jcas_Locking alock(env);
1358 {
1359 try {
1360 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1361 the_this->Rotate((Quantity_PlaneAngle) Angle,(Standard_Boolean) Start);
1362
1363 }
1364 catch (Standard_Failure) {
1365   Standard_SStream Err;
1366   Err <<   Standard_Failure::Caught(); 
1367   Err << (char) 0;
1368   jcas_ThrowException(env,Err.str().c_str());
1369 }
1370 }
1371 alock.Release();
1372
1373 }
1374
1375
1376
1377 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Move_11 (JNIEnv *env, jobject theobj, jdouble Dx, jdouble Dy, jdouble Dz, jboolean Start)
1378 {
1379
1380 jcas_Locking alock(env);
1381 {
1382 try {
1383 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1384 the_this->Move((Quantity_Length) Dx,(Quantity_Length) Dy,(Quantity_Length) Dz,(Standard_Boolean) Start);
1385
1386 }
1387 catch (Standard_Failure) {
1388   Standard_SStream Err;
1389   Err <<   Standard_Failure::Caught(); 
1390   Err << (char) 0;
1391   jcas_ThrowException(env,Err.str().c_str());
1392 }
1393 }
1394 alock.Release();
1395
1396 }
1397
1398
1399
1400 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Move_12 (JNIEnv *env, jobject theobj, jshort Axe, jdouble Length, jboolean Start)
1401 {
1402
1403 jcas_Locking alock(env);
1404 {
1405 try {
1406 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1407 the_this->Move((V3d_TypeOfAxe) Axe,(Quantity_Length) Length,(Standard_Boolean) Start);
1408
1409 }
1410 catch (Standard_Failure) {
1411   Standard_SStream Err;
1412   Err <<   Standard_Failure::Caught(); 
1413   Err << (char) 0;
1414   jcas_ThrowException(env,Err.str().c_str());
1415 }
1416 }
1417 alock.Release();
1418
1419 }
1420
1421
1422
1423 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Move_13 (JNIEnv *env, jobject theobj, jdouble Length, jboolean Start)
1424 {
1425
1426 jcas_Locking alock(env);
1427 {
1428 try {
1429 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1430 the_this->Move((Quantity_Length) Length,(Standard_Boolean) Start);
1431
1432 }
1433 catch (Standard_Failure) {
1434   Standard_SStream Err;
1435   Err <<   Standard_Failure::Caught(); 
1436   Err << (char) 0;
1437   jcas_ThrowException(env,Err.str().c_str());
1438 }
1439 }
1440 alock.Release();
1441
1442 }
1443
1444
1445
1446 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Translate_11 (JNIEnv *env, jobject theobj, jdouble Dx, jdouble Dy, jdouble Dz, jboolean Start)
1447 {
1448
1449 jcas_Locking alock(env);
1450 {
1451 try {
1452 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1453 the_this->Translate((Quantity_Length) Dx,(Quantity_Length) Dy,(Quantity_Length) Dz,(Standard_Boolean) Start);
1454
1455 }
1456 catch (Standard_Failure) {
1457   Standard_SStream Err;
1458   Err <<   Standard_Failure::Caught(); 
1459   Err << (char) 0;
1460   jcas_ThrowException(env,Err.str().c_str());
1461 }
1462 }
1463 alock.Release();
1464
1465 }
1466
1467
1468
1469 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Translate_12 (JNIEnv *env, jobject theobj, jshort Axe, jdouble Length, jboolean Start)
1470 {
1471
1472 jcas_Locking alock(env);
1473 {
1474 try {
1475 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1476 the_this->Translate((V3d_TypeOfAxe) Axe,(Quantity_Length) Length,(Standard_Boolean) Start);
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
1488 }
1489
1490
1491
1492 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Translate_13 (JNIEnv *env, jobject theobj, jdouble Length, jboolean Start)
1493 {
1494
1495 jcas_Locking alock(env);
1496 {
1497 try {
1498 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1499 the_this->Translate((Quantity_Length) Length,(Standard_Boolean) Start);
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 void JNICALL Java_CASCADESamplesJni_V3d_1View_Place (JNIEnv *env, jobject theobj, jint x, jint y, jdouble aZoomFactor)
1516 {
1517
1518 jcas_Locking alock(env);
1519 {
1520 try {
1521 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1522 the_this->Place((Standard_Integer) x,(Standard_Integer) y,(Quantity_Factor) aZoomFactor);
1523
1524 }
1525 catch (Standard_Failure) {
1526   Standard_SStream Err;
1527   Err <<   Standard_Failure::Caught(); 
1528   Err << (char) 0;
1529   jcas_ThrowException(env,Err.str().c_str());
1530 }
1531 }
1532 alock.Release();
1533
1534 }
1535
1536
1537
1538 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Turn_11 (JNIEnv *env, jobject theobj, jdouble Ax, jdouble Ay, jdouble Az, jboolean Start)
1539 {
1540
1541 jcas_Locking alock(env);
1542 {
1543 try {
1544 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1545 the_this->Turn((Quantity_PlaneAngle) Ax,(Quantity_PlaneAngle) Ay,(Quantity_PlaneAngle) Az,(Standard_Boolean) Start);
1546
1547 }
1548 catch (Standard_Failure) {
1549   Standard_SStream Err;
1550   Err <<   Standard_Failure::Caught(); 
1551   Err << (char) 0;
1552   jcas_ThrowException(env,Err.str().c_str());
1553 }
1554 }
1555 alock.Release();
1556
1557 }
1558
1559
1560
1561 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Turn_12 (JNIEnv *env, jobject theobj, jshort Axe, jdouble Angle, jboolean Start)
1562 {
1563
1564 jcas_Locking alock(env);
1565 {
1566 try {
1567 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1568 the_this->Turn((V3d_TypeOfAxe) Axe,(Quantity_PlaneAngle) Angle,(Standard_Boolean) Start);
1569
1570 }
1571 catch (Standard_Failure) {
1572   Standard_SStream Err;
1573   Err <<   Standard_Failure::Caught(); 
1574   Err << (char) 0;
1575   jcas_ThrowException(env,Err.str().c_str());
1576 }
1577 }
1578 alock.Release();
1579
1580 }
1581
1582
1583
1584 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Turn_13 (JNIEnv *env, jobject theobj, jdouble Angle, jboolean Start)
1585 {
1586
1587 jcas_Locking alock(env);
1588 {
1589 try {
1590 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1591 the_this->Turn((Quantity_PlaneAngle) Angle,(Standard_Boolean) Start);
1592
1593 }
1594 catch (Standard_Failure) {
1595   Standard_SStream Err;
1596   Err <<   Standard_Failure::Caught(); 
1597   Err << (char) 0;
1598   jcas_ThrowException(env,Err.str().c_str());
1599 }
1600 }
1601 alock.Release();
1602
1603 }
1604
1605
1606
1607 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetTwist (JNIEnv *env, jobject theobj, jdouble Angle)
1608 {
1609
1610 jcas_Locking alock(env);
1611 {
1612 try {
1613 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1614 the_this->SetTwist((Quantity_PlaneAngle) Angle);
1615
1616 }
1617 catch (Standard_Failure) {
1618   Standard_SStream Err;
1619   Err <<   Standard_Failure::Caught(); 
1620   Err << (char) 0;
1621   jcas_ThrowException(env,Err.str().c_str());
1622 }
1623 }
1624 alock.Release();
1625
1626 }
1627
1628
1629
1630 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetEye (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z)
1631 {
1632
1633 jcas_Locking alock(env);
1634 {
1635 try {
1636 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1637 the_this->SetEye((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z);
1638
1639 }
1640 catch (Standard_Failure) {
1641   Standard_SStream Err;
1642   Err <<   Standard_Failure::Caught(); 
1643   Err << (char) 0;
1644   jcas_ThrowException(env,Err.str().c_str());
1645 }
1646 }
1647 alock.Release();
1648
1649 }
1650
1651
1652
1653 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetDepth (JNIEnv *env, jobject theobj, jdouble Depth)
1654 {
1655
1656 jcas_Locking alock(env);
1657 {
1658 try {
1659 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1660 the_this->SetDepth((Quantity_Length) Depth);
1661
1662 }
1663 catch (Standard_Failure) {
1664   Standard_SStream Err;
1665   Err <<   Standard_Failure::Caught(); 
1666   Err << (char) 0;
1667   jcas_ThrowException(env,Err.str().c_str());
1668 }
1669 }
1670 alock.Release();
1671
1672 }
1673
1674
1675
1676 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetProj_11 (JNIEnv *env, jobject theobj, jdouble Vx, jdouble Vy, jdouble Vz)
1677 {
1678
1679 jcas_Locking alock(env);
1680 {
1681 try {
1682 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1683 the_this->SetProj((Quantity_Parameter) Vx,(Quantity_Parameter) Vy,(Quantity_Parameter) Vz);
1684
1685 }
1686 catch (Standard_Failure) {
1687   Standard_SStream Err;
1688   Err <<   Standard_Failure::Caught(); 
1689   Err << (char) 0;
1690   jcas_ThrowException(env,Err.str().c_str());
1691 }
1692 }
1693 alock.Release();
1694
1695 }
1696
1697
1698
1699 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetProj_12 (JNIEnv *env, jobject theobj, jshort Orientation)
1700 {
1701
1702 jcas_Locking alock(env);
1703 {
1704 try {
1705 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1706 the_this->SetProj((V3d_TypeOfOrientation) Orientation);
1707
1708 }
1709 catch (Standard_Failure) {
1710   Standard_SStream Err;
1711   Err <<   Standard_Failure::Caught(); 
1712   Err << (char) 0;
1713   jcas_ThrowException(env,Err.str().c_str());
1714 }
1715 }
1716 alock.Release();
1717
1718 }
1719
1720
1721
1722 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetAt (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z)
1723 {
1724
1725 jcas_Locking alock(env);
1726 {
1727 try {
1728 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1729 the_this->SetAt((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z);
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
1741 }
1742
1743
1744
1745 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetUp_11 (JNIEnv *env, jobject theobj, jdouble Vx, jdouble Vy, jdouble Vz)
1746 {
1747
1748 jcas_Locking alock(env);
1749 {
1750 try {
1751 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1752 the_this->SetUp((Quantity_Parameter) Vx,(Quantity_Parameter) Vy,(Quantity_Parameter) Vz);
1753
1754 }
1755 catch (Standard_Failure) {
1756   Standard_SStream Err;
1757   Err <<   Standard_Failure::Caught(); 
1758   Err << (char) 0;
1759   jcas_ThrowException(env,Err.str().c_str());
1760 }
1761 }
1762 alock.Release();
1763
1764 }
1765
1766
1767
1768 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetUp_12 (JNIEnv *env, jobject theobj, jshort Orientation)
1769 {
1770
1771 jcas_Locking alock(env);
1772 {
1773 try {
1774 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1775 the_this->SetUp((V3d_TypeOfOrientation) Orientation);
1776
1777 }
1778 catch (Standard_Failure) {
1779   Standard_SStream Err;
1780   Err <<   Standard_Failure::Caught(); 
1781   Err << (char) 0;
1782   jcas_ThrowException(env,Err.str().c_str());
1783 }
1784 }
1785 alock.Release();
1786
1787 }
1788
1789
1790
1791 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetViewOrientationDefault (JNIEnv *env, jobject theobj)
1792 {
1793
1794 jcas_Locking alock(env);
1795 {
1796 try {
1797 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1798 the_this->SetViewOrientationDefault();
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
1810 }
1811
1812
1813
1814 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ResetViewOrientation (JNIEnv *env, jobject theobj)
1815 {
1816
1817 jcas_Locking alock(env);
1818 {
1819 try {
1820 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1821 the_this->ResetViewOrientation();
1822
1823 }
1824 catch (Standard_Failure) {
1825   Standard_SStream Err;
1826   Err <<   Standard_Failure::Caught(); 
1827   Err << (char) 0;
1828   jcas_ThrowException(env,Err.str().c_str());
1829 }
1830 }
1831 alock.Release();
1832
1833 }
1834
1835
1836
1837 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Panning (JNIEnv *env, jobject theobj, jdouble Dx, jdouble Dy, jdouble aZoomFactor, jboolean Start)
1838 {
1839
1840 jcas_Locking alock(env);
1841 {
1842 try {
1843 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1844 the_this->Panning((Quantity_Length) Dx,(Quantity_Length) Dy,(Quantity_Factor) aZoomFactor,(Standard_Boolean) Start);
1845
1846 }
1847 catch (Standard_Failure) {
1848   Standard_SStream Err;
1849   Err <<   Standard_Failure::Caught(); 
1850   Err << (char) 0;
1851   jcas_ThrowException(env,Err.str().c_str());
1852 }
1853 }
1854 alock.Release();
1855
1856 }
1857
1858
1859
1860 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetCenter_11 (JNIEnv *env, jobject theobj, jdouble Xc, jdouble Yc)
1861 {
1862
1863 jcas_Locking alock(env);
1864 {
1865 try {
1866 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1867 the_this->SetCenter((V3d_Coordinate) Xc,(V3d_Coordinate) Yc);
1868
1869 }
1870 catch (Standard_Failure) {
1871   Standard_SStream Err;
1872   Err <<   Standard_Failure::Caught(); 
1873   Err << (char) 0;
1874   jcas_ThrowException(env,Err.str().c_str());
1875 }
1876 }
1877 alock.Release();
1878
1879 }
1880
1881
1882
1883 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1SetCenter_12 (JNIEnv *env, jobject theobj, jint X, jint Y)
1884 {
1885
1886 jcas_Locking alock(env);
1887 {
1888 try {
1889 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1890 the_this->SetCenter((Standard_Integer) X,(Standard_Integer) Y);
1891
1892 }
1893 catch (Standard_Failure) {
1894   Standard_SStream Err;
1895   Err <<   Standard_Failure::Caught(); 
1896   Err << (char) 0;
1897   jcas_ThrowException(env,Err.str().c_str());
1898 }
1899 }
1900 alock.Release();
1901
1902 }
1903
1904
1905
1906 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetSize (JNIEnv *env, jobject theobj, jdouble Size)
1907 {
1908
1909 jcas_Locking alock(env);
1910 {
1911 try {
1912 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1913 the_this->SetSize((Quantity_Length) Size);
1914
1915 }
1916 catch (Standard_Failure) {
1917   Standard_SStream Err;
1918   Err <<   Standard_Failure::Caught(); 
1919   Err << (char) 0;
1920   jcas_ThrowException(env,Err.str().c_str());
1921 }
1922 }
1923 alock.Release();
1924
1925 }
1926
1927
1928
1929 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetZSize (JNIEnv *env, jobject theobj, jdouble Size)
1930 {
1931
1932 jcas_Locking alock(env);
1933 {
1934 try {
1935 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1936 the_this->SetZSize((Quantity_Length) Size);
1937
1938 }
1939 catch (Standard_Failure) {
1940   Standard_SStream Err;
1941   Err <<   Standard_Failure::Caught(); 
1942   Err << (char) 0;
1943   jcas_ThrowException(env,Err.str().c_str());
1944 }
1945 }
1946 alock.Release();
1947
1948 }
1949
1950
1951
1952 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetZoom (JNIEnv *env, jobject theobj, jdouble Coef, jboolean Start)
1953 {
1954
1955 jcas_Locking alock(env);
1956 {
1957 try {
1958 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1959 the_this->SetZoom((Quantity_Factor) Coef,(Standard_Boolean) Start);
1960
1961 }
1962 catch (Standard_Failure) {
1963   Standard_SStream Err;
1964   Err <<   Standard_Failure::Caught(); 
1965   Err << (char) 0;
1966   jcas_ThrowException(env,Err.str().c_str());
1967 }
1968 }
1969 alock.Release();
1970
1971 }
1972
1973
1974
1975 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetScale (JNIEnv *env, jobject theobj, jdouble Coef)
1976 {
1977
1978 jcas_Locking alock(env);
1979 {
1980 try {
1981 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
1982 the_this->SetScale((Quantity_Factor) Coef);
1983
1984 }
1985 catch (Standard_Failure) {
1986   Standard_SStream Err;
1987   Err <<   Standard_Failure::Caught(); 
1988   Err << (char) 0;
1989   jcas_ThrowException(env,Err.str().c_str());
1990 }
1991 }
1992 alock.Release();
1993
1994 }
1995
1996
1997
1998 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetAxialScale (JNIEnv *env, jobject theobj, jdouble Sx, jdouble Sy, jdouble Sz)
1999 {
2000
2001 jcas_Locking alock(env);
2002 {
2003 try {
2004 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2005 the_this->SetAxialScale((Standard_Real) Sx,(Standard_Real) Sy,(Standard_Real) Sz);
2006
2007 }
2008 catch (Standard_Failure) {
2009   Standard_SStream Err;
2010   Err <<   Standard_Failure::Caught(); 
2011   Err << (char) 0;
2012   jcas_ThrowException(env,Err.str().c_str());
2013 }
2014 }
2015 alock.Release();
2016
2017 }
2018
2019
2020
2021 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1FitAll_11 (JNIEnv *env, jobject theobj, jdouble Coef, jboolean FitZ, jboolean update)
2022 {
2023
2024 jcas_Locking alock(env);
2025 {
2026 try {
2027 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2028 the_this->FitAll((Quantity_Coefficient) Coef,(Standard_Boolean) FitZ,(Standard_Boolean) update);
2029
2030 }
2031 catch (Standard_Failure) {
2032   Standard_SStream Err;
2033   Err <<   Standard_Failure::Caught(); 
2034   Err << (char) 0;
2035   jcas_ThrowException(env,Err.str().c_str());
2036 }
2037 }
2038 alock.Release();
2039
2040 }
2041
2042
2043
2044 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ZFitAll (JNIEnv *env, jobject theobj, jdouble Coef)
2045 {
2046
2047 jcas_Locking alock(env);
2048 {
2049 try {
2050 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2051 the_this->ZFitAll((Quantity_Coefficient) Coef);
2052
2053 }
2054 catch (Standard_Failure) {
2055   Standard_SStream Err;
2056   Err <<   Standard_Failure::Caught(); 
2057   Err << (char) 0;
2058   jcas_ThrowException(env,Err.str().c_str());
2059 }
2060 }
2061 alock.Release();
2062
2063 }
2064
2065
2066
2067 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1FitAll_12 (JNIEnv *env, jobject theobj, jdouble Umin, jdouble Vmin, jdouble Umax, jdouble Vmax)
2068 {
2069
2070 jcas_Locking alock(env);
2071 {
2072 try {
2073 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2074 the_this->FitAll((V3d_Coordinate) Umin,(V3d_Coordinate) Vmin,(V3d_Coordinate) Umax,(V3d_Coordinate) Vmax);
2075
2076 }
2077 catch (Standard_Failure) {
2078   Standard_SStream Err;
2079   Err <<   Standard_Failure::Caught(); 
2080   Err << (char) 0;
2081   jcas_ThrowException(env,Err.str().c_str());
2082 }
2083 }
2084 alock.Release();
2085
2086 }
2087
2088
2089
2090 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_WindowFit (JNIEnv *env, jobject theobj, jint Xmin, jint Ymin, jint Xmax, jint Ymax)
2091 {
2092
2093 jcas_Locking alock(env);
2094 {
2095 try {
2096 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2097 the_this->WindowFit((Standard_Integer) Xmin,(Standard_Integer) Ymin,(Standard_Integer) Xmax,(Standard_Integer) Ymax);
2098
2099 }
2100 catch (Standard_Failure) {
2101   Standard_SStream Err;
2102   Err <<   Standard_Failure::Caught(); 
2103   Err << (char) 0;
2104   jcas_ThrowException(env,Err.str().c_str());
2105 }
2106 }
2107 alock.Release();
2108
2109 }
2110
2111
2112
2113 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetViewMappingDefault (JNIEnv *env, jobject theobj)
2114 {
2115
2116 jcas_Locking alock(env);
2117 {
2118 try {
2119 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2120 the_this->SetViewMappingDefault();
2121
2122 }
2123 catch (Standard_Failure) {
2124   Standard_SStream Err;
2125   Err <<   Standard_Failure::Caught(); 
2126   Err << (char) 0;
2127   jcas_ThrowException(env,Err.str().c_str());
2128 }
2129 }
2130 alock.Release();
2131
2132 }
2133
2134
2135
2136 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ResetViewMapping (JNIEnv *env, jobject theobj)
2137 {
2138
2139 jcas_Locking alock(env);
2140 {
2141 try {
2142 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2143 the_this->ResetViewMapping();
2144
2145 }
2146 catch (Standard_Failure) {
2147   Standard_SStream Err;
2148   Err <<   Standard_Failure::Caught(); 
2149   Err << (char) 0;
2150   jcas_ThrowException(env,Err.str().c_str());
2151 }
2152 }
2153 alock.Release();
2154
2155 }
2156
2157
2158
2159 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Reset (JNIEnv *env, jobject theobj, jboolean update)
2160 {
2161
2162 jcas_Locking alock(env);
2163 {
2164 try {
2165 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2166 the_this->Reset((Standard_Boolean) update);
2167
2168 }
2169 catch (Standard_Failure) {
2170   Standard_SStream Err;
2171   Err <<   Standard_Failure::Caught(); 
2172   Err << (char) 0;
2173   jcas_ThrowException(env,Err.str().c_str());
2174 }
2175 }
2176 alock.Release();
2177
2178 }
2179
2180
2181
2182 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_11 (JNIEnv *env, jobject theobj, jint Vp)
2183 {
2184 jdouble thejret;
2185
2186 jcas_Locking alock(env);
2187 {
2188 try {
2189 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2190  thejret = the_this->Convert((Standard_Integer) Vp);
2191
2192 }
2193 catch (Standard_Failure) {
2194   Standard_SStream Err;
2195   Err <<   Standard_Failure::Caught(); 
2196   Err << (char) 0;
2197   jcas_ThrowException(env,Err.str().c_str());
2198 }
2199 }
2200 alock.Release();
2201 return thejret;
2202 }
2203
2204
2205
2206 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_12 (JNIEnv *env, jobject theobj, jint Xp, jint Yp, jobject Xv, jobject Yv)
2207 {
2208
2209 jcas_Locking alock(env);
2210 {
2211 try {
2212 Standard_Real the_Xv = jcas_GetReal(env,Xv);
2213 Standard_Real the_Yv = jcas_GetReal(env,Yv);
2214 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2215 the_this->Convert((Standard_Integer) Xp,(Standard_Integer) Yp,the_Xv,the_Yv);
2216 jcas_SetReal(env,Xv,the_Xv);
2217 jcas_SetReal(env,Yv,the_Yv);
2218
2219 }
2220 catch (Standard_Failure) {
2221   Standard_SStream Err;
2222   Err <<   Standard_Failure::Caught(); 
2223   Err << (char) 0;
2224   jcas_ThrowException(env,Err.str().c_str());
2225 }
2226 }
2227 alock.Release();
2228
2229 }
2230
2231
2232
2233 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_13 (JNIEnv *env, jobject theobj, jdouble Vv)
2234 {
2235 jint thejret;
2236
2237 jcas_Locking alock(env);
2238 {
2239 try {
2240 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2241  thejret = the_this->Convert((Quantity_Length) Vv);
2242
2243 }
2244 catch (Standard_Failure) {
2245   Standard_SStream Err;
2246   Err <<   Standard_Failure::Caught(); 
2247   Err << (char) 0;
2248   jcas_ThrowException(env,Err.str().c_str());
2249 }
2250 }
2251 alock.Release();
2252 return thejret;
2253 }
2254
2255
2256
2257 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_14 (JNIEnv *env, jobject theobj, jdouble Xv, jdouble Yv, jobject Xp, jobject Yp)
2258 {
2259
2260 jcas_Locking alock(env);
2261 {
2262 try {
2263 Standard_Integer the_Xp = jcas_GetInteger(env,Xp);
2264 Standard_Integer the_Yp = jcas_GetInteger(env,Yp);
2265 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2266 the_this->Convert((V3d_Coordinate) Xv,(V3d_Coordinate) Yv,the_Xp,the_Yp);
2267 jcas_SetInteger(env,Xp,the_Xp);
2268 jcas_SetInteger(env,Yp,the_Yp);
2269
2270 }
2271 catch (Standard_Failure) {
2272   Standard_SStream Err;
2273   Err <<   Standard_Failure::Caught(); 
2274   Err << (char) 0;
2275   jcas_ThrowException(env,Err.str().c_str());
2276 }
2277 }
2278 alock.Release();
2279
2280 }
2281
2282
2283
2284 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_15 (JNIEnv *env, jobject theobj, jint Xp, jint Yp, jobject X, jobject Y, jobject Z)
2285 {
2286
2287 jcas_Locking alock(env);
2288 {
2289 try {
2290 Standard_Real the_X = jcas_GetReal(env,X);
2291 Standard_Real the_Y = jcas_GetReal(env,Y);
2292 Standard_Real the_Z = jcas_GetReal(env,Z);
2293 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2294 the_this->Convert((Standard_Integer) Xp,(Standard_Integer) Yp,the_X,the_Y,the_Z);
2295 jcas_SetReal(env,X,the_X);
2296 jcas_SetReal(env,Y,the_Y);
2297 jcas_SetReal(env,Z,the_Z);
2298
2299 }
2300 catch (Standard_Failure) {
2301   Standard_SStream Err;
2302   Err <<   Standard_Failure::Caught(); 
2303   Err << (char) 0;
2304   jcas_ThrowException(env,Err.str().c_str());
2305 }
2306 }
2307 alock.Release();
2308
2309 }
2310
2311
2312
2313 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1ConvertToGrid_11 (JNIEnv *env, jobject theobj, jint Xp, jint Yp, jobject Xg, jobject Yg, jobject Zg)
2314 {
2315
2316 jcas_Locking alock(env);
2317 {
2318 try {
2319 Standard_Real the_Xg = jcas_GetReal(env,Xg);
2320 Standard_Real the_Yg = jcas_GetReal(env,Yg);
2321 Standard_Real the_Zg = jcas_GetReal(env,Zg);
2322 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2323 the_this->ConvertToGrid((Standard_Integer) Xp,(Standard_Integer) Yp,the_Xg,the_Yg,the_Zg);
2324 jcas_SetReal(env,Xg,the_Xg);
2325 jcas_SetReal(env,Yg,the_Yg);
2326 jcas_SetReal(env,Zg,the_Zg);
2327
2328 }
2329 catch (Standard_Failure) {
2330   Standard_SStream Err;
2331   Err <<   Standard_Failure::Caught(); 
2332   Err << (char) 0;
2333   jcas_ThrowException(env,Err.str().c_str());
2334 }
2335 }
2336 alock.Release();
2337
2338 }
2339
2340
2341
2342 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1ConvertToGrid_12 (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z, jobject Xg, jobject Yg, jobject Zg)
2343 {
2344
2345 jcas_Locking alock(env);
2346 {
2347 try {
2348 Standard_Real the_Xg = jcas_GetReal(env,Xg);
2349 Standard_Real the_Yg = jcas_GetReal(env,Yg);
2350 Standard_Real the_Zg = jcas_GetReal(env,Zg);
2351 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2352 the_this->ConvertToGrid((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,the_Xg,the_Yg,the_Zg);
2353 jcas_SetReal(env,Xg,the_Xg);
2354 jcas_SetReal(env,Yg,the_Yg);
2355 jcas_SetReal(env,Zg,the_Zg);
2356
2357 }
2358 catch (Standard_Failure) {
2359   Standard_SStream Err;
2360   Err <<   Standard_Failure::Caught(); 
2361   Err << (char) 0;
2362   jcas_ThrowException(env,Err.str().c_str());
2363 }
2364 }
2365 alock.Release();
2366
2367 }
2368
2369
2370
2371 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Convert_16 (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z, jobject Xp, jobject Yp)
2372 {
2373
2374 jcas_Locking alock(env);
2375 {
2376 try {
2377 Standard_Integer the_Xp = jcas_GetInteger(env,Xp);
2378 Standard_Integer the_Yp = jcas_GetInteger(env,Yp);
2379 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2380 the_this->Convert((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,the_Xp,the_Yp);
2381 jcas_SetInteger(env,Xp,the_Xp);
2382 jcas_SetInteger(env,Yp,the_Yp);
2383
2384 }
2385 catch (Standard_Failure) {
2386   Standard_SStream Err;
2387   Err <<   Standard_Failure::Caught(); 
2388   Err << (char) 0;
2389   jcas_ThrowException(env,Err.str().c_str());
2390 }
2391 }
2392 alock.Release();
2393
2394 }
2395
2396
2397
2398 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Project (JNIEnv *env, jobject theobj, jdouble X, jdouble Y, jdouble Z, jobject Xp, jobject Yp)
2399 {
2400
2401 jcas_Locking alock(env);
2402 {
2403 try {
2404 Standard_Real the_Xp = jcas_GetReal(env,Xp);
2405 Standard_Real the_Yp = jcas_GetReal(env,Yp);
2406 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2407 the_this->Project((V3d_Coordinate) X,(V3d_Coordinate) Y,(V3d_Coordinate) Z,the_Xp,the_Yp);
2408 jcas_SetReal(env,Xp,the_Xp);
2409 jcas_SetReal(env,Yp,the_Yp);
2410
2411 }
2412 catch (Standard_Failure) {
2413   Standard_SStream Err;
2414   Err <<   Standard_Failure::Caught(); 
2415   Err << (char) 0;
2416   jcas_ThrowException(env,Err.str().c_str());
2417 }
2418 }
2419 alock.Release();
2420
2421 }
2422
2423
2424
2425 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1BackgroundColor_11 (JNIEnv *env, jobject theobj, jshort Type, jobject V1, jobject V2, jobject V3)
2426 {
2427
2428 jcas_Locking alock(env);
2429 {
2430 try {
2431 Standard_Real the_V1 = jcas_GetReal(env,V1);
2432 Standard_Real the_V2 = jcas_GetReal(env,V2);
2433 Standard_Real the_V3 = jcas_GetReal(env,V3);
2434 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2435 the_this->BackgroundColor((Quantity_TypeOfColor) Type,the_V1,the_V2,the_V3);
2436 jcas_SetReal(env,V1,the_V1);
2437 jcas_SetReal(env,V2,the_V2);
2438 jcas_SetReal(env,V3,the_V3);
2439
2440 }
2441 catch (Standard_Failure) {
2442   Standard_SStream Err;
2443   Err <<   Standard_Failure::Caught(); 
2444   Err << (char) 0;
2445   jcas_ThrowException(env,Err.str().c_str());
2446 }
2447 }
2448 alock.Release();
2449
2450 }
2451
2452
2453
2454 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1BackgroundColor_12 (JNIEnv *env, jobject theobj)
2455 {
2456 jobject thejret;
2457
2458 jcas_Locking alock(env);
2459 {
2460 try {
2461 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2462 Quantity_Color* theret = new Quantity_Color(the_this->BackgroundColor());
2463 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Quantity_Color",theret);
2464
2465 }
2466 catch (Standard_Failure) {
2467   Standard_SStream Err;
2468   Err <<   Standard_Failure::Caught(); 
2469   Err << (char) 0;
2470   jcas_ThrowException(env,Err.str().c_str());
2471 }
2472 }
2473 alock.Release();
2474 return thejret;
2475 }
2476
2477
2478
2479 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_Scale (JNIEnv *env, jobject theobj)
2480 {
2481 jdouble thejret;
2482
2483 jcas_Locking alock(env);
2484 {
2485 try {
2486 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2487  thejret = the_this->Scale();
2488
2489 }
2490 catch (Standard_Failure) {
2491   Standard_SStream Err;
2492   Err <<   Standard_Failure::Caught(); 
2493   Err << (char) 0;
2494   jcas_ThrowException(env,Err.str().c_str());
2495 }
2496 }
2497 alock.Release();
2498 return thejret;
2499 }
2500
2501
2502
2503 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1AxialScale_11 (JNIEnv *env, jobject theobj, jobject Sx, jobject Sy, jobject Sz)
2504 {
2505
2506 jcas_Locking alock(env);
2507 {
2508 try {
2509 Standard_Real the_Sx = jcas_GetReal(env,Sx);
2510 Standard_Real the_Sy = jcas_GetReal(env,Sy);
2511 Standard_Real the_Sz = jcas_GetReal(env,Sz);
2512 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2513 the_this->AxialScale(the_Sx,the_Sy,the_Sz);
2514 jcas_SetReal(env,Sx,the_Sx);
2515 jcas_SetReal(env,Sy,the_Sy);
2516 jcas_SetReal(env,Sz,the_Sz);
2517
2518 }
2519 catch (Standard_Failure) {
2520   Standard_SStream Err;
2521   Err <<   Standard_Failure::Caught(); 
2522   Err << (char) 0;
2523   jcas_ThrowException(env,Err.str().c_str());
2524 }
2525 }
2526 alock.Release();
2527
2528 }
2529
2530
2531
2532 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Center (JNIEnv *env, jobject theobj, jobject Xc, jobject Yc)
2533 {
2534
2535 jcas_Locking alock(env);
2536 {
2537 try {
2538 Standard_Real the_Xc = jcas_GetReal(env,Xc);
2539 Standard_Real the_Yc = jcas_GetReal(env,Yc);
2540 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2541 the_this->Center(the_Xc,the_Yc);
2542 jcas_SetReal(env,Xc,the_Xc);
2543 jcas_SetReal(env,Yc,the_Yc);
2544
2545 }
2546 catch (Standard_Failure) {
2547   Standard_SStream Err;
2548   Err <<   Standard_Failure::Caught(); 
2549   Err << (char) 0;
2550   jcas_ThrowException(env,Err.str().c_str());
2551 }
2552 }
2553 alock.Release();
2554
2555 }
2556
2557
2558
2559 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Size (JNIEnv *env, jobject theobj, jobject Width, jobject Height)
2560 {
2561
2562 jcas_Locking alock(env);
2563 {
2564 try {
2565 Standard_Real the_Width = jcas_GetReal(env,Width);
2566 Standard_Real the_Height = jcas_GetReal(env,Height);
2567 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2568 the_this->Size(the_Width,the_Height);
2569 jcas_SetReal(env,Width,the_Width);
2570 jcas_SetReal(env,Height,the_Height);
2571
2572 }
2573 catch (Standard_Failure) {
2574   Standard_SStream Err;
2575   Err <<   Standard_Failure::Caught(); 
2576   Err << (char) 0;
2577   jcas_ThrowException(env,Err.str().c_str());
2578 }
2579 }
2580 alock.Release();
2581
2582 }
2583
2584
2585
2586 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_ZSize (JNIEnv *env, jobject theobj)
2587 {
2588 jdouble thejret;
2589
2590 jcas_Locking alock(env);
2591 {
2592 try {
2593 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2594  thejret = the_this->ZSize();
2595
2596 }
2597 catch (Standard_Failure) {
2598   Standard_SStream Err;
2599   Err <<   Standard_Failure::Caught(); 
2600   Err << (char) 0;
2601   jcas_ThrowException(env,Err.str().c_str());
2602 }
2603 }
2604 alock.Release();
2605 return thejret;
2606 }
2607
2608
2609
2610 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Eye (JNIEnv *env, jobject theobj, jobject X, jobject Y, jobject Z)
2611 {
2612
2613 jcas_Locking alock(env);
2614 {
2615 try {
2616 Standard_Real the_X = jcas_GetReal(env,X);
2617 Standard_Real the_Y = jcas_GetReal(env,Y);
2618 Standard_Real the_Z = jcas_GetReal(env,Z);
2619 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2620 the_this->Eye(the_X,the_Y,the_Z);
2621 jcas_SetReal(env,X,the_X);
2622 jcas_SetReal(env,Y,the_Y);
2623 jcas_SetReal(env,Z,the_Z);
2624
2625 }
2626 catch (Standard_Failure) {
2627   Standard_SStream Err;
2628   Err <<   Standard_Failure::Caught(); 
2629   Err << (char) 0;
2630   jcas_ThrowException(env,Err.str().c_str());
2631 }
2632 }
2633 alock.Release();
2634
2635 }
2636
2637
2638
2639 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_FocalReferencePoint (JNIEnv *env, jobject theobj, jobject X, jobject Y, jobject Z)
2640 {
2641
2642 jcas_Locking alock(env);
2643 {
2644 try {
2645 Standard_Real the_X = jcas_GetReal(env,X);
2646 Standard_Real the_Y = jcas_GetReal(env,Y);
2647 Standard_Real the_Z = jcas_GetReal(env,Z);
2648 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2649 the_this->FocalReferencePoint(the_X,the_Y,the_Z);
2650 jcas_SetReal(env,X,the_X);
2651 jcas_SetReal(env,Y,the_Y);
2652 jcas_SetReal(env,Z,the_Z);
2653
2654 }
2655 catch (Standard_Failure) {
2656   Standard_SStream Err;
2657   Err <<   Standard_Failure::Caught(); 
2658   Err << (char) 0;
2659   jcas_ThrowException(env,Err.str().c_str());
2660 }
2661 }
2662 alock.Release();
2663
2664 }
2665
2666
2667
2668 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_ProjReferenceAxe (JNIEnv *env, jobject theobj, jint Xpix, jint Ypix, jobject XP, jobject YP, jobject ZP, jobject VX, jobject VY, jobject VZ)
2669 {
2670
2671 jcas_Locking alock(env);
2672 {
2673 try {
2674 Standard_Real the_XP = jcas_GetReal(env,XP);
2675 Standard_Real the_YP = jcas_GetReal(env,YP);
2676 Standard_Real the_ZP = jcas_GetReal(env,ZP);
2677 Standard_Real the_VX = jcas_GetReal(env,VX);
2678 Standard_Real the_VY = jcas_GetReal(env,VY);
2679 Standard_Real the_VZ = jcas_GetReal(env,VZ);
2680 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2681 the_this->ProjReferenceAxe((Standard_Integer) Xpix,(Standard_Integer) Ypix,the_XP,the_YP,the_ZP,the_VX,the_VY,the_VZ);
2682 jcas_SetReal(env,XP,the_XP);
2683 jcas_SetReal(env,YP,the_YP);
2684 jcas_SetReal(env,ZP,the_ZP);
2685 jcas_SetReal(env,VX,the_VX);
2686 jcas_SetReal(env,VY,the_VY);
2687 jcas_SetReal(env,VZ,the_VZ);
2688
2689 }
2690 catch (Standard_Failure) {
2691   Standard_SStream Err;
2692   Err <<   Standard_Failure::Caught(); 
2693   Err << (char) 0;
2694   jcas_ThrowException(env,Err.str().c_str());
2695 }
2696 }
2697 alock.Release();
2698
2699 }
2700
2701
2702
2703 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_Depth (JNIEnv *env, jobject theobj)
2704 {
2705 jdouble thejret;
2706
2707 jcas_Locking alock(env);
2708 {
2709 try {
2710 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2711  thejret = the_this->Depth();
2712
2713 }
2714 catch (Standard_Failure) {
2715   Standard_SStream Err;
2716   Err <<   Standard_Failure::Caught(); 
2717   Err << (char) 0;
2718   jcas_ThrowException(env,Err.str().c_str());
2719 }
2720 }
2721 alock.Release();
2722 return thejret;
2723 }
2724
2725
2726
2727 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Proj (JNIEnv *env, jobject theobj, jobject Vx, jobject Vy, jobject Vz)
2728 {
2729
2730 jcas_Locking alock(env);
2731 {
2732 try {
2733 Standard_Real the_Vx = jcas_GetReal(env,Vx);
2734 Standard_Real the_Vy = jcas_GetReal(env,Vy);
2735 Standard_Real the_Vz = jcas_GetReal(env,Vz);
2736 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2737 the_this->Proj(the_Vx,the_Vy,the_Vz);
2738 jcas_SetReal(env,Vx,the_Vx);
2739 jcas_SetReal(env,Vy,the_Vy);
2740 jcas_SetReal(env,Vz,the_Vz);
2741
2742 }
2743 catch (Standard_Failure) {
2744   Standard_SStream Err;
2745   Err <<   Standard_Failure::Caught(); 
2746   Err << (char) 0;
2747   jcas_ThrowException(env,Err.str().c_str());
2748 }
2749 }
2750 alock.Release();
2751
2752 }
2753
2754
2755
2756 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_At (JNIEnv *env, jobject theobj, jobject X, jobject Y, jobject Z)
2757 {
2758
2759 jcas_Locking alock(env);
2760 {
2761 try {
2762 Standard_Real the_X = jcas_GetReal(env,X);
2763 Standard_Real the_Y = jcas_GetReal(env,Y);
2764 Standard_Real the_Z = jcas_GetReal(env,Z);
2765 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2766 the_this->At(the_X,the_Y,the_Z);
2767 jcas_SetReal(env,X,the_X);
2768 jcas_SetReal(env,Y,the_Y);
2769 jcas_SetReal(env,Z,the_Z);
2770
2771 }
2772 catch (Standard_Failure) {
2773   Standard_SStream Err;
2774   Err <<   Standard_Failure::Caught(); 
2775   Err << (char) 0;
2776   jcas_ThrowException(env,Err.str().c_str());
2777 }
2778 }
2779 alock.Release();
2780
2781 }
2782
2783
2784
2785 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Up (JNIEnv *env, jobject theobj, jobject Vx, jobject Vy, jobject Vz)
2786 {
2787
2788 jcas_Locking alock(env);
2789 {
2790 try {
2791 Standard_Real the_Vx = jcas_GetReal(env,Vx);
2792 Standard_Real the_Vy = jcas_GetReal(env,Vy);
2793 Standard_Real the_Vz = jcas_GetReal(env,Vz);
2794 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2795 the_this->Up(the_Vx,the_Vy,the_Vz);
2796 jcas_SetReal(env,Vx,the_Vx);
2797 jcas_SetReal(env,Vy,the_Vy);
2798 jcas_SetReal(env,Vz,the_Vz);
2799
2800 }
2801 catch (Standard_Failure) {
2802   Standard_SStream Err;
2803   Err <<   Standard_Failure::Caught(); 
2804   Err << (char) 0;
2805   jcas_ThrowException(env,Err.str().c_str());
2806 }
2807 }
2808 alock.Release();
2809
2810 }
2811
2812
2813
2814 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_Twist (JNIEnv *env, jobject theobj)
2815 {
2816 jdouble thejret;
2817
2818 jcas_Locking alock(env);
2819 {
2820 try {
2821 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2822  thejret = the_this->Twist();
2823
2824 }
2825 catch (Standard_Failure) {
2826   Standard_SStream Err;
2827   Err <<   Standard_Failure::Caught(); 
2828   Err << (char) 0;
2829   jcas_ThrowException(env,Err.str().c_str());
2830 }
2831 }
2832 alock.Release();
2833 return thejret;
2834 }
2835
2836
2837
2838 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1View_ShadingModel (JNIEnv *env, jobject theobj)
2839 {
2840 jshort thejret;
2841
2842 jcas_Locking alock(env);
2843 {
2844 try {
2845 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2846  thejret = the_this->ShadingModel();
2847
2848 }
2849 catch (Standard_Failure) {
2850   Standard_SStream Err;
2851   Err <<   Standard_Failure::Caught(); 
2852   Err << (char) 0;
2853   jcas_ThrowException(env,Err.str().c_str());
2854 }
2855 }
2856 alock.Release();
2857 return thejret;
2858 }
2859
2860
2861
2862 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1View_SurfaceDetail (JNIEnv *env, jobject theobj)
2863 {
2864 jshort thejret;
2865
2866 jcas_Locking alock(env);
2867 {
2868 try {
2869 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2870  thejret = the_this->SurfaceDetail();
2871
2872 }
2873 catch (Standard_Failure) {
2874   Standard_SStream Err;
2875   Err <<   Standard_Failure::Caught(); 
2876   Err << (char) 0;
2877   jcas_ThrowException(env,Err.str().c_str());
2878 }
2879 }
2880 alock.Release();
2881 return thejret;
2882 }
2883
2884
2885
2886 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_TextureEnv (JNIEnv *env, jobject theobj)
2887 {
2888 jobject thejret;
2889
2890 jcas_Locking alock(env);
2891 {
2892 try {
2893 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2894 Handle(Graphic3d_TextureEnv)* theret = new Handle(Graphic3d_TextureEnv);
2895 *theret = the_this->TextureEnv();
2896 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Graphic3d_TextureEnv",theret);
2897
2898 }
2899 catch (Standard_Failure) {
2900   Standard_SStream Err;
2901   Err <<   Standard_Failure::Caught(); 
2902   Err << (char) 0;
2903   jcas_ThrowException(env,Err.str().c_str());
2904 }
2905 }
2906 alock.Release();
2907 return thejret;
2908 }
2909
2910
2911
2912 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_Transparency (JNIEnv *env, jobject theobj)
2913 {
2914 jboolean thejret;
2915
2916 jcas_Locking alock(env);
2917 {
2918 try {
2919 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2920  thejret = the_this->Transparency();
2921
2922 }
2923 catch (Standard_Failure) {
2924   Standard_SStream Err;
2925   Err <<   Standard_Failure::Caught(); 
2926   Err << (char) 0;
2927   jcas_ThrowException(env,Err.str().c_str());
2928 }
2929 }
2930 alock.Release();
2931 return thejret;
2932 }
2933
2934
2935
2936 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1View_Visualization (JNIEnv *env, jobject theobj)
2937 {
2938 jshort thejret;
2939
2940 jcas_Locking alock(env);
2941 {
2942 try {
2943 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2944  thejret = the_this->Visualization();
2945
2946 }
2947 catch (Standard_Failure) {
2948   Standard_SStream Err;
2949   Err <<   Standard_Failure::Caught(); 
2950   Err << (char) 0;
2951   jcas_ThrowException(env,Err.str().c_str());
2952 }
2953 }
2954 alock.Release();
2955 return thejret;
2956 }
2957
2958
2959
2960 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_Antialiasing (JNIEnv *env, jobject theobj)
2961 {
2962 jboolean thejret;
2963
2964 jcas_Locking alock(env);
2965 {
2966 try {
2967 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2968  thejret = the_this->Antialiasing();
2969
2970 }
2971 catch (Standard_Failure) {
2972   Standard_SStream Err;
2973   Err <<   Standard_Failure::Caught(); 
2974   Err << (char) 0;
2975   jcas_ThrowException(env,Err.str().c_str());
2976 }
2977 }
2978 alock.Release();
2979 return thejret;
2980 }
2981
2982
2983
2984 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_ZCueing (JNIEnv *env, jobject theobj, jobject Depth, jobject Width)
2985 {
2986 jboolean thejret;
2987
2988 jcas_Locking alock(env);
2989 {
2990 try {
2991 Standard_Real the_Depth = jcas_GetReal(env,Depth);
2992 Standard_Real the_Width = jcas_GetReal(env,Width);
2993 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
2994  thejret = the_this->ZCueing(the_Depth,the_Width);
2995 jcas_SetReal(env,Depth,the_Depth);
2996 jcas_SetReal(env,Width,the_Width);
2997
2998 }
2999 catch (Standard_Failure) {
3000   Standard_SStream Err;
3001   Err <<   Standard_Failure::Caught(); 
3002   Err << (char) 0;
3003   jcas_ThrowException(env,Err.str().c_str());
3004 }
3005 }
3006 alock.Release();
3007 return thejret;
3008 }
3009
3010
3011
3012 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1View_ZClipping (JNIEnv *env, jobject theobj, jobject Depth, jobject Width)
3013 {
3014 jshort thejret;
3015
3016 jcas_Locking alock(env);
3017 {
3018 try {
3019 Standard_Real the_Depth = jcas_GetReal(env,Depth);
3020 Standard_Real the_Width = jcas_GetReal(env,Width);
3021 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3022  thejret = the_this->ZClipping(the_Depth,the_Width);
3023 jcas_SetReal(env,Depth,the_Depth);
3024 jcas_SetReal(env,Width,the_Width);
3025
3026 }
3027 catch (Standard_Failure) {
3028   Standard_SStream Err;
3029   Err <<   Standard_Failure::Caught(); 
3030   Err << (char) 0;
3031   jcas_ThrowException(env,Err.str().c_str());
3032 }
3033 }
3034 alock.Release();
3035 return thejret;
3036 }
3037
3038
3039
3040 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IfMoreLights (JNIEnv *env, jobject theobj)
3041 {
3042 jboolean thejret;
3043
3044 jcas_Locking alock(env);
3045 {
3046 try {
3047 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3048  thejret = the_this->IfMoreLights();
3049
3050 }
3051 catch (Standard_Failure) {
3052   Standard_SStream Err;
3053   Err <<   Standard_Failure::Caught(); 
3054   Err << (char) 0;
3055   jcas_ThrowException(env,Err.str().c_str());
3056 }
3057 }
3058 alock.Release();
3059 return thejret;
3060 }
3061
3062
3063
3064 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_InitActiveLights (JNIEnv *env, jobject theobj)
3065 {
3066
3067 jcas_Locking alock(env);
3068 {
3069 try {
3070 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3071 the_this->InitActiveLights();
3072
3073 }
3074 catch (Standard_Failure) {
3075   Standard_SStream Err;
3076   Err <<   Standard_Failure::Caught(); 
3077   Err << (char) 0;
3078   jcas_ThrowException(env,Err.str().c_str());
3079 }
3080 }
3081 alock.Release();
3082
3083 }
3084
3085
3086
3087 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_MoreActiveLights (JNIEnv *env, jobject theobj)
3088 {
3089 jboolean thejret;
3090
3091 jcas_Locking alock(env);
3092 {
3093 try {
3094 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3095  thejret = the_this->MoreActiveLights();
3096
3097 }
3098 catch (Standard_Failure) {
3099   Standard_SStream Err;
3100   Err <<   Standard_Failure::Caught(); 
3101   Err << (char) 0;
3102   jcas_ThrowException(env,Err.str().c_str());
3103 }
3104 }
3105 alock.Release();
3106 return thejret;
3107 }
3108
3109
3110
3111 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_NextActiveLights (JNIEnv *env, jobject theobj)
3112 {
3113
3114 jcas_Locking alock(env);
3115 {
3116 try {
3117 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3118 the_this->NextActiveLights();
3119
3120 }
3121 catch (Standard_Failure) {
3122   Standard_SStream Err;
3123   Err <<   Standard_Failure::Caught(); 
3124   Err << (char) 0;
3125   jcas_ThrowException(env,Err.str().c_str());
3126 }
3127 }
3128 alock.Release();
3129
3130 }
3131
3132
3133
3134 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_ActiveLight (JNIEnv *env, jobject theobj)
3135 {
3136 jobject thejret;
3137
3138 jcas_Locking alock(env);
3139 {
3140 try {
3141 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3142 Handle(V3d_Light)* theret = new Handle(V3d_Light);
3143 *theret = the_this->ActiveLight();
3144 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Light",theret);
3145
3146 }
3147 catch (Standard_Failure) {
3148   Standard_SStream Err;
3149   Err <<   Standard_Failure::Caught(); 
3150   Err << (char) 0;
3151   jcas_ThrowException(env,Err.str().c_str());
3152 }
3153 }
3154 alock.Release();
3155 return thejret;
3156 }
3157
3158
3159
3160 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IfMorePlanes (JNIEnv *env, jobject theobj)
3161 {
3162 jboolean thejret;
3163
3164 jcas_Locking alock(env);
3165 {
3166 try {
3167 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3168  thejret = the_this->IfMorePlanes();
3169
3170 }
3171 catch (Standard_Failure) {
3172   Standard_SStream Err;
3173   Err <<   Standard_Failure::Caught(); 
3174   Err << (char) 0;
3175   jcas_ThrowException(env,Err.str().c_str());
3176 }
3177 }
3178 alock.Release();
3179 return thejret;
3180 }
3181
3182
3183
3184 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_InitActivePlanes (JNIEnv *env, jobject theobj)
3185 {
3186
3187 jcas_Locking alock(env);
3188 {
3189 try {
3190 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3191 the_this->InitActivePlanes();
3192
3193 }
3194 catch (Standard_Failure) {
3195   Standard_SStream Err;
3196   Err <<   Standard_Failure::Caught(); 
3197   Err << (char) 0;
3198   jcas_ThrowException(env,Err.str().c_str());
3199 }
3200 }
3201 alock.Release();
3202
3203 }
3204
3205
3206
3207 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_MoreActivePlanes (JNIEnv *env, jobject theobj)
3208 {
3209 jboolean thejret;
3210
3211 jcas_Locking alock(env);
3212 {
3213 try {
3214 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3215  thejret = the_this->MoreActivePlanes();
3216
3217 }
3218 catch (Standard_Failure) {
3219   Standard_SStream Err;
3220   Err <<   Standard_Failure::Caught(); 
3221   Err << (char) 0;
3222   jcas_ThrowException(env,Err.str().c_str());
3223 }
3224 }
3225 alock.Release();
3226 return thejret;
3227 }
3228
3229
3230
3231 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_NextActivePlanes (JNIEnv *env, jobject theobj)
3232 {
3233
3234 jcas_Locking alock(env);
3235 {
3236 try {
3237 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3238 the_this->NextActivePlanes();
3239
3240 }
3241 catch (Standard_Failure) {
3242   Standard_SStream Err;
3243   Err <<   Standard_Failure::Caught(); 
3244   Err << (char) 0;
3245   jcas_ThrowException(env,Err.str().c_str());
3246 }
3247 }
3248 alock.Release();
3249
3250 }
3251
3252
3253
3254 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_ActivePlane (JNIEnv *env, jobject theobj)
3255 {
3256 jobject thejret;
3257
3258 jcas_Locking alock(env);
3259 {
3260 try {
3261 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3262 Handle(V3d_Plane)* theret = new Handle(V3d_Plane);
3263 *theret = the_this->ActivePlane();
3264 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Plane",theret);
3265
3266 }
3267 catch (Standard_Failure) {
3268   Standard_SStream Err;
3269   Err <<   Standard_Failure::Caught(); 
3270   Err << (char) 0;
3271   jcas_ThrowException(env,Err.str().c_str());
3272 }
3273 }
3274 alock.Release();
3275 return thejret;
3276 }
3277
3278
3279
3280 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_Viewer (JNIEnv *env, jobject theobj)
3281 {
3282 jobject thejret;
3283
3284 jcas_Locking alock(env);
3285 {
3286 try {
3287 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3288 Handle(V3d_Viewer)* theret = new Handle(V3d_Viewer);
3289 *theret = the_this->Viewer();
3290 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V3d_Viewer",theret);
3291
3292 }
3293 catch (Standard_Failure) {
3294   Standard_SStream Err;
3295   Err <<   Standard_Failure::Caught(); 
3296   Err << (char) 0;
3297   jcas_ThrowException(env,Err.str().c_str());
3298 }
3299 }
3300 alock.Release();
3301 return thejret;
3302 }
3303
3304
3305
3306 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V3d_1View_IfWindow (JNIEnv *env, jobject theobj)
3307 {
3308 jboolean thejret;
3309
3310 jcas_Locking alock(env);
3311 {
3312 try {
3313 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3314  thejret = the_this->IfWindow();
3315
3316 }
3317 catch (Standard_Failure) {
3318   Standard_SStream Err;
3319   Err <<   Standard_Failure::Caught(); 
3320   Err << (char) 0;
3321   jcas_ThrowException(env,Err.str().c_str());
3322 }
3323 }
3324 alock.Release();
3325 return thejret;
3326 }
3327
3328
3329
3330 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V3d_1View_Window (JNIEnv *env, jobject theobj)
3331 {
3332 jobject thejret;
3333
3334 jcas_Locking alock(env);
3335 {
3336 try {
3337 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3338 Handle(Aspect_Window)* theret = new Handle(Aspect_Window);
3339 *theret = the_this->Window();
3340 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_Window",theret);
3341
3342 }
3343 catch (Standard_Failure) {
3344   Standard_SStream Err;
3345   Err <<   Standard_Failure::Caught(); 
3346   Err << (char) 0;
3347   jcas_ThrowException(env,Err.str().c_str());
3348 }
3349 }
3350 alock.Release();
3351 return thejret;
3352 }
3353
3354
3355
3356 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V3d_1View_Type (JNIEnv *env, jobject theobj)
3357 {
3358 jshort thejret;
3359
3360 jcas_Locking alock(env);
3361 {
3362 try {
3363 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3364  thejret = the_this->Type();
3365
3366 }
3367 catch (Standard_Failure) {
3368   Standard_SStream Err;
3369   Err <<   Standard_Failure::Caught(); 
3370   Err << (char) 0;
3371   jcas_ThrowException(env,Err.str().c_str());
3372 }
3373 }
3374 alock.Release();
3375 return thejret;
3376 }
3377
3378
3379
3380 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Pan (JNIEnv *env, jobject theobj, jint Dx, jint Dy, jdouble aZoomFactor)
3381 {
3382
3383 jcas_Locking alock(env);
3384 {
3385 try {
3386 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3387 the_this->Pan((Standard_Integer) Dx,(Standard_Integer) Dy,(Quantity_Factor) aZoomFactor);
3388
3389 }
3390 catch (Standard_Failure) {
3391   Standard_SStream Err;
3392   Err <<   Standard_Failure::Caught(); 
3393   Err << (char) 0;
3394   jcas_ThrowException(env,Err.str().c_str());
3395 }
3396 }
3397 alock.Release();
3398
3399 }
3400
3401
3402
3403 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Zoom_11 (JNIEnv *env, jobject theobj, jint X1, jint Y1, jint X2, jint Y2)
3404 {
3405
3406 jcas_Locking alock(env);
3407 {
3408 try {
3409 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3410 the_this->Zoom((Standard_Integer) X1,(Standard_Integer) Y1,(Standard_Integer) X2,(Standard_Integer) Y2);
3411
3412 }
3413 catch (Standard_Failure) {
3414   Standard_SStream Err;
3415   Err <<   Standard_Failure::Caught(); 
3416   Err << (char) 0;
3417   jcas_ThrowException(env,Err.str().c_str());
3418 }
3419 }
3420 alock.Release();
3421
3422 }
3423
3424
3425
3426 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1Zoom_12 (JNIEnv *env, jobject theobj, jint X, jint Y)
3427 {
3428
3429 jcas_Locking alock(env);
3430 {
3431 try {
3432 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3433 the_this->Zoom((Standard_Integer) X,(Standard_Integer) Y);
3434
3435 }
3436 catch (Standard_Failure) {
3437   Standard_SStream Err;
3438   Err <<   Standard_Failure::Caught(); 
3439   Err << (char) 0;
3440   jcas_ThrowException(env,Err.str().c_str());
3441 }
3442 }
3443 alock.Release();
3444
3445 }
3446
3447
3448
3449 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_V3d_1View_1AxialScale_12 (JNIEnv *env, jobject theobj, jint Dx, jint Dy, jshort Axis)
3450 {
3451
3452 jcas_Locking alock(env);
3453 {
3454 try {
3455 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3456 the_this->AxialScale((Standard_Integer) Dx,(Standard_Integer) Dy,(V3d_TypeOfAxe) Axis);
3457
3458 }
3459 catch (Standard_Failure) {
3460   Standard_SStream Err;
3461   Err <<   Standard_Failure::Caught(); 
3462   Err << (char) 0;
3463   jcas_ThrowException(env,Err.str().c_str());
3464 }
3465 }
3466 alock.Release();
3467
3468 }
3469
3470
3471
3472 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_StartRotation (JNIEnv *env, jobject theobj, jint X, jint Y, jdouble zRotationThreshold)
3473 {
3474
3475 jcas_Locking alock(env);
3476 {
3477 try {
3478 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3479 the_this->StartRotation((Standard_Integer) X,(Standard_Integer) Y,(Quantity_Ratio) zRotationThreshold);
3480
3481 }
3482 catch (Standard_Failure) {
3483   Standard_SStream Err;
3484   Err <<   Standard_Failure::Caught(); 
3485   Err << (char) 0;
3486   jcas_ThrowException(env,Err.str().c_str());
3487 }
3488 }
3489 alock.Release();
3490
3491 }
3492
3493
3494
3495 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_Rotation (JNIEnv *env, jobject theobj, jint X, jint Y)
3496 {
3497
3498 jcas_Locking alock(env);
3499 {
3500 try {
3501 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3502 the_this->Rotation((Standard_Integer) X,(Standard_Integer) Y);
3503
3504 }
3505 catch (Standard_Failure) {
3506   Standard_SStream Err;
3507   Err <<   Standard_Failure::Caught(); 
3508   Err << (char) 0;
3509   jcas_ThrowException(env,Err.str().c_str());
3510 }
3511 }
3512 alock.Release();
3513
3514 }
3515
3516
3517
3518 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V3d_1View_SetFocale (JNIEnv *env, jobject theobj, jdouble Focale)
3519 {
3520
3521 jcas_Locking alock(env);
3522 {
3523 try {
3524 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3525 the_this->SetFocale((Quantity_Length) Focale);
3526
3527 }
3528 catch (Standard_Failure) {
3529   Standard_SStream Err;
3530   Err <<   Standard_Failure::Caught(); 
3531   Err << (char) 0;
3532   jcas_ThrowException(env,Err.str().c_str());
3533 }
3534 }
3535 alock.Release();
3536
3537 }
3538
3539
3540
3541 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V3d_1View_Focale (JNIEnv *env, jobject theobj)
3542 {
3543 jdouble thejret;
3544
3545 jcas_Locking alock(env);
3546 {
3547 try {
3548 Handle(V3d_View) the_this = *((Handle(V3d_View)*) jcas_GetHandle(env,theobj));
3549  thejret = the_this->Focale();
3550
3551 }
3552 catch (Standard_Failure) {
3553   Standard_SStream Err;
3554   Err <<   Standard_Failure::Caught(); 
3555   Err << (char) 0;
3556   jcas_ThrowException(env,Err.str().c_str());
3557 }
3558 }
3559 alock.Release();
3560 return thejret;
3561 }
3562
3563
3564