Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / SampleHLRJni / SampleHLRJni_Aspect_FontStyle_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_FontStyle.h>
22 #include <Aspect_FontStyle.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_TypeOfFont.hxx>
30 #include <Standard_Real.hxx>
31 #include <Standard_Boolean.hxx>
32 #include <Standard_CString.hxx>
33 #include <Standard_Integer.hxx>
34
35
36 extern "C" {
37
38
39 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1Create_11 (JNIEnv *env, jobject theobj)
40 {
41
42 jcas_Locking alock(env);
43 {
44 try {
45 Aspect_FontStyle* theret = new Aspect_FontStyle();
46 jcas_SetHandle(env,theobj,theret);
47
48 }
49 catch (Standard_Failure) {
50   Standard_SStream Err;
51   Err <<   Standard_Failure::Caught(); 
52   Err << (char) 0;
53   jcas_ThrowException(env,Err.str().c_str());
54 }
55 }
56 alock.Release();
57
58 }
59
60
61
62 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1Create_12 (JNIEnv *env, jobject theobj, jshort Type, jdouble Size, jdouble Slant, jboolean CapsHeight)
63 {
64
65 jcas_Locking alock(env);
66 {
67 try {
68 Aspect_FontStyle* theret = new Aspect_FontStyle((Aspect_TypeOfFont) Type,(Quantity_Length) Size,(Quantity_PlaneAngle) Slant,(Standard_Boolean) CapsHeight);
69 jcas_SetHandle(env,theobj,theret);
70
71 }
72 catch (Standard_Failure) {
73   Standard_SStream Err;
74   Err <<   Standard_Failure::Caught(); 
75   Err << (char) 0;
76   jcas_ThrowException(env,Err.str().c_str());
77 }
78 }
79 alock.Release();
80
81 }
82
83
84
85 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1Create_13 (JNIEnv *env, jobject theobj, jobject Style, jdouble Size, jdouble Slant, jboolean CapsHeight)
86 {
87
88 jcas_Locking alock(env);
89 {
90 try {
91 Standard_CString the_Style = jcas_ConvertToCString(env,Style);
92 Aspect_FontStyle* theret = new Aspect_FontStyle(the_Style,(Quantity_Length) Size,(Quantity_PlaneAngle) Slant,(Standard_Boolean) CapsHeight);
93 jcas_SetHandle(env,theobj,theret);
94
95 }
96 catch (Standard_Failure) {
97   Standard_SStream Err;
98   Err <<   Standard_Failure::Caught(); 
99   Err << (char) 0;
100   jcas_ThrowException(env,Err.str().c_str());
101 }
102 }
103 alock.Release();
104
105 }
106
107
108
109 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1Create_14 (JNIEnv *env, jobject theobj, jobject Style)
110 {
111
112 jcas_Locking alock(env);
113 {
114 try {
115 Standard_CString the_Style = jcas_ConvertToCString(env,Style);
116 Aspect_FontStyle* theret = new Aspect_FontStyle(the_Style);
117 jcas_SetHandle(env,theobj,theret);
118
119 }
120 catch (Standard_Failure) {
121   Standard_SStream Err;
122   Err <<   Standard_Failure::Caught(); 
123   Err << (char) 0;
124   jcas_ThrowException(env,Err.str().c_str());
125 }
126 }
127 alock.Release();
128
129 }
130
131
132
133 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Assign (JNIEnv *env, jobject theobj, jobject Other)
134 {
135 jobject thejret;
136
137 jcas_Locking alock(env);
138 {
139 try {
140 Aspect_FontStyle* the_Other = (Aspect_FontStyle*) jcas_GetHandle(env,Other);
141 if ( the_Other == NULL ) {
142
143  // The following assumes availability of the default constructor (what may not
144  // always be the case). Therefore explicit exception is thrown if the null
145  // object has been passed.
146  // the_Other = new Aspect_FontStyle ();
147  // jcas_SetHandle ( env, Other, the_Other );
148  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
149
150 }  // end if
151 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
152 const Aspect_FontStyle& theret = the_this->Assign(*the_Other);
153 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_FontStyle",&theret,0);
154
155 }
156 catch (Standard_Failure) {
157   Standard_SStream Err;
158   Err <<   Standard_Failure::Caught(); 
159   Err << (char) 0;
160   jcas_ThrowException(env,Err.str().c_str());
161 }
162 }
163 alock.Release();
164 return thejret;
165 }
166
167
168
169 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1SetValues_11 (JNIEnv *env, jobject theobj, jshort Type, jdouble Size, jdouble Slant, jboolean CapsHeight)
170 {
171
172 jcas_Locking alock(env);
173 {
174 try {
175 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
176 the_this->SetValues((Aspect_TypeOfFont) Type,(Quantity_Length) Size,(Quantity_PlaneAngle) Slant,(Standard_Boolean) CapsHeight);
177
178 }
179 catch (Standard_Failure) {
180   Standard_SStream Err;
181   Err <<   Standard_Failure::Caught(); 
182   Err << (char) 0;
183   jcas_ThrowException(env,Err.str().c_str());
184 }
185 }
186 alock.Release();
187
188 }
189
190
191
192 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1SetValues_12 (JNIEnv *env, jobject theobj, jobject Style, jdouble Size, jdouble Slant, jboolean CapsHeight)
193 {
194
195 jcas_Locking alock(env);
196 {
197 try {
198 Standard_CString the_Style = jcas_ConvertToCString(env,Style);
199 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
200 the_this->SetValues(the_Style,(Quantity_Length) Size,(Quantity_PlaneAngle) Slant,(Standard_Boolean) CapsHeight);
201
202 }
203 catch (Standard_Failure) {
204   Standard_SStream Err;
205   Err <<   Standard_Failure::Caught(); 
206   Err << (char) 0;
207   jcas_ThrowException(env,Err.str().c_str());
208 }
209 }
210 alock.Release();
211
212 }
213
214
215
216 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Aspect_1FontStyle_1SetValues_13 (JNIEnv *env, jobject theobj, jobject Style)
217 {
218
219 jcas_Locking alock(env);
220 {
221 try {
222 Standard_CString the_Style = jcas_ConvertToCString(env,Style);
223 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
224 the_this->SetValues(the_Style);
225
226 }
227 catch (Standard_Failure) {
228   Standard_SStream Err;
229   Err <<   Standard_Failure::Caught(); 
230   Err << (char) 0;
231   jcas_ThrowException(env,Err.str().c_str());
232 }
233 }
234 alock.Release();
235
236 }
237
238
239
240 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SetFamily (JNIEnv *env, jobject theobj, jobject aName)
241 {
242
243 jcas_Locking alock(env);
244 {
245 try {
246 Standard_CString the_aName = jcas_ConvertToCString(env,aName);
247 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
248 the_this->SetFamily(the_aName);
249
250 }
251 catch (Standard_Failure) {
252   Standard_SStream Err;
253   Err <<   Standard_Failure::Caught(); 
254   Err << (char) 0;
255   jcas_ThrowException(env,Err.str().c_str());
256 }
257 }
258 alock.Release();
259
260 }
261
262
263
264 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SetWeight (JNIEnv *env, jobject theobj, jobject aName)
265 {
266
267 jcas_Locking alock(env);
268 {
269 try {
270 Standard_CString the_aName = jcas_ConvertToCString(env,aName);
271 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
272 the_this->SetWeight(the_aName);
273
274 }
275 catch (Standard_Failure) {
276   Standard_SStream Err;
277   Err <<   Standard_Failure::Caught(); 
278   Err << (char) 0;
279   jcas_ThrowException(env,Err.str().c_str());
280 }
281 }
282 alock.Release();
283
284 }
285
286
287
288 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SetRegistry (JNIEnv *env, jobject theobj, jobject aName)
289 {
290
291 jcas_Locking alock(env);
292 {
293 try {
294 Standard_CString the_aName = jcas_ConvertToCString(env,aName);
295 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
296 the_this->SetRegistry(the_aName);
297
298 }
299 catch (Standard_Failure) {
300   Standard_SStream Err;
301   Err <<   Standard_Failure::Caught(); 
302   Err << (char) 0;
303   jcas_ThrowException(env,Err.str().c_str());
304 }
305 }
306 alock.Release();
307
308 }
309
310
311
312 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SetEncoding (JNIEnv *env, jobject theobj, jobject aName)
313 {
314
315 jcas_Locking alock(env);
316 {
317 try {
318 Standard_CString the_aName = jcas_ConvertToCString(env,aName);
319 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
320 the_this->SetEncoding(the_aName);
321
322 }
323 catch (Standard_Failure) {
324   Standard_SStream Err;
325   Err <<   Standard_Failure::Caught(); 
326   Err << (char) 0;
327   jcas_ThrowException(env,Err.str().c_str());
328 }
329 }
330 alock.Release();
331
332 }
333
334
335
336 JNIEXPORT jshort JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Style (JNIEnv *env, jobject theobj)
337 {
338 jshort thejret;
339
340 jcas_Locking alock(env);
341 {
342 try {
343 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
344  thejret = the_this->Style();
345
346 }
347 catch (Standard_Failure) {
348   Standard_SStream Err;
349   Err <<   Standard_Failure::Caught(); 
350   Err << (char) 0;
351   jcas_ThrowException(env,Err.str().c_str());
352 }
353 }
354 alock.Release();
355 return thejret;
356 }
357
358
359
360 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Length (JNIEnv *env, jobject theobj)
361 {
362 jint thejret;
363
364 jcas_Locking alock(env);
365 {
366 try {
367 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
368  thejret = the_this->Length();
369
370 }
371 catch (Standard_Failure) {
372   Standard_SStream Err;
373   Err <<   Standard_Failure::Caught(); 
374   Err << (char) 0;
375   jcas_ThrowException(env,Err.str().c_str());
376 }
377 }
378 alock.Release();
379 return thejret;
380 }
381
382
383
384 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Value (JNIEnv *env, jobject theobj)
385 {
386 jobject thejret;
387
388 jcas_Locking alock(env);
389 {
390 try {
391 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
392 Standard_CString sret = the_this->Value();
393 jclass CLSret  = env->FindClass("jcas/Standard_CString");
394 thejret = env->AllocObject(CLSret);
395 jcas_SetCStringValue(env,thejret,sret);
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 jdouble JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Size (JNIEnv *env, jobject theobj)
412 {
413 jdouble thejret;
414
415 jcas_Locking alock(env);
416 {
417 try {
418 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
419  thejret = the_this->Size();
420
421 }
422 catch (Standard_Failure) {
423   Standard_SStream Err;
424   Err <<   Standard_Failure::Caught(); 
425   Err << (char) 0;
426   jcas_ThrowException(env,Err.str().c_str());
427 }
428 }
429 alock.Release();
430 return thejret;
431 }
432
433
434
435 JNIEXPORT jdouble JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Slant (JNIEnv *env, jobject theobj)
436 {
437 jdouble thejret;
438
439 jcas_Locking alock(env);
440 {
441 try {
442 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
443  thejret = the_this->Slant();
444
445 }
446 catch (Standard_Failure) {
447   Standard_SStream Err;
448   Err <<   Standard_Failure::Caught(); 
449   Err << (char) 0;
450   jcas_ThrowException(env,Err.str().c_str());
451 }
452 }
453 alock.Release();
454 return thejret;
455 }
456
457
458
459 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1FontStyle_CapsHeight (JNIEnv *env, jobject theobj)
460 {
461 jboolean thejret;
462
463 jcas_Locking alock(env);
464 {
465 try {
466 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
467  thejret = the_this->CapsHeight();
468
469 }
470 catch (Standard_Failure) {
471   Standard_SStream Err;
472   Err <<   Standard_Failure::Caught(); 
473   Err << (char) 0;
474   jcas_ThrowException(env,Err.str().c_str());
475 }
476 }
477 alock.Release();
478 return thejret;
479 }
480
481
482
483 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_AliasName (JNIEnv *env, jobject theobj)
484 {
485 jobject thejret;
486
487 jcas_Locking alock(env);
488 {
489 try {
490 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
491 Standard_CString sret = the_this->AliasName();
492 jclass CLSret  = env->FindClass("jcas/Standard_CString");
493 thejret = env->AllocObject(CLSret);
494 jcas_SetCStringValue(env,thejret,sret);
495
496 }
497 catch (Standard_Failure) {
498   Standard_SStream Err;
499   Err <<   Standard_Failure::Caught(); 
500   Err << (char) 0;
501   jcas_ThrowException(env,Err.str().c_str());
502 }
503 }
504 alock.Release();
505 return thejret;
506 }
507
508
509
510 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_FullName (JNIEnv *env, jobject theobj)
511 {
512 jobject thejret;
513
514 jcas_Locking alock(env);
515 {
516 try {
517 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
518 Standard_CString sret = the_this->FullName();
519 jclass CLSret  = env->FindClass("jcas/Standard_CString");
520 thejret = env->AllocObject(CLSret);
521 jcas_SetCStringValue(env,thejret,sret);
522
523 }
524 catch (Standard_Failure) {
525   Standard_SStream Err;
526   Err <<   Standard_Failure::Caught(); 
527   Err << (char) 0;
528   jcas_ThrowException(env,Err.str().c_str());
529 }
530 }
531 alock.Release();
532 return thejret;
533 }
534
535
536
537 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Foundry (JNIEnv *env, jobject theobj)
538 {
539 jobject thejret;
540
541 jcas_Locking alock(env);
542 {
543 try {
544 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
545 Standard_CString sret = the_this->Foundry();
546 jclass CLSret  = env->FindClass("jcas/Standard_CString");
547 thejret = env->AllocObject(CLSret);
548 jcas_SetCStringValue(env,thejret,sret);
549
550 }
551 catch (Standard_Failure) {
552   Standard_SStream Err;
553   Err <<   Standard_Failure::Caught(); 
554   Err << (char) 0;
555   jcas_ThrowException(env,Err.str().c_str());
556 }
557 }
558 alock.Release();
559 return thejret;
560 }
561
562
563
564 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Family (JNIEnv *env, jobject theobj)
565 {
566 jobject thejret;
567
568 jcas_Locking alock(env);
569 {
570 try {
571 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
572 Standard_CString sret = the_this->Family();
573 jclass CLSret  = env->FindClass("jcas/Standard_CString");
574 thejret = env->AllocObject(CLSret);
575 jcas_SetCStringValue(env,thejret,sret);
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_1FontStyle_Weight (JNIEnv *env, jobject theobj)
592 {
593 jobject thejret;
594
595 jcas_Locking alock(env);
596 {
597 try {
598 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
599 Standard_CString sret = the_this->Weight();
600 jclass CLSret  = env->FindClass("jcas/Standard_CString");
601 thejret = env->AllocObject(CLSret);
602 jcas_SetCStringValue(env,thejret,sret);
603
604 }
605 catch (Standard_Failure) {
606   Standard_SStream Err;
607   Err <<   Standard_Failure::Caught(); 
608   Err << (char) 0;
609   jcas_ThrowException(env,Err.str().c_str());
610 }
611 }
612 alock.Release();
613 return thejret;
614 }
615
616
617
618 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Registry (JNIEnv *env, jobject theobj)
619 {
620 jobject thejret;
621
622 jcas_Locking alock(env);
623 {
624 try {
625 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
626 Standard_CString sret = the_this->Registry();
627 jclass CLSret  = env->FindClass("jcas/Standard_CString");
628 thejret = env->AllocObject(CLSret);
629 jcas_SetCStringValue(env,thejret,sret);
630
631 }
632 catch (Standard_Failure) {
633   Standard_SStream Err;
634   Err <<   Standard_Failure::Caught(); 
635   Err << (char) 0;
636   jcas_ThrowException(env,Err.str().c_str());
637 }
638 }
639 alock.Release();
640 return thejret;
641 }
642
643
644
645 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Encoding (JNIEnv *env, jobject theobj)
646 {
647 jobject thejret;
648
649 jcas_Locking alock(env);
650 {
651 try {
652 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
653 Standard_CString sret = the_this->Encoding();
654 jclass CLSret  = env->FindClass("jcas/Standard_CString");
655 thejret = env->AllocObject(CLSret);
656 jcas_SetCStringValue(env,thejret,sret);
657
658 }
659 catch (Standard_Failure) {
660   Standard_SStream Err;
661   Err <<   Standard_Failure::Caught(); 
662   Err << (char) 0;
663   jcas_ThrowException(env,Err.str().c_str());
664 }
665 }
666 alock.Release();
667 return thejret;
668 }
669
670
671
672 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SSlant (JNIEnv *env, jobject theobj)
673 {
674 jobject thejret;
675
676 jcas_Locking alock(env);
677 {
678 try {
679 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
680 Standard_CString sret = the_this->SSlant();
681 jclass CLSret  = env->FindClass("jcas/Standard_CString");
682 thejret = env->AllocObject(CLSret);
683 jcas_SetCStringValue(env,thejret,sret);
684
685 }
686 catch (Standard_Failure) {
687   Standard_SStream Err;
688   Err <<   Standard_Failure::Caught(); 
689   Err << (char) 0;
690   jcas_ThrowException(env,Err.str().c_str());
691 }
692 }
693 alock.Release();
694 return thejret;
695 }
696
697
698
699 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SWidth (JNIEnv *env, jobject theobj)
700 {
701 jobject thejret;
702
703 jcas_Locking alock(env);
704 {
705 try {
706 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
707 Standard_CString sret = the_this->SWidth();
708 jclass CLSret  = env->FindClass("jcas/Standard_CString");
709 thejret = env->AllocObject(CLSret);
710 jcas_SetCStringValue(env,thejret,sret);
711
712 }
713 catch (Standard_Failure) {
714   Standard_SStream Err;
715   Err <<   Standard_Failure::Caught(); 
716   Err << (char) 0;
717   jcas_ThrowException(env,Err.str().c_str());
718 }
719 }
720 alock.Release();
721 return thejret;
722 }
723
724
725
726 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SStyle (JNIEnv *env, jobject theobj)
727 {
728 jobject thejret;
729
730 jcas_Locking alock(env);
731 {
732 try {
733 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
734 Standard_CString sret = the_this->SStyle();
735 jclass CLSret  = env->FindClass("jcas/Standard_CString");
736 thejret = env->AllocObject(CLSret);
737 jcas_SetCStringValue(env,thejret,sret);
738
739 }
740 catch (Standard_Failure) {
741   Standard_SStream Err;
742   Err <<   Standard_Failure::Caught(); 
743   Err << (char) 0;
744   jcas_ThrowException(env,Err.str().c_str());
745 }
746 }
747 alock.Release();
748 return thejret;
749 }
750
751
752
753 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SPixelSize (JNIEnv *env, jobject theobj)
754 {
755 jobject thejret;
756
757 jcas_Locking alock(env);
758 {
759 try {
760 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
761 Standard_CString sret = the_this->SPixelSize();
762 jclass CLSret  = env->FindClass("jcas/Standard_CString");
763 thejret = env->AllocObject(CLSret);
764 jcas_SetCStringValue(env,thejret,sret);
765
766 }
767 catch (Standard_Failure) {
768   Standard_SStream Err;
769   Err <<   Standard_Failure::Caught(); 
770   Err << (char) 0;
771   jcas_ThrowException(env,Err.str().c_str());
772 }
773 }
774 alock.Release();
775 return thejret;
776 }
777
778
779
780 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SPointSize (JNIEnv *env, jobject theobj)
781 {
782 jobject thejret;
783
784 jcas_Locking alock(env);
785 {
786 try {
787 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
788 Standard_CString sret = the_this->SPointSize();
789 jclass CLSret  = env->FindClass("jcas/Standard_CString");
790 thejret = env->AllocObject(CLSret);
791 jcas_SetCStringValue(env,thejret,sret);
792
793 }
794 catch (Standard_Failure) {
795   Standard_SStream Err;
796   Err <<   Standard_Failure::Caught(); 
797   Err << (char) 0;
798   jcas_ThrowException(env,Err.str().c_str());
799 }
800 }
801 alock.Release();
802 return thejret;
803 }
804
805
806
807 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SResolutionX (JNIEnv *env, jobject theobj)
808 {
809 jobject thejret;
810
811 jcas_Locking alock(env);
812 {
813 try {
814 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
815 Standard_CString sret = the_this->SResolutionX();
816 jclass CLSret  = env->FindClass("jcas/Standard_CString");
817 thejret = env->AllocObject(CLSret);
818 jcas_SetCStringValue(env,thejret,sret);
819
820 }
821 catch (Standard_Failure) {
822   Standard_SStream Err;
823   Err <<   Standard_Failure::Caught(); 
824   Err << (char) 0;
825   jcas_ThrowException(env,Err.str().c_str());
826 }
827 }
828 alock.Release();
829 return thejret;
830 }
831
832
833
834 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SResolutionY (JNIEnv *env, jobject theobj)
835 {
836 jobject thejret;
837
838 jcas_Locking alock(env);
839 {
840 try {
841 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
842 Standard_CString sret = the_this->SResolutionY();
843 jclass CLSret  = env->FindClass("jcas/Standard_CString");
844 thejret = env->AllocObject(CLSret);
845 jcas_SetCStringValue(env,thejret,sret);
846
847 }
848 catch (Standard_Failure) {
849   Standard_SStream Err;
850   Err <<   Standard_Failure::Caught(); 
851   Err << (char) 0;
852   jcas_ThrowException(env,Err.str().c_str());
853 }
854 }
855 alock.Release();
856 return thejret;
857 }
858
859
860
861 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SSpacing (JNIEnv *env, jobject theobj)
862 {
863 jobject thejret;
864
865 jcas_Locking alock(env);
866 {
867 try {
868 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
869 Standard_CString sret = the_this->SSpacing();
870 jclass CLSret  = env->FindClass("jcas/Standard_CString");
871 thejret = env->AllocObject(CLSret);
872 jcas_SetCStringValue(env,thejret,sret);
873
874 }
875 catch (Standard_Failure) {
876   Standard_SStream Err;
877   Err <<   Standard_Failure::Caught(); 
878   Err << (char) 0;
879   jcas_ThrowException(env,Err.str().c_str());
880 }
881 }
882 alock.Release();
883 return thejret;
884 }
885
886
887
888 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1FontStyle_SAverageWidth (JNIEnv *env, jobject theobj)
889 {
890 jobject thejret;
891
892 jcas_Locking alock(env);
893 {
894 try {
895 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
896 Standard_CString sret = the_this->SAverageWidth();
897 jclass CLSret  = env->FindClass("jcas/Standard_CString");
898 thejret = env->AllocObject(CLSret);
899 jcas_SetCStringValue(env,thejret,sret);
900
901 }
902 catch (Standard_Failure) {
903   Standard_SStream Err;
904   Err <<   Standard_Failure::Caught(); 
905   Err << (char) 0;
906   jcas_ThrowException(env,Err.str().c_str());
907 }
908 }
909 alock.Release();
910 return thejret;
911 }
912
913
914
915 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_Dump (JNIEnv *env, jobject theobj)
916 {
917
918 jcas_Locking alock(env);
919 {
920 try {
921 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
922 the_this->Dump();
923
924 }
925 catch (Standard_Failure) {
926   Standard_SStream Err;
927   Err <<   Standard_Failure::Caught(); 
928   Err << (char) 0;
929   jcas_ThrowException(env,Err.str().c_str());
930 }
931 }
932 alock.Release();
933
934 }
935
936
937
938 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1FontStyle_IsEqual (JNIEnv *env, jobject theobj, jobject Other)
939 {
940 jboolean thejret;
941
942 jcas_Locking alock(env);
943 {
944 try {
945 Aspect_FontStyle* the_Other = (Aspect_FontStyle*) jcas_GetHandle(env,Other);
946 if ( the_Other == NULL ) {
947
948  // The following assumes availability of the default constructor (what may not
949  // always be the case). Therefore explicit exception is thrown if the null
950  // object has been passed.
951  // the_Other = new Aspect_FontStyle ();
952  // jcas_SetHandle ( env, Other, the_Other );
953  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
954
955 }  // end if
956 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
957  thejret = the_this->IsEqual(*the_Other);
958
959 }
960 catch (Standard_Failure) {
961   Standard_SStream Err;
962   Err <<   Standard_Failure::Caught(); 
963   Err << (char) 0;
964   jcas_ThrowException(env,Err.str().c_str());
965 }
966 }
967 alock.Release();
968 return thejret;
969 }
970
971
972
973 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1FontStyle_IsNotEqual (JNIEnv *env, jobject theobj, jobject Other)
974 {
975 jboolean thejret;
976
977 jcas_Locking alock(env);
978 {
979 try {
980 Aspect_FontStyle* the_Other = (Aspect_FontStyle*) jcas_GetHandle(env,Other);
981 if ( the_Other == NULL ) {
982
983  // The following assumes availability of the default constructor (what may not
984  // always be the case). Therefore explicit exception is thrown if the null
985  // object has been passed.
986  // the_Other = new Aspect_FontStyle ();
987  // jcas_SetHandle ( env, Other, the_Other );
988  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
989
990 }  // end if
991 Aspect_FontStyle* the_this = (Aspect_FontStyle*) jcas_GetHandle(env,theobj);
992  thejret = the_this->IsNotEqual(*the_Other);
993
994 }
995 catch (Standard_Failure) {
996   Standard_SStream Err;
997   Err <<   Standard_Failure::Caught(); 
998   Err << (char) 0;
999   jcas_ThrowException(env,Err.str().c_str());
1000 }
1001 }
1002 alock.Release();
1003 return thejret;
1004 }
1005
1006
1007
1008 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1FontStyle_FinalizeValue(JNIEnv *, jclass, jlong theid)
1009 {
1010 if (theid) {
1011   Aspect_FontStyle* theobj = (Aspect_FontStyle*) theid;
1012   delete theobj;
1013 }
1014 }
1015
1016
1017 }