Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_V2d_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_V2d_View.h>
22 #include <V2d_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_WindowDriver.hxx>
30 #include <V2d_Viewer.hxx>
31 #include <Standard_Real.hxx>
32 #include <Standard_Integer.hxx>
33 #include <Standard_Boolean.hxx>
34 #include <Standard_CString.hxx>
35 #include <Graphic2d_DisplayList.hxx>
36 #include <Graphic2d_PickMode.hxx>
37 #include <V2d_TypeOfWindowResizingEffect.hxx>
38 #include <PlotMgt_PlotterDriver.hxx>
39 #include <Aspect_TypeOfColorSpace.hxx>
40 #include <Graphic2d_View.hxx>
41 #include <Quantity_NameOfColor.hxx>
42 #include <Quantity_Color.hxx>
43 #include <Aspect_FillMethod.hxx>
44
45
46 extern "C" {
47
48
49 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Create_10 (JNIEnv *env, jobject theobj, jobject aWindowDriver, jobject aViewer, jdouble aXCenter, jdouble aYCenter, jdouble aSize)
50 {
51
52 jcas_Locking alock(env);
53 {
54 try {
55  Handle( Aspect_WindowDriver ) the_aWindowDriver;
56  void*                ptr_aWindowDriver = jcas_GetHandle(env,aWindowDriver);
57  
58  if ( ptr_aWindowDriver != NULL ) the_aWindowDriver = *(   (  Handle( Aspect_WindowDriver )*  )ptr_aWindowDriver   );
59
60  Handle( V2d_Viewer ) the_aViewer;
61  void*                ptr_aViewer = jcas_GetHandle(env,aViewer);
62  
63  if ( ptr_aViewer != NULL ) the_aViewer = *(   (  Handle( V2d_Viewer )*  )ptr_aViewer   );
64
65 Handle(V2d_View)* theret = new Handle(V2d_View);
66 *theret = new V2d_View(the_aWindowDriver,the_aViewer,(Quantity_Length) aXCenter,(Quantity_Length) aYCenter,(Quantity_Length) aSize);
67 jcas_SetHandle(env,theobj,theret);
68
69 }
70 catch (Standard_Failure) {
71   Standard_SStream Err;
72   Err <<   Standard_Failure::Caught(); 
73   Err << (char) 0;
74   jcas_ThrowException(env,Err.str().c_str());
75 }
76 }
77 alock.Release();
78
79 }
80
81
82
83 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_SetDefaultPosition (JNIEnv *env, jobject theobj, jdouble aXCenter, jdouble aYCenter, jdouble aSize)
84 {
85
86 jcas_Locking alock(env);
87 {
88 try {
89 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
90 the_this->SetDefaultPosition((Quantity_Length) aXCenter,(Quantity_Length) aYCenter,(Quantity_Length) aSize);
91
92 }
93 catch (Standard_Failure) {
94   Standard_SStream Err;
95   Err <<   Standard_Failure::Caught(); 
96   Err << (char) 0;
97   jcas_ThrowException(env,Err.str().c_str());
98 }
99 }
100 alock.Release();
101
102 }
103
104
105
106 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Fitall (JNIEnv *env, jobject theobj)
107 {
108
109 jcas_Locking alock(env);
110 {
111 try {
112 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
113 the_this->Fitall();
114
115 }
116 catch (Standard_Failure) {
117   Standard_SStream Err;
118   Err <<   Standard_Failure::Caught(); 
119   Err << (char) 0;
120   jcas_ThrowException(env,Err.str().c_str());
121 }
122 }
123 alock.Release();
124
125 }
126
127
128
129 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_WindowFit (JNIEnv *env, jobject theobj, jint aX1, jint aY1, jint aX2, jint aY2)
130 {
131
132 jcas_Locking alock(env);
133 {
134 try {
135 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
136 the_this->WindowFit((Standard_Integer) aX1,(Standard_Integer) aY1,(Standard_Integer) aX2,(Standard_Integer) aY2);
137
138 }
139 catch (Standard_Failure) {
140   Standard_SStream Err;
141   Err <<   Standard_Failure::Caught(); 
142   Err << (char) 0;
143   jcas_ThrowException(env,Err.str().c_str());
144 }
145 }
146 alock.Release();
147
148 }
149
150
151
152 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Fit_11 (JNIEnv *env, jobject theobj, jdouble aX1, jdouble aY1, jdouble aX2, jdouble aY2, jboolean UseMinimum)
153 {
154
155 jcas_Locking alock(env);
156 {
157 try {
158 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
159 the_this->Fit((Quantity_Length) aX1,(Quantity_Length) aY1,(Quantity_Length) aX2,(Quantity_Length) aY2,(Standard_Boolean) UseMinimum);
160
161 }
162 catch (Standard_Failure) {
163   Standard_SStream Err;
164   Err <<   Standard_Failure::Caught(); 
165   Err << (char) 0;
166   jcas_ThrowException(env,Err.str().c_str());
167 }
168 }
169 alock.Release();
170
171 }
172
173
174
175 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_SetFitallRatio (JNIEnv *env, jobject theobj, jdouble aRatio)
176 {
177
178 jcas_Locking alock(env);
179 {
180 try {
181 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
182 the_this->SetFitallRatio((Quantity_Ratio) aRatio);
183
184 }
185 catch (Standard_Failure) {
186   Standard_SStream Err;
187   Err <<   Standard_Failure::Caught(); 
188   Err << (char) 0;
189   jcas_ThrowException(env,Err.str().c_str());
190 }
191 }
192 alock.Release();
193
194 }
195
196
197
198 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Zoom_11 (JNIEnv *env, jobject theobj, jdouble Zoom)
199 {
200
201 jcas_Locking alock(env);
202 {
203 try {
204 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
205 the_this->Zoom((Quantity_Factor) Zoom);
206
207 }
208 catch (Standard_Failure) {
209   Standard_SStream Err;
210   Err <<   Standard_Failure::Caught(); 
211   Err << (char) 0;
212   jcas_ThrowException(env,Err.str().c_str());
213 }
214 }
215 alock.Release();
216
217 }
218
219
220
221 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Zoom_12 (JNIEnv *env, jobject theobj, jint aX1, jint aY1, jint aX2, jint aY2, jdouble aCoefficient)
222 {
223
224 jcas_Locking alock(env);
225 {
226 try {
227 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
228 the_this->Zoom((Standard_Integer) aX1,(Standard_Integer) aY1,(Standard_Integer) aX2,(Standard_Integer) aY2,(Quantity_Ratio) aCoefficient);
229
230 }
231 catch (Standard_Failure) {
232   Standard_SStream Err;
233   Err <<   Standard_Failure::Caught(); 
234   Err << (char) 0;
235   jcas_ThrowException(env,Err.str().c_str());
236 }
237 }
238 alock.Release();
239
240 }
241
242
243
244 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Zoom_13 (JNIEnv *env, jobject theobj, jint aX, jint aY, jdouble aCoefficient)
245 {
246
247 jcas_Locking alock(env);
248 {
249 try {
250 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
251 the_this->Zoom((Standard_Integer) aX,(Standard_Integer) aY,(Quantity_Ratio) aCoefficient);
252
253 }
254 catch (Standard_Failure) {
255   Standard_SStream Err;
256   Err <<   Standard_Failure::Caught(); 
257   Err << (char) 0;
258   jcas_ThrowException(env,Err.str().c_str());
259 }
260 }
261 alock.Release();
262
263 }
264
265
266
267 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Magnify (JNIEnv *env, jobject theobj, jobject anOriginView, jint X1, jint Y1, jint X2, jint Y2)
268 {
269
270 jcas_Locking alock(env);
271 {
272 try {
273  Handle( V2d_View ) the_anOriginView;
274  void*                ptr_anOriginView = jcas_GetHandle(env,anOriginView);
275  
276  if ( ptr_anOriginView != NULL ) the_anOriginView = *(   (  Handle( V2d_View )*  )ptr_anOriginView   );
277
278 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
279 the_this->Magnify(the_anOriginView,(Standard_Integer) X1,(Standard_Integer) Y1,(Standard_Integer) X2,(Standard_Integer) Y2);
280
281 }
282 catch (Standard_Failure) {
283   Standard_SStream Err;
284   Err <<   Standard_Failure::Caught(); 
285   Err << (char) 0;
286   jcas_ThrowException(env,Err.str().c_str());
287 }
288 }
289 alock.Release();
290
291 }
292
293
294
295 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Translate (JNIEnv *env, jobject theobj, jdouble dx, jdouble dy)
296 {
297
298 jcas_Locking alock(env);
299 {
300 try {
301 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
302 the_this->Translate((Quantity_Length) dx,(Quantity_Length) dy);
303
304 }
305 catch (Standard_Failure) {
306   Standard_SStream Err;
307   Err <<   Standard_Failure::Caught(); 
308   Err << (char) 0;
309   jcas_ThrowException(env,Err.str().c_str());
310 }
311 }
312 alock.Release();
313
314 }
315
316
317
318 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Place (JNIEnv *env, jobject theobj, jint x, jint y, jdouble aZoomFactor)
319 {
320
321 jcas_Locking alock(env);
322 {
323 try {
324 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
325 the_this->Place((Standard_Integer) x,(Standard_Integer) y,(Quantity_Factor) aZoomFactor);
326
327 }
328 catch (Standard_Failure) {
329   Standard_SStream Err;
330   Err <<   Standard_Failure::Caught(); 
331   Err << (char) 0;
332   jcas_ThrowException(env,Err.str().c_str());
333 }
334 }
335 alock.Release();
336
337 }
338
339
340
341 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_ScreenPlace (JNIEnv *env, jobject theobj, jdouble x, jdouble y, jdouble aZoomFactor)
342 {
343
344 jcas_Locking alock(env);
345 {
346 try {
347 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
348 the_this->ScreenPlace((Quantity_Length) x,(Quantity_Length) y,(Quantity_Factor) aZoomFactor);
349
350 }
351 catch (Standard_Failure) {
352   Standard_SStream Err;
353   Err <<   Standard_Failure::Caught(); 
354   Err << (char) 0;
355   jcas_ThrowException(env,Err.str().c_str());
356 }
357 }
358 alock.Release();
359
360 }
361
362
363
364 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Pan (JNIEnv *env, jobject theobj, jint dx, jint dy)
365 {
366
367 jcas_Locking alock(env);
368 {
369 try {
370 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
371 the_this->Pan((Standard_Integer) dx,(Standard_Integer) dy);
372
373 }
374 catch (Standard_Failure) {
375   Standard_SStream Err;
376   Err <<   Standard_Failure::Caught(); 
377   Err << (char) 0;
378   jcas_ThrowException(env,Err.str().c_str());
379 }
380 }
381 alock.Release();
382
383 }
384
385
386
387 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Convert_11 (JNIEnv *env, jobject theobj, jint V)
388 {
389 jdouble thejret;
390
391 jcas_Locking alock(env);
392 {
393 try {
394 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
395  thejret = the_this->Convert((Standard_Integer) V);
396
397 }
398 catch (Standard_Failure) {
399   Standard_SStream Err;
400   Err <<   Standard_Failure::Caught(); 
401   Err << (char) 0;
402   jcas_ThrowException(env,Err.str().c_str());
403 }
404 }
405 alock.Release();
406 return thejret;
407 }
408
409
410
411 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Convert_12 (JNIEnv *env, jobject theobj, jint X, jint Y, jobject ViewX, jobject ViewY)
412 {
413
414 jcas_Locking alock(env);
415 {
416 try {
417 Standard_Real the_ViewX = jcas_GetReal(env,ViewX);
418 Standard_Real the_ViewY = jcas_GetReal(env,ViewY);
419 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
420 the_this->Convert((Standard_Integer) X,(Standard_Integer) Y,the_ViewX,the_ViewY);
421 jcas_SetReal(env,ViewX,the_ViewX);
422 jcas_SetReal(env,ViewY,the_ViewY);
423
424 }
425 catch (Standard_Failure) {
426   Standard_SStream Err;
427   Err <<   Standard_Failure::Caught(); 
428   Err << (char) 0;
429   jcas_ThrowException(env,Err.str().c_str());
430 }
431 }
432 alock.Release();
433
434 }
435
436
437
438 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Convert_13 (JNIEnv *env, jobject theobj, jdouble ViewX, jdouble ViewY, jobject X, jobject Y)
439 {
440
441 jcas_Locking alock(env);
442 {
443 try {
444 Standard_Integer the_X = jcas_GetInteger(env,X);
445 Standard_Integer the_Y = jcas_GetInteger(env,Y);
446 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
447 the_this->Convert((Quantity_Length) ViewX,(Quantity_Length) ViewY,the_X,the_Y);
448 jcas_SetInteger(env,X,the_X);
449 jcas_SetInteger(env,Y,the_Y);
450
451 }
452 catch (Standard_Failure) {
453   Standard_SStream Err;
454   Err <<   Standard_Failure::Caught(); 
455   Err << (char) 0;
456   jcas_ThrowException(env,Err.str().c_str());
457 }
458 }
459 alock.Release();
460
461 }
462
463
464
465 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Convert_14 (JNIEnv *env, jobject theobj, jdouble aDriverSize)
466 {
467 jdouble thejret;
468
469 jcas_Locking alock(env);
470 {
471 try {
472 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
473  thejret = the_this->Convert((Quantity_Length) aDriverSize);
474
475 }
476 catch (Standard_Failure) {
477   Standard_SStream Err;
478   Err <<   Standard_Failure::Caught(); 
479   Err << (char) 0;
480   jcas_ThrowException(env,Err.str().c_str());
481 }
482 }
483 alock.Release();
484 return thejret;
485 }
486
487
488
489 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Reset (JNIEnv *env, jobject theobj)
490 {
491
492 jcas_Locking alock(env);
493 {
494 try {
495 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
496 the_this->Reset();
497
498 }
499 catch (Standard_Failure) {
500   Standard_SStream Err;
501   Err <<   Standard_Failure::Caught(); 
502   Err << (char) 0;
503   jcas_ThrowException(env,Err.str().c_str());
504 }
505 }
506 alock.Release();
507
508 }
509
510
511
512 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Previous (JNIEnv *env, jobject theobj)
513 {
514
515 jcas_Locking alock(env);
516 {
517 try {
518 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
519 the_this->Previous();
520
521 }
522 catch (Standard_Failure) {
523   Standard_SStream Err;
524   Err <<   Standard_Failure::Caught(); 
525   Err << (char) 0;
526   jcas_ThrowException(env,Err.str().c_str());
527 }
528 }
529 alock.Release();
530
531 }
532
533
534
535 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_DisableStorePrevious (JNIEnv *env, jobject theobj)
536 {
537
538 jcas_Locking alock(env);
539 {
540 try {
541 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
542 the_this->DisableStorePrevious();
543
544 }
545 catch (Standard_Failure) {
546   Standard_SStream Err;
547   Err <<   Standard_Failure::Caught(); 
548   Err << (char) 0;
549   jcas_ThrowException(env,Err.str().c_str());
550 }
551 }
552 alock.Release();
553
554 }
555
556
557
558 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_EnableStorePrevious (JNIEnv *env, jobject theobj)
559 {
560
561 jcas_Locking alock(env);
562 {
563 try {
564 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
565 the_this->EnableStorePrevious();
566
567 }
568 catch (Standard_Failure) {
569   Standard_SStream Err;
570   Err <<   Standard_Failure::Caught(); 
571   Err << (char) 0;
572   jcas_ThrowException(env,Err.str().c_str());
573 }
574 }
575 alock.Release();
576
577 }
578
579
580
581 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Update (JNIEnv *env, jobject theobj)
582 {
583
584 jcas_Locking alock(env);
585 {
586 try {
587 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
588 the_this->Update();
589
590 }
591 catch (Standard_Failure) {
592   Standard_SStream Err;
593   Err <<   Standard_Failure::Caught(); 
594   Err << (char) 0;
595   jcas_ThrowException(env,Err.str().c_str());
596 }
597 }
598 alock.Release();
599
600 }
601
602
603
604 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_UpdateNew (JNIEnv *env, jobject theobj)
605 {
606
607 jcas_Locking alock(env);
608 {
609 try {
610 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
611 the_this->UpdateNew();
612
613 }
614 catch (Standard_Failure) {
615   Standard_SStream Err;
616   Err <<   Standard_Failure::Caught(); 
617   Err << (char) 0;
618   jcas_ThrowException(env,Err.str().c_str());
619 }
620 }
621 alock.Release();
622
623 }
624
625
626
627 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_RestoreArea (JNIEnv *env, jobject theobj, jint Xc, jint Yc, jint Width, jint Height)
628 {
629
630 jcas_Locking alock(env);
631 {
632 try {
633 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
634 the_this->RestoreArea((Standard_Integer) Xc,(Standard_Integer) Yc,(Standard_Integer) Width,(Standard_Integer) Height);
635
636 }
637 catch (Standard_Failure) {
638   Standard_SStream Err;
639   Err <<   Standard_Failure::Caught(); 
640   Err << (char) 0;
641   jcas_ThrowException(env,Err.str().c_str());
642 }
643 }
644 alock.Release();
645
646 }
647
648
649
650 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Restore (JNIEnv *env, jobject theobj)
651 {
652
653 jcas_Locking alock(env);
654 {
655 try {
656 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
657 the_this->Restore();
658
659 }
660 catch (Standard_Failure) {
661   Standard_SStream Err;
662   Err <<   Standard_Failure::Caught(); 
663   Err << (char) 0;
664   jcas_ThrowException(env,Err.str().c_str());
665 }
666 }
667 alock.Release();
668
669 }
670
671
672
673 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Dump_11 (JNIEnv *env, jobject theobj)
674 {
675
676 jcas_Locking alock(env);
677 {
678 try {
679 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
680 the_this->Dump();
681
682 }
683 catch (Standard_Failure) {
684   Standard_SStream Err;
685   Err <<   Standard_Failure::Caught(); 
686   Err << (char) 0;
687   jcas_ThrowException(env,Err.str().c_str());
688 }
689 }
690 alock.Release();
691
692 }
693
694
695
696 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Dump_12 (JNIEnv *env, jobject theobj, jobject aFileName)
697 {
698
699 jcas_Locking alock(env);
700 {
701 try {
702 Standard_CString the_aFileName = jcas_ConvertToCString(env,aFileName);
703 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
704 the_this->Dump(the_aFileName);
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 jobject JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Pick_11 (JNIEnv *env, jobject theobj, jint X, jint Y, jint aPrecision)
721 {
722 jobject thejret;
723
724 jcas_Locking alock(env);
725 {
726 try {
727 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
728 Handle(Graphic2d_DisplayList)* theret = new Handle(Graphic2d_DisplayList);
729 *theret = the_this->Pick((Standard_Integer) X,(Standard_Integer) Y,(Standard_Integer) aPrecision);
730 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Graphic2d_DisplayList",theret);
731
732 }
733 catch (Standard_Failure) {
734   Standard_SStream Err;
735   Err <<   Standard_Failure::Caught(); 
736   Err << (char) 0;
737   jcas_ThrowException(env,Err.str().c_str());
738 }
739 }
740 alock.Release();
741 return thejret;
742 }
743
744
745
746 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V2d_1View_PickByCircle (JNIEnv *env, jobject theobj, jint X, jint Y, jint Radius)
747 {
748 jobject thejret;
749
750 jcas_Locking alock(env);
751 {
752 try {
753 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
754 Handle(Graphic2d_DisplayList)* theret = new Handle(Graphic2d_DisplayList);
755 *theret = the_this->PickByCircle((Standard_Integer) X,(Standard_Integer) Y,(Standard_Integer) Radius);
756 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Graphic2d_DisplayList",theret);
757
758 }
759 catch (Standard_Failure) {
760   Standard_SStream Err;
761   Err <<   Standard_Failure::Caught(); 
762   Err << (char) 0;
763   jcas_ThrowException(env,Err.str().c_str());
764 }
765 }
766 alock.Release();
767 return thejret;
768 }
769
770
771
772 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Pick_12 (JNIEnv *env, jobject theobj, jint Xmin, jint Ymin, jint Xmax, jint Ymax, jshort aPickMode)
773 {
774 jobject thejret;
775
776 jcas_Locking alock(env);
777 {
778 try {
779 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
780 Handle(Graphic2d_DisplayList)* theret = new Handle(Graphic2d_DisplayList);
781 *theret = the_this->Pick((Standard_Integer) Xmin,(Standard_Integer) Ymin,(Standard_Integer) Xmax,(Standard_Integer) Ymax,(Graphic2d_PickMode) aPickMode);
782 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Graphic2d_DisplayList",theret);
783
784 }
785 catch (Standard_Failure) {
786   Standard_SStream Err;
787   Err <<   Standard_Failure::Caught(); 
788   Err << (char) 0;
789   jcas_ThrowException(env,Err.str().c_str());
790 }
791 }
792 alock.Release();
793 return thejret;
794 }
795
796
797
798 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Erase (JNIEnv *env, jobject theobj)
799 {
800
801 jcas_Locking alock(env);
802 {
803 try {
804 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
805 the_this->Erase();
806
807 }
808 catch (Standard_Failure) {
809   Standard_SStream Err;
810   Err <<   Standard_Failure::Caught(); 
811   Err << (char) 0;
812   jcas_ThrowException(env,Err.str().c_str());
813 }
814 }
815 alock.Release();
816
817 }
818
819
820
821 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_MustBeResized (JNIEnv *env, jobject theobj, jshort anEffect)
822 {
823
824 jcas_Locking alock(env);
825 {
826 try {
827 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
828 the_this->MustBeResized((V2d_TypeOfWindowResizingEffect) anEffect);
829
830 }
831 catch (Standard_Failure) {
832   Standard_SStream Err;
833   Err <<   Standard_Failure::Caught(); 
834   Err << (char) 0;
835   jcas_ThrowException(env,Err.str().c_str());
836 }
837 }
838 alock.Release();
839
840 }
841
842
843
844 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_HasBeenMoved (JNIEnv *env, jobject theobj)
845 {
846
847 jcas_Locking alock(env);
848 {
849 try {
850 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
851 the_this->HasBeenMoved();
852
853 }
854 catch (Standard_Failure) {
855   Standard_SStream Err;
856   Err <<   Standard_Failure::Caught(); 
857   Err << (char) 0;
858   jcas_ThrowException(env,Err.str().c_str());
859 }
860 }
861 alock.Release();
862
863 }
864
865
866
867 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Plot_11 (JNIEnv *env, jobject theobj, jobject aPlotterDriver, jdouble aXCenter, jdouble aYCenter, jdouble aScale)
868 {
869
870 jcas_Locking alock(env);
871 {
872 try {
873  Handle( PlotMgt_PlotterDriver ) the_aPlotterDriver;
874  void*                ptr_aPlotterDriver = jcas_GetHandle(env,aPlotterDriver);
875  
876  if ( ptr_aPlotterDriver != NULL ) the_aPlotterDriver = *(   (  Handle( PlotMgt_PlotterDriver )*  )ptr_aPlotterDriver   );
877
878 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
879 the_this->Plot(the_aPlotterDriver,(Quantity_Length) aXCenter,(Quantity_Length) aYCenter,(Quantity_Factor) aScale);
880
881 }
882 catch (Standard_Failure) {
883   Standard_SStream Err;
884   Err <<   Standard_Failure::Caught(); 
885   Err << (char) 0;
886   jcas_ThrowException(env,Err.str().c_str());
887 }
888 }
889 alock.Release();
890
891 }
892
893
894
895 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Plot_12 (JNIEnv *env, jobject theobj, jobject aPlotterDriver, jdouble aScale)
896 {
897
898 jcas_Locking alock(env);
899 {
900 try {
901  Handle( PlotMgt_PlotterDriver ) the_aPlotterDriver;
902  void*                ptr_aPlotterDriver = jcas_GetHandle(env,aPlotterDriver);
903  
904  if ( ptr_aPlotterDriver != NULL ) the_aPlotterDriver = *(   (  Handle( PlotMgt_PlotterDriver )*  )ptr_aPlotterDriver   );
905
906 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
907 the_this->Plot(the_aPlotterDriver,(Quantity_Factor) aScale);
908
909 }
910 catch (Standard_Failure) {
911   Standard_SStream Err;
912   Err <<   Standard_Failure::Caught(); 
913   Err << (char) 0;
914   jcas_ThrowException(env,Err.str().c_str());
915 }
916 }
917 alock.Release();
918
919 }
920
921
922
923 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_PlotScreen (JNIEnv *env, jobject theobj, jobject aPlotterDriver)
924 {
925
926 jcas_Locking alock(env);
927 {
928 try {
929  Handle( PlotMgt_PlotterDriver ) the_aPlotterDriver;
930  void*                ptr_aPlotterDriver = jcas_GetHandle(env,aPlotterDriver);
931  
932  if ( ptr_aPlotterDriver != NULL ) the_aPlotterDriver = *(   (  Handle( PlotMgt_PlotterDriver )*  )ptr_aPlotterDriver   );
933
934 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
935 the_this->PlotScreen(the_aPlotterDriver);
936
937 }
938 catch (Standard_Failure) {
939   Standard_SStream Err;
940   Err <<   Standard_Failure::Caught(); 
941   Err << (char) 0;
942   jcas_ThrowException(env,Err.str().c_str());
943 }
944 }
945 alock.Release();
946
947 }
948
949
950
951 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_ScreenCopy (JNIEnv *env, jobject theobj, jobject aPlotterDriver, jboolean fWhiteBackground, jdouble aScale)
952 {
953
954 jcas_Locking alock(env);
955 {
956 try {
957  Handle( PlotMgt_PlotterDriver ) the_aPlotterDriver;
958  void*                ptr_aPlotterDriver = jcas_GetHandle(env,aPlotterDriver);
959  
960  if ( ptr_aPlotterDriver != NULL ) the_aPlotterDriver = *(   (  Handle( PlotMgt_PlotterDriver )*  )ptr_aPlotterDriver   );
961
962 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
963 the_this->ScreenCopy(the_aPlotterDriver,(Standard_Boolean) fWhiteBackground,(Quantity_Factor) aScale);
964
965 }
966 catch (Standard_Failure) {
967   Standard_SStream Err;
968   Err <<   Standard_Failure::Caught(); 
969   Err << (char) 0;
970   jcas_ThrowException(env,Err.str().c_str());
971 }
972 }
973 alock.Release();
974
975 }
976
977
978
979 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_PostScriptOutput (JNIEnv *env, jobject theobj, jobject aFile, jdouble aWidth, jdouble aHeight, jdouble aXCenter, jdouble aYCenter, jdouble aScale, jshort aTypeOfColorSpace)
980 {
981
982 jcas_Locking alock(env);
983 {
984 try {
985 Standard_CString the_aFile = jcas_ConvertToCString(env,aFile);
986 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
987 the_this->PostScriptOutput(the_aFile,(Quantity_Length) aWidth,(Quantity_Length) aHeight,(Quantity_Length) aXCenter,(Quantity_Length) aYCenter,(Quantity_Factor) aScale,(Aspect_TypeOfColorSpace) aTypeOfColorSpace);
988
989 }
990 catch (Standard_Failure) {
991   Standard_SStream Err;
992   Err <<   Standard_Failure::Caught(); 
993   Err << (char) 0;
994   jcas_ThrowException(env,Err.str().c_str());
995 }
996 }
997 alock.Release();
998
999 }
1000
1001
1002
1003 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_ScreenPostScriptOutput (JNIEnv *env, jobject theobj, jobject aFile, jdouble aWidth, jdouble aHeight, jshort aTypeOfColorSpace)
1004 {
1005
1006 jcas_Locking alock(env);
1007 {
1008 try {
1009 Standard_CString the_aFile = jcas_ConvertToCString(env,aFile);
1010 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1011 the_this->ScreenPostScriptOutput(the_aFile,(Quantity_Length) aWidth,(Quantity_Length) aHeight,(Aspect_TypeOfColorSpace) aTypeOfColorSpace);
1012
1013 }
1014 catch (Standard_Failure) {
1015   Standard_SStream Err;
1016   Err <<   Standard_Failure::Caught(); 
1017   Err << (char) 0;
1018   jcas_ThrowException(env,Err.str().c_str());
1019 }
1020 }
1021 alock.Release();
1022
1023 }
1024
1025
1026
1027 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Hit (JNIEnv *env, jobject theobj, jint X, jint Y, jobject gx, jobject gy)
1028 {
1029
1030 jcas_Locking alock(env);
1031 {
1032 try {
1033 Standard_Real the_gx = jcas_GetReal(env,gx);
1034 Standard_Real the_gy = jcas_GetReal(env,gy);
1035 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1036 the_this->Hit((Standard_Integer) X,(Standard_Integer) Y,the_gx,the_gy);
1037 jcas_SetReal(env,gx,the_gx);
1038 jcas_SetReal(env,gy,the_gy);
1039
1040 }
1041 catch (Standard_Failure) {
1042   Standard_SStream Err;
1043   Err <<   Standard_Failure::Caught(); 
1044   Err << (char) 0;
1045   jcas_ThrowException(env,Err.str().c_str());
1046 }
1047 }
1048 alock.Release();
1049
1050 }
1051
1052
1053
1054 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_ShowHit (JNIEnv *env, jobject theobj, jint X, jint Y)
1055 {
1056
1057 jcas_Locking alock(env);
1058 {
1059 try {
1060 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1061 the_this->ShowHit((Standard_Integer) X,(Standard_Integer) Y);
1062
1063 }
1064 catch (Standard_Failure) {
1065   Standard_SStream Err;
1066   Err <<   Standard_Failure::Caught(); 
1067   Err << (char) 0;
1068   jcas_ThrowException(env,Err.str().c_str());
1069 }
1070 }
1071 alock.Release();
1072
1073 }
1074
1075
1076
1077 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_EraseHit (JNIEnv *env, jobject theobj)
1078 {
1079
1080 jcas_Locking alock(env);
1081 {
1082 try {
1083 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1084 the_this->EraseHit();
1085
1086 }
1087 catch (Standard_Failure) {
1088   Standard_SStream Err;
1089   Err <<   Standard_Failure::Caught(); 
1090   Err << (char) 0;
1091   jcas_ThrowException(env,Err.str().c_str());
1092 }
1093 }
1094 alock.Release();
1095
1096 }
1097
1098
1099
1100 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_SetDefaultHighlightColor (JNIEnv *env, jobject theobj, jint aColorIndex)
1101 {
1102
1103 jcas_Locking alock(env);
1104 {
1105 try {
1106 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1107 the_this->SetDefaultHighlightColor((Standard_Integer) aColorIndex);
1108
1109 }
1110 catch (Standard_Failure) {
1111   Standard_SStream Err;
1112   Err <<   Standard_Failure::Caught(); 
1113   Err << (char) 0;
1114   jcas_ThrowException(env,Err.str().c_str());
1115 }
1116 }
1117 alock.Release();
1118
1119 }
1120
1121
1122
1123 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_SetDeflection (JNIEnv *env, jobject theobj, jdouble aDeflection)
1124 {
1125
1126 jcas_Locking alock(env);
1127 {
1128 try {
1129 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1130 the_this->SetDeflection((Quantity_Length) aDeflection);
1131
1132 }
1133 catch (Standard_Failure) {
1134   Standard_SStream Err;
1135   Err <<   Standard_Failure::Caught(); 
1136   Err << (char) 0;
1137   jcas_ThrowException(env,Err.str().c_str());
1138 }
1139 }
1140 alock.Release();
1141
1142 }
1143
1144
1145
1146 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V2d_1View_Deflection (JNIEnv *env, jobject theobj)
1147 {
1148 jdouble thejret;
1149
1150 jcas_Locking alock(env);
1151 {
1152 try {
1153 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1154  thejret = the_this->Deflection();
1155
1156 }
1157 catch (Standard_Failure) {
1158   Standard_SStream Err;
1159   Err <<   Standard_Failure::Caught(); 
1160   Err << (char) 0;
1161   jcas_ThrowException(env,Err.str().c_str());
1162 }
1163 }
1164 alock.Release();
1165 return thejret;
1166 }
1167
1168
1169
1170 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V2d_1View_View (JNIEnv *env, jobject theobj)
1171 {
1172 jobject thejret;
1173
1174 jcas_Locking alock(env);
1175 {
1176 try {
1177 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1178 Handle(Graphic2d_View)* theret = new Handle(Graphic2d_View);
1179 *theret = the_this->View();
1180 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Graphic2d_View",theret);
1181
1182 }
1183 catch (Standard_Failure) {
1184   Standard_SStream Err;
1185   Err <<   Standard_Failure::Caught(); 
1186   Err << (char) 0;
1187   jcas_ThrowException(env,Err.str().c_str());
1188 }
1189 }
1190 alock.Release();
1191 return thejret;
1192 }
1193
1194
1195
1196 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V2d_1View_Viewer (JNIEnv *env, jobject theobj)
1197 {
1198 jobject thejret;
1199
1200 jcas_Locking alock(env);
1201 {
1202 try {
1203 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1204 Handle(V2d_Viewer)* theret = new Handle(V2d_Viewer);
1205 *theret = the_this->Viewer();
1206 thejret = jcas_CreateObject(env,"CASCADESamplesJni/V2d_Viewer",theret);
1207
1208 }
1209 catch (Standard_Failure) {
1210   Standard_SStream Err;
1211   Err <<   Standard_Failure::Caught(); 
1212   Err << (char) 0;
1213   jcas_ThrowException(env,Err.str().c_str());
1214 }
1215 }
1216 alock.Release();
1217 return thejret;
1218 }
1219
1220
1221
1222 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_V2d_1View_Driver (JNIEnv *env, jobject theobj)
1223 {
1224 jobject thejret;
1225
1226 jcas_Locking alock(env);
1227 {
1228 try {
1229 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1230 Handle(Aspect_WindowDriver)* theret = new Handle(Aspect_WindowDriver);
1231 *theret = the_this->Driver();
1232 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_WindowDriver",theret);
1233
1234 }
1235 catch (Standard_Failure) {
1236   Standard_SStream Err;
1237   Err <<   Standard_Failure::Caught(); 
1238   Err << (char) 0;
1239   jcas_ThrowException(env,Err.str().c_str());
1240 }
1241 }
1242 alock.Release();
1243 return thejret;
1244 }
1245
1246
1247
1248 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Zoom_14 (JNIEnv *env, jobject theobj)
1249 {
1250 jdouble thejret;
1251
1252 jcas_Locking alock(env);
1253 {
1254 try {
1255 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1256  thejret = the_this->Zoom();
1257
1258 }
1259 catch (Standard_Failure) {
1260   Standard_SStream Err;
1261   Err <<   Standard_Failure::Caught(); 
1262   Err << (char) 0;
1263   jcas_ThrowException(env,Err.str().c_str());
1264 }
1265 }
1266 alock.Release();
1267 return thejret;
1268 }
1269
1270
1271
1272 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Center (JNIEnv *env, jobject theobj, jobject aX, jobject aY)
1273 {
1274
1275 jcas_Locking alock(env);
1276 {
1277 try {
1278 Standard_Real the_aX = jcas_GetReal(env,aX);
1279 Standard_Real the_aY = jcas_GetReal(env,aY);
1280 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1281 the_this->Center(the_aX,the_aY);
1282 jcas_SetReal(env,aX,the_aX);
1283 jcas_SetReal(env,aY,the_aY);
1284
1285 }
1286 catch (Standard_Failure) {
1287   Standard_SStream Err;
1288   Err <<   Standard_Failure::Caught(); 
1289   Err << (char) 0;
1290   jcas_ThrowException(env,Err.str().c_str());
1291 }
1292 }
1293 alock.Release();
1294
1295 }
1296
1297
1298
1299 JNIEXPORT jdouble JNICALL Java_CASCADESamplesJni_V2d_1View_Size (JNIEnv *env, jobject theobj)
1300 {
1301 jdouble thejret;
1302
1303 jcas_Locking alock(env);
1304 {
1305 try {
1306 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1307  thejret = the_this->Size();
1308
1309 }
1310 catch (Standard_Failure) {
1311   Standard_SStream Err;
1312   Err <<   Standard_Failure::Caught(); 
1313   Err << (char) 0;
1314   jcas_ThrowException(env,Err.str().c_str());
1315 }
1316 }
1317 alock.Release();
1318 return thejret;
1319 }
1320
1321
1322
1323 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Color_11 (JNIEnv *env, jobject theobj)
1324 {
1325 jshort thejret;
1326
1327 jcas_Locking alock(env);
1328 {
1329 try {
1330 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1331  thejret = the_this->Color();
1332
1333 }
1334 catch (Standard_Failure) {
1335   Standard_SStream Err;
1336   Err <<   Standard_Failure::Caught(); 
1337   Err << (char) 0;
1338   jcas_ThrowException(env,Err.str().c_str());
1339 }
1340 }
1341 alock.Release();
1342 return thejret;
1343 }
1344
1345
1346
1347 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Color_12 (JNIEnv *env, jobject theobj, jobject color)
1348 {
1349
1350 jcas_Locking alock(env);
1351 {
1352 try {
1353 Quantity_Color* the_color = (Quantity_Color*) jcas_GetHandle(env,color);
1354 if ( the_color == NULL ) {
1355
1356  // The following assumes availability of the default constructor (what may not
1357  // always be the case). Therefore explicit exception is thrown if the null
1358  // object has been passed.
1359  // the_color = new Quantity_Color ();
1360  // jcas_SetHandle ( env, color, the_color );
1361  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1362
1363 }  // end if
1364 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1365 the_this->Color(*the_color);
1366
1367 }
1368 catch (Standard_Failure) {
1369   Standard_SStream Err;
1370   Err <<   Standard_Failure::Caught(); 
1371   Err << (char) 0;
1372   jcas_ThrowException(env,Err.str().c_str());
1373 }
1374 }
1375 alock.Release();
1376
1377 }
1378
1379
1380
1381 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_Scroll (JNIEnv *env, jobject theobj, jobject XCenter, jobject YCenter, jobject DX, jobject DY)
1382 {
1383
1384 jcas_Locking alock(env);
1385 {
1386 try {
1387 Standard_Integer the_XCenter = jcas_GetInteger(env,XCenter);
1388 Standard_Integer the_YCenter = jcas_GetInteger(env,YCenter);
1389 Standard_Integer the_DX = jcas_GetInteger(env,DX);
1390 Standard_Integer the_DY = jcas_GetInteger(env,DY);
1391 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1392 the_this->Scroll(the_XCenter,the_YCenter,the_DX,the_DY);
1393 jcas_SetInteger(env,XCenter,the_XCenter);
1394 jcas_SetInteger(env,YCenter,the_YCenter);
1395 jcas_SetInteger(env,DX,the_DX);
1396 jcas_SetInteger(env,DY,the_DY);
1397
1398 }
1399 catch (Standard_Failure) {
1400   Standard_SStream Err;
1401   Err <<   Standard_Failure::Caught(); 
1402   Err << (char) 0;
1403   jcas_ThrowException(env,Err.str().c_str());
1404 }
1405 }
1406 alock.Release();
1407
1408 }
1409
1410
1411
1412 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_V2d_1View_DefaultHighlightColor (JNIEnv *env, jobject theobj)
1413 {
1414 jint thejret;
1415
1416 jcas_Locking alock(env);
1417 {
1418 try {
1419 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1420  thejret = the_this->DefaultHighlightColor();
1421
1422 }
1423 catch (Standard_Failure) {
1424   Standard_SStream Err;
1425   Err <<   Standard_Failure::Caught(); 
1426   Err << (char) 0;
1427   jcas_ThrowException(env,Err.str().c_str());
1428 }
1429 }
1430 alock.Release();
1431 return thejret;
1432 }
1433
1434
1435
1436 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1Fit_12 (JNIEnv *env, jobject theobj, jint aX1, jint aY1, jint aX2, jint aY2)
1437 {
1438
1439 jcas_Locking alock(env);
1440 {
1441 try {
1442 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1443 the_this->Fit((Standard_Integer) aX1,(Standard_Integer) aY1,(Standard_Integer) aX2,(Standard_Integer) aY2);
1444
1445 }
1446 catch (Standard_Failure) {
1447   Standard_SStream Err;
1448   Err <<   Standard_Failure::Caught(); 
1449   Err << (char) 0;
1450   jcas_ThrowException(env,Err.str().c_str());
1451 }
1452 }
1453 alock.Release();
1454
1455 }
1456
1457
1458
1459 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1SetBackground_11 (JNIEnv *env, jobject theobj, jshort aNameColor)
1460 {
1461
1462 jcas_Locking alock(env);
1463 {
1464 try {
1465 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1466 the_this->SetBackground((Quantity_NameOfColor) aNameColor);
1467
1468 }
1469 catch (Standard_Failure) {
1470   Standard_SStream Err;
1471   Err <<   Standard_Failure::Caught(); 
1472   Err << (char) 0;
1473   jcas_ThrowException(env,Err.str().c_str());
1474 }
1475 }
1476 alock.Release();
1477
1478 }
1479
1480
1481
1482 JNIEXPORT void JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1SetBackground_12 (JNIEnv *env, jobject theobj, jobject color)
1483 {
1484
1485 jcas_Locking alock(env);
1486 {
1487 try {
1488 Quantity_Color* the_color = (Quantity_Color*) jcas_GetHandle(env,color);
1489 if ( the_color == NULL ) {
1490
1491  // The following assumes availability of the default constructor (what may not
1492  // always be the case). Therefore explicit exception is thrown if the null
1493  // object has been passed.
1494  // the_color = new Quantity_Color ();
1495  // jcas_SetHandle ( env, color, the_color );
1496  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
1497
1498 }  // end if
1499 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1500 the_this->SetBackground(*the_color);
1501
1502 }
1503 catch (Standard_Failure) {
1504   Standard_SStream Err;
1505   Err <<   Standard_Failure::Caught(); 
1506   Err << (char) 0;
1507   jcas_ThrowException(env,Err.str().c_str());
1508 }
1509 }
1510 alock.Release();
1511
1512 }
1513
1514
1515
1516 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_V2d_1View_V2d_1View_1SetBackground_13 (JNIEnv *env, jobject theobj, jobject aNameFile, jshort aMethod)
1517 {
1518 jboolean thejret;
1519
1520 jcas_Locking alock(env);
1521 {
1522 try {
1523 Standard_CString the_aNameFile = jcas_ConvertToCString(env,aNameFile);
1524 Handle(V2d_View) the_this = *((Handle(V2d_View)*) jcas_GetHandle(env,theobj));
1525  thejret = the_this->SetBackground(the_aNameFile,(Aspect_FillMethod) aMethod);
1526
1527 }
1528 catch (Standard_Failure) {
1529   Standard_SStream Err;
1530   Err <<   Standard_Failure::Caught(); 
1531   Err << (char) 0;
1532   jcas_ThrowException(env,Err.str().c_str());
1533 }
1534 }
1535 alock.Release();
1536 return thejret;
1537 }
1538
1539
1540 }