Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / SampleHLRJni / SampleHLRJni_Aspect_Window_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 <SampleHLRJni_Aspect_Window.h>
22 #include <Aspect_Window.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_Background.hxx>
30 #include <Quantity_NameOfColor.hxx>
31 #include <Quantity_Color.hxx>
32 #include <Standard_Boolean.hxx>
33 #include <Standard_CString.hxx>
34 #include <Aspect_FillMethod.hxx>
35 #include <Aspect_TypeOfResize.hxx>
36 #include <Standard_Integer.hxx>
37 #include <Standard_Real.hxx>
38 #include <Aspect_GraphicDevice.hxx>
39
40
41 extern "C" {
42
43
44 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1SetBackground_11 (JNIEnv *env, jobject theobj, jobject ABack)
45 {
46
47 jcas_Locking alock(env);
48 {
49 try {
50 Aspect_Background* the_ABack = (Aspect_Background*) jcas_GetHandle(env,ABack);
51 if ( the_ABack == NULL ) {
52
53  // The following assumes availability of the default constructor (what may not
54  // always be the case). Therefore explicit exception is thrown if the null
55  // object has been passed.
56  // the_ABack = new Aspect_Background ();
57  // jcas_SetHandle ( env, ABack, the_ABack );
58  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
59
60 }  // end if
61 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
62 the_this->SetBackground(*the_ABack);
63
64 }
65 catch (Standard_Failure) {
66   Standard_SStream Err;
67   Err <<   Standard_Failure::Caught(); 
68   Err << (char) 0;
69   jcas_ThrowException(env,Err.str().c_str());
70 }
71 }
72 alock.Release();
73
74 }
75
76
77
78 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1SetBackground_12 (JNIEnv *env, jobject theobj, jshort BackColor)
79 {
80
81 jcas_Locking alock(env);
82 {
83 try {
84 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
85 the_this->SetBackground((Quantity_NameOfColor) BackColor);
86
87 }
88 catch (Standard_Failure) {
89   Standard_SStream Err;
90   Err <<   Standard_Failure::Caught(); 
91   Err << (char) 0;
92   jcas_ThrowException(env,Err.str().c_str());
93 }
94 }
95 alock.Release();
96
97 }
98
99
100
101 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1SetBackground_13 (JNIEnv *env, jobject theobj, jobject color)
102 {
103
104 jcas_Locking alock(env);
105 {
106 try {
107 Quantity_Color* the_color = (Quantity_Color*) jcas_GetHandle(env,color);
108 if ( the_color == NULL ) {
109
110  // The following assumes availability of the default constructor (what may not
111  // always be the case). Therefore explicit exception is thrown if the null
112  // object has been passed.
113  // the_color = new Quantity_Color ();
114  // jcas_SetHandle ( env, color, the_color );
115  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
116
117 }  // end if
118 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
119 the_this->SetBackground(*the_color);
120
121 }
122 catch (Standard_Failure) {
123   Standard_SStream Err;
124   Err <<   Standard_Failure::Caught(); 
125   Err << (char) 0;
126   jcas_ThrowException(env,Err.str().c_str());
127 }
128 }
129 alock.Release();
130
131 }
132
133
134
135 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1SetBackground_14 (JNIEnv *env, jobject theobj, jobject aName, jshort aMethod)
136 {
137 jboolean thejret;
138
139 jcas_Locking alock(env);
140 {
141 try {
142 Standard_CString the_aName = jcas_ConvertToCString(env,aName);
143 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
144  thejret = the_this->SetBackground(the_aName,(Aspect_FillMethod) aMethod);
145
146 }
147 catch (Standard_Failure) {
148   Standard_SStream Err;
149   Err <<   Standard_Failure::Caught(); 
150   Err << (char) 0;
151   jcas_ThrowException(env,Err.str().c_str());
152 }
153 }
154 alock.Release();
155 return thejret;
156 }
157
158
159
160 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_SetDoubleBuffer (JNIEnv *env, jobject theobj, jboolean DBmode)
161 {
162
163 jcas_Locking alock(env);
164 {
165 try {
166 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
167 the_this->SetDoubleBuffer((Standard_Boolean) DBmode);
168
169 }
170 catch (Standard_Failure) {
171   Standard_SStream Err;
172   Err <<   Standard_Failure::Caught(); 
173   Err << (char) 0;
174   jcas_ThrowException(env,Err.str().c_str());
175 }
176 }
177 alock.Release();
178
179 }
180
181
182
183 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Flush (JNIEnv *env, jobject theobj)
184 {
185
186 jcas_Locking alock(env);
187 {
188 try {
189 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
190 the_this->Flush();
191
192 }
193 catch (Standard_Failure) {
194   Standard_SStream Err;
195   Err <<   Standard_Failure::Caught(); 
196   Err << (char) 0;
197   jcas_ThrowException(env,Err.str().c_str());
198 }
199 }
200 alock.Release();
201
202 }
203
204
205
206 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Map (JNIEnv *env, jobject theobj)
207 {
208
209 jcas_Locking alock(env);
210 {
211 try {
212 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
213 the_this->Map();
214
215 }
216 catch (Standard_Failure) {
217   Standard_SStream Err;
218   Err <<   Standard_Failure::Caught(); 
219   Err << (char) 0;
220   jcas_ThrowException(env,Err.str().c_str());
221 }
222 }
223 alock.Release();
224
225 }
226
227
228
229 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Unmap (JNIEnv *env, jobject theobj)
230 {
231
232 jcas_Locking alock(env);
233 {
234 try {
235 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
236 the_this->Unmap();
237
238 }
239 catch (Standard_Failure) {
240   Standard_SStream Err;
241   Err <<   Standard_Failure::Caught(); 
242   Err << (char) 0;
243   jcas_ThrowException(env,Err.str().c_str());
244 }
245 }
246 alock.Release();
247
248 }
249
250
251
252 JNIEXPORT jshort JNICALL Java_SampleHLRJni_Aspect_1Window_DoResize (JNIEnv *env, jobject theobj)
253 {
254 jshort thejret;
255
256 jcas_Locking alock(env);
257 {
258 try {
259 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
260  thejret = the_this->DoResize();
261
262 }
263 catch (Standard_Failure) {
264   Standard_SStream Err;
265   Err <<   Standard_Failure::Caught(); 
266   Err << (char) 0;
267   jcas_ThrowException(env,Err.str().c_str());
268 }
269 }
270 alock.Release();
271 return thejret;
272 }
273
274
275
276 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_DoMapping (JNIEnv *env, jobject theobj)
277 {
278 jboolean thejret;
279
280 jcas_Locking alock(env);
281 {
282 try {
283 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
284  thejret = the_this->DoMapping();
285
286 }
287 catch (Standard_Failure) {
288   Standard_SStream Err;
289   Err <<   Standard_Failure::Caught(); 
290   Err << (char) 0;
291   jcas_ThrowException(env,Err.str().c_str());
292 }
293 }
294 alock.Release();
295 return thejret;
296 }
297
298
299
300 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Destroy (JNIEnv *env, jobject theobj)
301 {
302
303 jcas_Locking alock(env);
304 {
305 try {
306 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
307 the_this->Destroy();
308
309 }
310 catch (Standard_Failure) {
311   Standard_SStream Err;
312   Err <<   Standard_Failure::Caught(); 
313   Err << (char) 0;
314   jcas_ThrowException(env,Err.str().c_str());
315 }
316 }
317 alock.Release();
318
319 }
320
321
322
323 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Clear (JNIEnv *env, jobject theobj)
324 {
325
326 jcas_Locking alock(env);
327 {
328 try {
329 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
330 the_this->Clear();
331
332 }
333 catch (Standard_Failure) {
334   Standard_SStream Err;
335   Err <<   Standard_Failure::Caught(); 
336   Err << (char) 0;
337   jcas_ThrowException(env,Err.str().c_str());
338 }
339 }
340 alock.Release();
341
342 }
343
344
345
346 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_ClearArea (JNIEnv *env, jobject theobj, jint XCenter, jint YCenter, jint Width, jint Height)
347 {
348
349 jcas_Locking alock(env);
350 {
351 try {
352 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
353 the_this->ClearArea((Standard_Integer) XCenter,(Standard_Integer) YCenter,(Standard_Integer) Width,(Standard_Integer) Height);
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_SampleHLRJni_Aspect_1Window_Restore (JNIEnv *env, jobject theobj)
370 {
371
372 jcas_Locking alock(env);
373 {
374 try {
375 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
376 the_this->Restore();
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_SampleHLRJni_Aspect_1Window_RestoreArea (JNIEnv *env, jobject theobj, jint XCenter, jint YCenter, jint Width, jint Height)
393 {
394
395 jcas_Locking alock(env);
396 {
397 try {
398 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
399 the_this->RestoreArea((Standard_Integer) XCenter,(Standard_Integer) YCenter,(Standard_Integer) Width,(Standard_Integer) Height);
400
401 }
402 catch (Standard_Failure) {
403   Standard_SStream Err;
404   Err <<   Standard_Failure::Caught(); 
405   Err << (char) 0;
406   jcas_ThrowException(env,Err.str().c_str());
407 }
408 }
409 alock.Release();
410
411 }
412
413
414
415 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_Dump (JNIEnv *env, jobject theobj, jobject aFilename, jdouble aGammaValue)
416 {
417 jboolean thejret;
418
419 jcas_Locking alock(env);
420 {
421 try {
422 Standard_CString the_aFilename = jcas_ConvertToCString(env,aFilename);
423 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
424  thejret = the_this->Dump(the_aFilename,(Standard_Real) aGammaValue);
425
426 }
427 catch (Standard_Failure) {
428   Standard_SStream Err;
429   Err <<   Standard_Failure::Caught(); 
430   Err << (char) 0;
431   jcas_ThrowException(env,Err.str().c_str());
432 }
433 }
434 alock.Release();
435 return thejret;
436 }
437
438
439
440 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_DumpArea (JNIEnv *env, jobject theobj, jobject aFilename, jint Xc, jint Yc, jint Width, jint Height, jdouble aGammaValue)
441 {
442 jboolean thejret;
443
444 jcas_Locking alock(env);
445 {
446 try {
447 Standard_CString the_aFilename = jcas_ConvertToCString(env,aFilename);
448 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
449  thejret = the_this->DumpArea(the_aFilename,(Standard_Integer) Xc,(Standard_Integer) Yc,(Standard_Integer) Width,(Standard_Integer) Height,(Standard_Real) aGammaValue);
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 return thejret;
461 }
462
463
464
465 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_Load (JNIEnv *env, jobject theobj, jobject aFilename)
466 {
467 jboolean thejret;
468
469 jcas_Locking alock(env);
470 {
471 try {
472 Standard_CString the_aFilename = jcas_ConvertToCString(env,aFilename);
473 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
474  thejret = the_this->Load(the_aFilename);
475
476 }
477 catch (Standard_Failure) {
478   Standard_SStream Err;
479   Err <<   Standard_Failure::Caught(); 
480   Err << (char) 0;
481   jcas_ThrowException(env,Err.str().c_str());
482 }
483 }
484 alock.Release();
485 return thejret;
486 }
487
488
489
490 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_LoadArea (JNIEnv *env, jobject theobj, jobject aFilename, jint Xc, jint Yc, jint Width, jint Height)
491 {
492 jboolean thejret;
493
494 jcas_Locking alock(env);
495 {
496 try {
497 Standard_CString the_aFilename = jcas_ConvertToCString(env,aFilename);
498 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
499  thejret = the_this->LoadArea(the_aFilename,(Standard_Integer) Xc,(Standard_Integer) Yc,(Standard_Integer) Width,(Standard_Integer) Height);
500
501 }
502 catch (Standard_Failure) {
503   Standard_SStream Err;
504   Err <<   Standard_Failure::Caught(); 
505   Err << (char) 0;
506   jcas_ThrowException(env,Err.str().c_str());
507 }
508 }
509 alock.Release();
510 return thejret;
511 }
512
513
514
515 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Window_Background (JNIEnv *env, jobject theobj)
516 {
517 jobject thejret;
518
519 jcas_Locking alock(env);
520 {
521 try {
522 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
523 Aspect_Background* theret = new Aspect_Background(the_this->Background());
524 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_Background",theret);
525
526 }
527 catch (Standard_Failure) {
528   Standard_SStream Err;
529   Err <<   Standard_Failure::Caught(); 
530   Err << (char) 0;
531   jcas_ThrowException(env,Err.str().c_str());
532 }
533 }
534 alock.Release();
535 return thejret;
536 }
537
538
539
540 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Window_BackgroundImage (JNIEnv *env, jobject theobj)
541 {
542 jobject thejret;
543
544 jcas_Locking alock(env);
545 {
546 try {
547 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
548 Standard_CString sret = the_this->BackgroundImage();
549 jclass CLSret  = env->FindClass("jcas/Standard_CString");
550 thejret = env->AllocObject(CLSret);
551 jcas_SetCStringValue(env,thejret,sret);
552
553 }
554 catch (Standard_Failure) {
555   Standard_SStream Err;
556   Err <<   Standard_Failure::Caught(); 
557   Err << (char) 0;
558   jcas_ThrowException(env,Err.str().c_str());
559 }
560 }
561 alock.Release();
562 return thejret;
563 }
564
565
566
567 JNIEXPORT jshort JNICALL Java_SampleHLRJni_Aspect_1Window_BackgroundFillMethod (JNIEnv *env, jobject theobj)
568 {
569 jshort thejret;
570
571 jcas_Locking alock(env);
572 {
573 try {
574 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
575  thejret = the_this->BackgroundFillMethod();
576
577 }
578 catch (Standard_Failure) {
579   Standard_SStream Err;
580   Err <<   Standard_Failure::Caught(); 
581   Err << (char) 0;
582   jcas_ThrowException(env,Err.str().c_str());
583 }
584 }
585 alock.Release();
586 return thejret;
587 }
588
589
590
591 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Window_GraphicDevice (JNIEnv *env, jobject theobj)
592 {
593 jobject thejret;
594
595 jcas_Locking alock(env);
596 {
597 try {
598 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
599 Handle(Aspect_GraphicDevice)* theret = new Handle(Aspect_GraphicDevice);
600 *theret = the_this->GraphicDevice();
601 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_GraphicDevice",theret);
602
603 }
604 catch (Standard_Failure) {
605   Standard_SStream Err;
606   Err <<   Standard_Failure::Caught(); 
607   Err << (char) 0;
608   jcas_ThrowException(env,Err.str().c_str());
609 }
610 }
611 alock.Release();
612 return thejret;
613 }
614
615
616
617 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_IsMapped (JNIEnv *env, jobject theobj)
618 {
619 jboolean thejret;
620
621 jcas_Locking alock(env);
622 {
623 try {
624 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
625  thejret = the_this->IsMapped();
626
627 }
628 catch (Standard_Failure) {
629   Standard_SStream Err;
630   Err <<   Standard_Failure::Caught(); 
631   Err << (char) 0;
632   jcas_ThrowException(env,Err.str().c_str());
633 }
634 }
635 alock.Release();
636 return thejret;
637 }
638
639
640
641 JNIEXPORT jdouble JNICALL Java_SampleHLRJni_Aspect_1Window_Ratio (JNIEnv *env, jobject theobj)
642 {
643 jdouble thejret;
644
645 jcas_Locking alock(env);
646 {
647 try {
648 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
649  thejret = the_this->Ratio();
650
651 }
652 catch (Standard_Failure) {
653   Standard_SStream Err;
654   Err <<   Standard_Failure::Caught(); 
655   Err << (char) 0;
656   jcas_ThrowException(env,Err.str().c_str());
657 }
658 }
659 alock.Release();
660 return thejret;
661 }
662
663
664
665 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Position_11 (JNIEnv *env, jobject theobj, jobject X1, jobject Y1, jobject X2, jobject Y2)
666 {
667
668 jcas_Locking alock(env);
669 {
670 try {
671 Standard_Real the_X1 = jcas_GetReal(env,X1);
672 Standard_Real the_Y1 = jcas_GetReal(env,Y1);
673 Standard_Real the_X2 = jcas_GetReal(env,X2);
674 Standard_Real the_Y2 = jcas_GetReal(env,Y2);
675 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
676 the_this->Position(the_X1,the_Y1,the_X2,the_Y2);
677 jcas_SetReal(env,X1,the_X1);
678 jcas_SetReal(env,Y1,the_Y1);
679 jcas_SetReal(env,X2,the_X2);
680 jcas_SetReal(env,Y2,the_Y2);
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_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Position_12 (JNIEnv *env, jobject theobj, jobject X1, jobject Y1, jobject X2, jobject Y2)
697 {
698
699 jcas_Locking alock(env);
700 {
701 try {
702 Standard_Integer the_X1 = jcas_GetInteger(env,X1);
703 Standard_Integer the_Y1 = jcas_GetInteger(env,Y1);
704 Standard_Integer the_X2 = jcas_GetInteger(env,X2);
705 Standard_Integer the_Y2 = jcas_GetInteger(env,Y2);
706 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
707 the_this->Position(the_X1,the_Y1,the_X2,the_Y2);
708 jcas_SetInteger(env,X1,the_X1);
709 jcas_SetInteger(env,Y1,the_Y1);
710 jcas_SetInteger(env,X2,the_X2);
711 jcas_SetInteger(env,Y2,the_Y2);
712
713 }
714 catch (Standard_Failure) {
715   Standard_SStream Err;
716   Err <<   Standard_Failure::Caught(); 
717   Err << (char) 0;
718   jcas_ThrowException(env,Err.str().c_str());
719 }
720 }
721 alock.Release();
722
723 }
724
725
726
727 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Size_11 (JNIEnv *env, jobject theobj, jobject Width, jobject Height)
728 {
729
730 jcas_Locking alock(env);
731 {
732 try {
733 Standard_Real the_Width = jcas_GetReal(env,Width);
734 Standard_Real the_Height = jcas_GetReal(env,Height);
735 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
736 the_this->Size(the_Width,the_Height);
737 jcas_SetReal(env,Width,the_Width);
738 jcas_SetReal(env,Height,the_Height);
739
740 }
741 catch (Standard_Failure) {
742   Standard_SStream Err;
743   Err <<   Standard_Failure::Caught(); 
744   Err << (char) 0;
745   jcas_ThrowException(env,Err.str().c_str());
746 }
747 }
748 alock.Release();
749
750 }
751
752
753
754 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Size_12 (JNIEnv *env, jobject theobj, jobject Width, jobject Height)
755 {
756
757 jcas_Locking alock(env);
758 {
759 try {
760 Standard_Integer the_Width = jcas_GetInteger(env,Width);
761 Standard_Integer the_Height = jcas_GetInteger(env,Height);
762 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
763 the_this->Size(the_Width,the_Height);
764 jcas_SetInteger(env,Width,the_Width);
765 jcas_SetInteger(env,Height,the_Height);
766
767 }
768 catch (Standard_Failure) {
769   Standard_SStream Err;
770   Err <<   Standard_Failure::Caught(); 
771   Err << (char) 0;
772   jcas_ThrowException(env,Err.str().c_str());
773 }
774 }
775 alock.Release();
776
777 }
778
779
780
781 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_MMSize (JNIEnv *env, jobject theobj, jobject Width, jobject Height)
782 {
783
784 jcas_Locking alock(env);
785 {
786 try {
787 Standard_Real the_Width = jcas_GetReal(env,Width);
788 Standard_Real the_Height = jcas_GetReal(env,Height);
789 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
790 the_this->MMSize(the_Width,the_Height);
791 jcas_SetReal(env,Width,the_Width);
792 jcas_SetReal(env,Height,the_Height);
793
794 }
795 catch (Standard_Failure) {
796   Standard_SStream Err;
797   Err <<   Standard_Failure::Caught(); 
798   Err << (char) 0;
799   jcas_ThrowException(env,Err.str().c_str());
800 }
801 }
802 alock.Release();
803
804 }
805
806
807
808 JNIEXPORT jdouble JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Convert_11 (JNIEnv *env, jobject theobj, jint PV)
809 {
810 jdouble thejret;
811
812 jcas_Locking alock(env);
813 {
814 try {
815 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
816  thejret = the_this->Convert((Standard_Integer) PV);
817
818 }
819 catch (Standard_Failure) {
820   Standard_SStream Err;
821   Err <<   Standard_Failure::Caught(); 
822   Err << (char) 0;
823   jcas_ThrowException(env,Err.str().c_str());
824 }
825 }
826 alock.Release();
827 return thejret;
828 }
829
830
831
832 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Convert_12 (JNIEnv *env, jobject theobj, jdouble DV)
833 {
834 jint thejret;
835
836 jcas_Locking alock(env);
837 {
838 try {
839 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
840  thejret = the_this->Convert((Quantity_Parameter) DV);
841
842 }
843 catch (Standard_Failure) {
844   Standard_SStream Err;
845   Err <<   Standard_Failure::Caught(); 
846   Err << (char) 0;
847   jcas_ThrowException(env,Err.str().c_str());
848 }
849 }
850 alock.Release();
851 return thejret;
852 }
853
854
855
856 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Convert_13 (JNIEnv *env, jobject theobj, jint PX, jint PY, jobject DX, jobject DY)
857 {
858
859 jcas_Locking alock(env);
860 {
861 try {
862 Standard_Real the_DX = jcas_GetReal(env,DX);
863 Standard_Real the_DY = jcas_GetReal(env,DY);
864 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
865 the_this->Convert((Standard_Integer) PX,(Standard_Integer) PY,the_DX,the_DY);
866 jcas_SetReal(env,DX,the_DX);
867 jcas_SetReal(env,DY,the_DY);
868
869 }
870 catch (Standard_Failure) {
871   Standard_SStream Err;
872   Err <<   Standard_Failure::Caught(); 
873   Err << (char) 0;
874   jcas_ThrowException(env,Err.str().c_str());
875 }
876 }
877 alock.Release();
878
879 }
880
881
882
883 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Window_Aspect_1Window_1Convert_14 (JNIEnv *env, jobject theobj, jdouble DX, jdouble DY, jobject PX, jobject PY)
884 {
885
886 jcas_Locking alock(env);
887 {
888 try {
889 Standard_Integer the_PX = jcas_GetInteger(env,PX);
890 Standard_Integer the_PY = jcas_GetInteger(env,PY);
891 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
892 the_this->Convert((Quantity_Parameter) DX,(Quantity_Parameter) DY,the_PX,the_PY);
893 jcas_SetInteger(env,PX,the_PX);
894 jcas_SetInteger(env,PY,the_PY);
895
896 }
897 catch (Standard_Failure) {
898   Standard_SStream Err;
899   Err <<   Standard_Failure::Caught(); 
900   Err << (char) 0;
901   jcas_ThrowException(env,Err.str().c_str());
902 }
903 }
904 alock.Release();
905
906 }
907
908
909
910 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_BackingStore (JNIEnv *env, jobject theobj)
911 {
912 jboolean thejret;
913
914 jcas_Locking alock(env);
915 {
916 try {
917 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
918  thejret = the_this->BackingStore();
919
920 }
921 catch (Standard_Failure) {
922   Standard_SStream Err;
923   Err <<   Standard_Failure::Caught(); 
924   Err << (char) 0;
925   jcas_ThrowException(env,Err.str().c_str());
926 }
927 }
928 alock.Release();
929 return thejret;
930 }
931
932
933
934 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Window_DoubleBuffer (JNIEnv *env, jobject theobj)
935 {
936 jboolean thejret;
937
938 jcas_Locking alock(env);
939 {
940 try {
941 Handle(Aspect_Window) the_this = *((Handle(Aspect_Window)*) jcas_GetHandle(env,theobj));
942  thejret = the_this->DoubleBuffer();
943
944 }
945 catch (Standard_Failure) {
946   Standard_SStream Err;
947   Err <<   Standard_Failure::Caught(); 
948   Err << (char) 0;
949   jcas_ThrowException(env,Err.str().c_str());
950 }
951 }
952 alock.Release();
953 return thejret;
954 }
955
956
957 }