Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / SampleHLRJni / SampleHLRJni_Aspect_WindowDriver_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_WindowDriver.h>
22 #include <Aspect_WindowDriver.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 <Standard_Boolean.hxx>
30 #include <Standard_Integer.hxx>
31 #include <Aspect_TypeOfResize.hxx>
32 #include <Aspect_Window.hxx>
33 #include <Aspect_TypeOfDrawMode.hxx>
34 #include <Standard_ShortReal.hxx>
35 #include <Standard_Real.hxx>
36 #include <TCollection_ExtendedString.hxx>
37 #include <Standard_CString.hxx>
38
39
40 extern "C" {
41
42
43 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_BeginDraw (JNIEnv *env, jobject theobj, jboolean DoubleBuffer, jint aRetainBuffer)
44 {
45
46 jcas_Locking alock(env);
47 {
48 try {
49 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
50 the_this->BeginDraw((Standard_Boolean) DoubleBuffer,(Standard_Integer) aRetainBuffer);
51
52 }
53 catch (Standard_Failure) {
54   Standard_SStream Err;
55   Err <<   Standard_Failure::Caught(); 
56   Err << (char) 0;
57   jcas_ThrowException(env,Err.str().c_str());
58 }
59 }
60 alock.Release();
61
62 }
63
64
65
66 JNIEXPORT jshort JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_ResizeSpace (JNIEnv *env, jobject theobj)
67 {
68 jshort thejret;
69
70 jcas_Locking alock(env);
71 {
72 try {
73 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
74  thejret = the_this->ResizeSpace();
75
76 }
77 catch (Standard_Failure) {
78   Standard_SStream Err;
79   Err <<   Standard_Failure::Caught(); 
80   Err << (char) 0;
81   jcas_ThrowException(env,Err.str().c_str());
82 }
83 }
84 alock.Release();
85 return thejret;
86 }
87
88
89
90 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_Window (JNIEnv *env, jobject theobj)
91 {
92 jobject thejret;
93
94 jcas_Locking alock(env);
95 {
96 try {
97 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
98 Handle(Aspect_Window)* theret = new Handle(Aspect_Window);
99 *theret = the_this->Window();
100 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_Window",theret);
101
102 }
103 catch (Standard_Failure) {
104   Standard_SStream Err;
105   Err <<   Standard_Failure::Caught(); 
106   Err << (char) 0;
107   jcas_ThrowException(env,Err.str().c_str());
108 }
109 }
110 alock.Release();
111 return thejret;
112 }
113
114
115
116 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_SetDrawMode (JNIEnv *env, jobject theobj, jshort aMode)
117 {
118
119 jcas_Locking alock(env);
120 {
121 try {
122 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
123 the_this->SetDrawMode((Aspect_TypeOfDrawMode) aMode);
124
125 }
126 catch (Standard_Failure) {
127   Standard_SStream Err;
128   Err <<   Standard_Failure::Caught(); 
129   Err << (char) 0;
130   jcas_ThrowException(env,Err.str().c_str());
131 }
132 }
133 alock.Release();
134
135 }
136
137
138
139 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_OpenBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jfloat aPivotX, jfloat aPivotY, jint aWidthIndex, jint aColorIndex, jint aFontIndex, jshort aDrawMode)
140 {
141 jboolean thejret;
142
143 jcas_Locking alock(env);
144 {
145 try {
146 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
147  thejret = the_this->OpenBuffer((Standard_Integer) aRetainBuffer,(Standard_ShortReal) aPivotX,(Standard_ShortReal) aPivotY,(Standard_Integer) aWidthIndex,(Standard_Integer) aColorIndex,(Standard_Integer) aFontIndex,(Aspect_TypeOfDrawMode) aDrawMode);
148
149 }
150 catch (Standard_Failure) {
151   Standard_SStream Err;
152   Err <<   Standard_Failure::Caught(); 
153   Err << (char) 0;
154   jcas_ThrowException(env,Err.str().c_str());
155 }
156 }
157 alock.Release();
158 return thejret;
159 }
160
161
162
163 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_CloseBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer)
164 {
165
166 jcas_Locking alock(env);
167 {
168 try {
169 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
170 the_this->CloseBuffer((Standard_Integer) aRetainBuffer);
171
172 }
173 catch (Standard_Failure) {
174   Standard_SStream Err;
175   Err <<   Standard_Failure::Caught(); 
176   Err << (char) 0;
177   jcas_ThrowException(env,Err.str().c_str());
178 }
179 }
180 alock.Release();
181
182 }
183
184
185
186 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_ClearBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer)
187 {
188
189 jcas_Locking alock(env);
190 {
191 try {
192 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
193 the_this->ClearBuffer((Standard_Integer) aRetainBuffer);
194
195 }
196 catch (Standard_Failure) {
197   Standard_SStream Err;
198   Err <<   Standard_Failure::Caught(); 
199   Err << (char) 0;
200   jcas_ThrowException(env,Err.str().c_str());
201 }
202 }
203 alock.Release();
204
205 }
206
207
208
209 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_DrawBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer)
210 {
211
212 jcas_Locking alock(env);
213 {
214 try {
215 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
216 the_this->DrawBuffer((Standard_Integer) aRetainBuffer);
217
218 }
219 catch (Standard_Failure) {
220   Standard_SStream Err;
221   Err <<   Standard_Failure::Caught(); 
222   Err << (char) 0;
223   jcas_ThrowException(env,Err.str().c_str());
224 }
225 }
226 alock.Release();
227
228 }
229
230
231
232 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_EraseBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer)
233 {
234
235 jcas_Locking alock(env);
236 {
237 try {
238 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
239 the_this->EraseBuffer((Standard_Integer) aRetainBuffer);
240
241 }
242 catch (Standard_Failure) {
243   Standard_SStream Err;
244   Err <<   Standard_Failure::Caught(); 
245   Err << (char) 0;
246   jcas_ThrowException(env,Err.str().c_str());
247 }
248 }
249 alock.Release();
250
251 }
252
253
254
255 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_MoveBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jfloat aPivotX, jfloat aPivotY)
256 {
257
258 jcas_Locking alock(env);
259 {
260 try {
261 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
262 the_this->MoveBuffer((Standard_Integer) aRetainBuffer,(Standard_ShortReal) aPivotX,(Standard_ShortReal) aPivotY);
263
264 }
265 catch (Standard_Failure) {
266   Standard_SStream Err;
267   Err <<   Standard_Failure::Caught(); 
268   Err << (char) 0;
269   jcas_ThrowException(env,Err.str().c_str());
270 }
271 }
272 alock.Release();
273
274 }
275
276
277
278 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_ScaleBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jdouble aScaleX, jdouble aScaleY)
279 {
280
281 jcas_Locking alock(env);
282 {
283 try {
284 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
285 the_this->ScaleBuffer((Standard_Integer) aRetainBuffer,(Quantity_Factor) aScaleX,(Quantity_Factor) aScaleY);
286
287 }
288 catch (Standard_Failure) {
289   Standard_SStream Err;
290   Err <<   Standard_Failure::Caught(); 
291   Err << (char) 0;
292   jcas_ThrowException(env,Err.str().c_str());
293 }
294 }
295 alock.Release();
296
297 }
298
299
300
301 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_RotateBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jdouble anAngle)
302 {
303
304 jcas_Locking alock(env);
305 {
306 try {
307 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
308 the_this->RotateBuffer((Standard_Integer) aRetainBuffer,(Quantity_PlaneAngle) anAngle);
309
310 }
311 catch (Standard_Failure) {
312   Standard_SStream Err;
313   Err <<   Standard_Failure::Caught(); 
314   Err << (char) 0;
315   jcas_ThrowException(env,Err.str().c_str());
316 }
317 }
318 alock.Release();
319
320 }
321
322
323
324 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_BufferIsOpen (JNIEnv *env, jobject theobj, jint aRetainBuffer)
325 {
326 jboolean thejret;
327
328 jcas_Locking alock(env);
329 {
330 try {
331 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
332  thejret = the_this->BufferIsOpen((Standard_Integer) aRetainBuffer);
333
334 }
335 catch (Standard_Failure) {
336   Standard_SStream Err;
337   Err <<   Standard_Failure::Caught(); 
338   Err << (char) 0;
339   jcas_ThrowException(env,Err.str().c_str());
340 }
341 }
342 alock.Release();
343 return thejret;
344 }
345
346
347
348 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_BufferIsEmpty (JNIEnv *env, jobject theobj, jint aRetainBuffer)
349 {
350 jboolean thejret;
351
352 jcas_Locking alock(env);
353 {
354 try {
355 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
356  thejret = the_this->BufferIsEmpty((Standard_Integer) aRetainBuffer);
357
358 }
359 catch (Standard_Failure) {
360   Standard_SStream Err;
361   Err <<   Standard_Failure::Caught(); 
362   Err << (char) 0;
363   jcas_ThrowException(env,Err.str().c_str());
364 }
365 }
366 alock.Release();
367 return thejret;
368 }
369
370
371
372 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_BufferIsDrawn (JNIEnv *env, jobject theobj, jint aRetainBuffer)
373 {
374 jboolean thejret;
375
376 jcas_Locking alock(env);
377 {
378 try {
379 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
380  thejret = the_this->BufferIsDrawn((Standard_Integer) aRetainBuffer);
381
382 }
383 catch (Standard_Failure) {
384   Standard_SStream Err;
385   Err <<   Standard_Failure::Caught(); 
386   Err << (char) 0;
387   jcas_ThrowException(env,Err.str().c_str());
388 }
389 }
390 alock.Release();
391 return thejret;
392 }
393
394
395
396 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_AngleOfBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jobject anAngle)
397 {
398
399 jcas_Locking alock(env);
400 {
401 try {
402 Standard_Real the_anAngle = jcas_GetReal(env,anAngle);
403 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
404 the_this->AngleOfBuffer((Standard_Integer) aRetainBuffer,the_anAngle);
405 jcas_SetReal(env,anAngle,the_anAngle);
406
407 }
408 catch (Standard_Failure) {
409   Standard_SStream Err;
410   Err <<   Standard_Failure::Caught(); 
411   Err << (char) 0;
412   jcas_ThrowException(env,Err.str().c_str());
413 }
414 }
415 alock.Release();
416
417 }
418
419
420
421 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_ScaleOfBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jobject aScaleX, jobject aScaleY)
422 {
423
424 jcas_Locking alock(env);
425 {
426 try {
427 Standard_Real the_aScaleX = jcas_GetReal(env,aScaleX);
428 Standard_Real the_aScaleY = jcas_GetReal(env,aScaleY);
429 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
430 the_this->ScaleOfBuffer((Standard_Integer) aRetainBuffer,the_aScaleX,the_aScaleY);
431 jcas_SetReal(env,aScaleX,the_aScaleX);
432 jcas_SetReal(env,aScaleY,the_aScaleY);
433
434 }
435 catch (Standard_Failure) {
436   Standard_SStream Err;
437   Err <<   Standard_Failure::Caught(); 
438   Err << (char) 0;
439   jcas_ThrowException(env,Err.str().c_str());
440 }
441 }
442 alock.Release();
443
444 }
445
446
447
448 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_PositionOfBuffer (JNIEnv *env, jobject theobj, jint aRetainBuffer, jobject aPivotX, jobject aPivotY)
449 {
450
451 jcas_Locking alock(env);
452 {
453 try {
454 Standard_ShortReal the_aPivotX = jcas_GetShortReal(env,aPivotX);
455 Standard_ShortReal the_aPivotY = jcas_GetShortReal(env,aPivotY);
456 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
457 the_this->PositionOfBuffer((Standard_Integer) aRetainBuffer,the_aPivotX,the_aPivotY);
458 jcas_SetShortReal(env,aPivotX,the_aPivotX);
459 jcas_SetShortReal(env,aPivotY,the_aPivotY);
460
461 }
462 catch (Standard_Failure) {
463   Standard_SStream Err;
464   Err <<   Standard_Failure::Caught(); 
465   Err << (char) 0;
466   jcas_ThrowException(env,Err.str().c_str());
467 }
468 }
469 alock.Release();
470
471 }
472
473
474
475 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_Aspect_1WindowDriver_1TextSize_11 (JNIEnv *env, jobject theobj, jobject aText, jobject aWidth, jobject aHeight, jint aFontIndex)
476 {
477
478 jcas_Locking alock(env);
479 {
480 try {
481 TCollection_ExtendedString* the_aText = (TCollection_ExtendedString*) jcas_GetHandle(env,aText);
482 if ( the_aText == NULL ) {
483
484  // The following assumes availability of the default constructor (what may not
485  // always be the case). Therefore explicit exception is thrown if the null
486  // object has been passed.
487  // the_aText = new TCollection_ExtendedString ();
488  // jcas_SetHandle ( env, aText, the_aText );
489  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
490
491 }  // end if
492 Standard_ShortReal the_aWidth = jcas_GetShortReal(env,aWidth);
493 Standard_ShortReal the_aHeight = jcas_GetShortReal(env,aHeight);
494 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
495 the_this->TextSize(*the_aText,the_aWidth,the_aHeight,(Standard_Integer) aFontIndex);
496 jcas_SetShortReal(env,aWidth,the_aWidth);
497 jcas_SetShortReal(env,aHeight,the_aHeight);
498
499 }
500 catch (Standard_Failure) {
501   Standard_SStream Err;
502   Err <<   Standard_Failure::Caught(); 
503   Err << (char) 0;
504   jcas_ThrowException(env,Err.str().c_str());
505 }
506 }
507 alock.Release();
508
509 }
510
511
512
513 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_Aspect_1WindowDriver_1TextSize_12 (JNIEnv *env, jobject theobj, jobject aText, jobject aWidth, jobject aHeight, jobject anXoffset, jobject anYoffset, jint aFontIndex)
514 {
515
516 jcas_Locking alock(env);
517 {
518 try {
519 TCollection_ExtendedString* the_aText = (TCollection_ExtendedString*) jcas_GetHandle(env,aText);
520 if ( the_aText == NULL ) {
521
522  // The following assumes availability of the default constructor (what may not
523  // always be the case). Therefore explicit exception is thrown if the null
524  // object has been passed.
525  // the_aText = new TCollection_ExtendedString ();
526  // jcas_SetHandle ( env, aText, the_aText );
527  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
528
529 }  // end if
530 Standard_ShortReal the_aWidth = jcas_GetShortReal(env,aWidth);
531 Standard_ShortReal the_aHeight = jcas_GetShortReal(env,aHeight);
532 Standard_ShortReal the_anXoffset = jcas_GetShortReal(env,anXoffset);
533 Standard_ShortReal the_anYoffset = jcas_GetShortReal(env,anYoffset);
534 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
535 the_this->TextSize(*the_aText,the_aWidth,the_aHeight,the_anXoffset,the_anYoffset,(Standard_Integer) aFontIndex);
536 jcas_SetShortReal(env,aWidth,the_aWidth);
537 jcas_SetShortReal(env,aHeight,the_aHeight);
538 jcas_SetShortReal(env,anXoffset,the_anXoffset);
539 jcas_SetShortReal(env,anYoffset,the_anYoffset);
540
541 }
542 catch (Standard_Failure) {
543   Standard_SStream Err;
544   Err <<   Standard_Failure::Caught(); 
545   Err << (char) 0;
546   jcas_ThrowException(env,Err.str().c_str());
547 }
548 }
549 alock.Release();
550
551 }
552
553
554
555 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_FontSize (JNIEnv *env, jobject theobj, jobject aSlant, jobject aSize, jobject aBheight, jint aFontIndex)
556 {
557 jobject thejret;
558
559 jcas_Locking alock(env);
560 {
561 try {
562 Standard_Real the_aSlant = jcas_GetReal(env,aSlant);
563 Standard_ShortReal the_aSize = jcas_GetShortReal(env,aSize);
564 Standard_ShortReal the_aBheight = jcas_GetShortReal(env,aBheight);
565 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
566 Standard_CString sret = the_this->FontSize(the_aSlant,the_aSize,the_aBheight,(Standard_Integer) aFontIndex);
567 jclass CLSret  = env->FindClass("jcas/Standard_CString");
568 thejret = env->AllocObject(CLSret);
569 jcas_SetCStringValue(env,thejret,sret);
570 jcas_SetReal(env,aSlant,the_aSlant);
571 jcas_SetShortReal(env,aSize,the_aSize);
572 jcas_SetShortReal(env,aBheight,the_aBheight);
573
574 }
575 catch (Standard_Failure) {
576   Standard_SStream Err;
577   Err <<   Standard_Failure::Caught(); 
578   Err << (char) 0;
579   jcas_ThrowException(env,Err.str().c_str());
580 }
581 }
582 alock.Release();
583 return thejret;
584 }
585
586
587
588 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_ColorBoundIndexs (JNIEnv *env, jobject theobj, jobject aMinIndex, jobject aMaxIndex)
589 {
590
591 jcas_Locking alock(env);
592 {
593 try {
594 Standard_Integer the_aMinIndex = jcas_GetInteger(env,aMinIndex);
595 Standard_Integer the_aMaxIndex = jcas_GetInteger(env,aMaxIndex);
596 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
597 the_this->ColorBoundIndexs(the_aMinIndex,the_aMaxIndex);
598 jcas_SetInteger(env,aMinIndex,the_aMinIndex);
599 jcas_SetInteger(env,aMaxIndex,the_aMaxIndex);
600
601 }
602 catch (Standard_Failure) {
603   Standard_SStream Err;
604   Err <<   Standard_Failure::Caught(); 
605   Err << (char) 0;
606   jcas_ThrowException(env,Err.str().c_str());
607 }
608 }
609 alock.Release();
610
611 }
612
613
614
615 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_LocalColorIndex (JNIEnv *env, jobject theobj, jint anIndex)
616 {
617 jint thejret;
618
619 jcas_Locking alock(env);
620 {
621 try {
622 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
623  thejret = the_this->LocalColorIndex((Standard_Integer) anIndex);
624
625 }
626 catch (Standard_Failure) {
627   Standard_SStream Err;
628   Err <<   Standard_Failure::Caught(); 
629   Err << (char) 0;
630   jcas_ThrowException(env,Err.str().c_str());
631 }
632 }
633 alock.Release();
634 return thejret;
635 }
636
637
638
639 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_FontBoundIndexs (JNIEnv *env, jobject theobj, jobject aMinIndex, jobject aMaxIndex)
640 {
641
642 jcas_Locking alock(env);
643 {
644 try {
645 Standard_Integer the_aMinIndex = jcas_GetInteger(env,aMinIndex);
646 Standard_Integer the_aMaxIndex = jcas_GetInteger(env,aMaxIndex);
647 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
648 the_this->FontBoundIndexs(the_aMinIndex,the_aMaxIndex);
649 jcas_SetInteger(env,aMinIndex,the_aMinIndex);
650 jcas_SetInteger(env,aMaxIndex,the_aMaxIndex);
651
652 }
653 catch (Standard_Failure) {
654   Standard_SStream Err;
655   Err <<   Standard_Failure::Caught(); 
656   Err << (char) 0;
657   jcas_ThrowException(env,Err.str().c_str());
658 }
659 }
660 alock.Release();
661
662 }
663
664
665
666 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_LocalFontIndex (JNIEnv *env, jobject theobj, jint anIndex)
667 {
668 jint thejret;
669
670 jcas_Locking alock(env);
671 {
672 try {
673 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
674  thejret = the_this->LocalFontIndex((Standard_Integer) anIndex);
675
676 }
677 catch (Standard_Failure) {
678   Standard_SStream Err;
679   Err <<   Standard_Failure::Caught(); 
680   Err << (char) 0;
681   jcas_ThrowException(env,Err.str().c_str());
682 }
683 }
684 alock.Release();
685 return thejret;
686 }
687
688
689
690 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_TypeBoundIndexs (JNIEnv *env, jobject theobj, jobject aMinIndex, jobject aMaxIndex)
691 {
692
693 jcas_Locking alock(env);
694 {
695 try {
696 Standard_Integer the_aMinIndex = jcas_GetInteger(env,aMinIndex);
697 Standard_Integer the_aMaxIndex = jcas_GetInteger(env,aMaxIndex);
698 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
699 the_this->TypeBoundIndexs(the_aMinIndex,the_aMaxIndex);
700 jcas_SetInteger(env,aMinIndex,the_aMinIndex);
701 jcas_SetInteger(env,aMaxIndex,the_aMaxIndex);
702
703 }
704 catch (Standard_Failure) {
705   Standard_SStream Err;
706   Err <<   Standard_Failure::Caught(); 
707   Err << (char) 0;
708   jcas_ThrowException(env,Err.str().c_str());
709 }
710 }
711 alock.Release();
712
713 }
714
715
716
717 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_LocalTypeIndex (JNIEnv *env, jobject theobj, jint anIndex)
718 {
719 jint thejret;
720
721 jcas_Locking alock(env);
722 {
723 try {
724 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
725  thejret = the_this->LocalTypeIndex((Standard_Integer) anIndex);
726
727 }
728 catch (Standard_Failure) {
729   Standard_SStream Err;
730   Err <<   Standard_Failure::Caught(); 
731   Err << (char) 0;
732   jcas_ThrowException(env,Err.str().c_str());
733 }
734 }
735 alock.Release();
736 return thejret;
737 }
738
739
740
741 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_WidthBoundIndexs (JNIEnv *env, jobject theobj, jobject aMinIndex, jobject aMaxIndex)
742 {
743
744 jcas_Locking alock(env);
745 {
746 try {
747 Standard_Integer the_aMinIndex = jcas_GetInteger(env,aMinIndex);
748 Standard_Integer the_aMaxIndex = jcas_GetInteger(env,aMaxIndex);
749 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
750 the_this->WidthBoundIndexs(the_aMinIndex,the_aMaxIndex);
751 jcas_SetInteger(env,aMinIndex,the_aMinIndex);
752 jcas_SetInteger(env,aMaxIndex,the_aMaxIndex);
753
754 }
755 catch (Standard_Failure) {
756   Standard_SStream Err;
757   Err <<   Standard_Failure::Caught(); 
758   Err << (char) 0;
759   jcas_ThrowException(env,Err.str().c_str());
760 }
761 }
762 alock.Release();
763
764 }
765
766
767
768 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_LocalWidthIndex (JNIEnv *env, jobject theobj, jint anIndex)
769 {
770 jint thejret;
771
772 jcas_Locking alock(env);
773 {
774 try {
775 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
776  thejret = the_this->LocalWidthIndex((Standard_Integer) anIndex);
777
778 }
779 catch (Standard_Failure) {
780   Standard_SStream Err;
781   Err <<   Standard_Failure::Caught(); 
782   Err << (char) 0;
783   jcas_ThrowException(env,Err.str().c_str());
784 }
785 }
786 alock.Release();
787 return thejret;
788 }
789
790
791
792 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_MarkBoundIndexs (JNIEnv *env, jobject theobj, jobject aMinIndex, jobject aMaxIndex)
793 {
794
795 jcas_Locking alock(env);
796 {
797 try {
798 Standard_Integer the_aMinIndex = jcas_GetInteger(env,aMinIndex);
799 Standard_Integer the_aMaxIndex = jcas_GetInteger(env,aMaxIndex);
800 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
801 the_this->MarkBoundIndexs(the_aMinIndex,the_aMaxIndex);
802 jcas_SetInteger(env,aMinIndex,the_aMinIndex);
803 jcas_SetInteger(env,aMaxIndex,the_aMaxIndex);
804
805 }
806 catch (Standard_Failure) {
807   Standard_SStream Err;
808   Err <<   Standard_Failure::Caught(); 
809   Err << (char) 0;
810   jcas_ThrowException(env,Err.str().c_str());
811 }
812 }
813 alock.Release();
814
815 }
816
817
818
819 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1WindowDriver_LocalMarkIndex (JNIEnv *env, jobject theobj, jint anIndex)
820 {
821 jint thejret;
822
823 jcas_Locking alock(env);
824 {
825 try {
826 Handle(Aspect_WindowDriver) the_this = *((Handle(Aspect_WindowDriver)*) jcas_GetHandle(env,theobj));
827  thejret = the_this->LocalMarkIndex((Standard_Integer) anIndex);
828
829 }
830 catch (Standard_Failure) {
831   Standard_SStream Err;
832   Err <<   Standard_Failure::Caught(); 
833   Err << (char) 0;
834   jcas_ThrowException(env,Err.str().c_str());
835 }
836 }
837 alock.Release();
838 return thejret;
839 }
840
841
842 }