Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / SampleHLRJni / SampleHLRJni_Aspect_Driver_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_Driver.h>
22 #include <Aspect_Driver.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 <Aspect_ColorMap.hxx>
31 #include <Aspect_TypeMap.hxx>
32 #include <Aspect_WidthMap.hxx>
33 #include <Aspect_FontMap.hxx>
34 #include <Aspect_MarkMap.hxx>
35 #include <Standard_Integer.hxx>
36 #include <Standard_Real.hxx>
37 #include <Standard_Transient.hxx>
38 #include <Standard_CString.hxx>
39 #include <Standard_ShortReal.hxx>
40 #include <TShort_Array1OfShortReal.hxx>
41 #include <TCollection_ExtendedString.hxx>
42 #include <Aspect_TypeOfText.hxx>
43
44
45 extern "C" {
46
47
48 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_EndDraw (JNIEnv *env, jobject theobj, jboolean Synchronize)
49 {
50
51 jcas_Locking alock(env);
52 {
53 try {
54 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
55 the_this->EndDraw((Standard_Boolean) Synchronize);
56
57 }
58 catch (Standard_Failure) {
59   Standard_SStream Err;
60   Err <<   Standard_Failure::Caught(); 
61   Err << (char) 0;
62   jcas_ThrowException(env,Err.str().c_str());
63 }
64 }
65 alock.Release();
66
67 }
68
69
70
71 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetColorMap (JNIEnv *env, jobject theobj, jobject aColorMap)
72 {
73
74 jcas_Locking alock(env);
75 {
76 try {
77  Handle( Aspect_ColorMap ) the_aColorMap;
78  void*                ptr_aColorMap = jcas_GetHandle(env,aColorMap);
79  
80  if ( ptr_aColorMap != NULL ) the_aColorMap = *(   (  Handle( Aspect_ColorMap )*  )ptr_aColorMap   );
81
82 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
83 the_this->SetColorMap(the_aColorMap);
84
85 }
86 catch (Standard_Failure) {
87   Standard_SStream Err;
88   Err <<   Standard_Failure::Caught(); 
89   Err << (char) 0;
90   jcas_ThrowException(env,Err.str().c_str());
91 }
92 }
93 alock.Release();
94
95 }
96
97
98
99 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetTypeMap (JNIEnv *env, jobject theobj, jobject aTypeMap)
100 {
101
102 jcas_Locking alock(env);
103 {
104 try {
105  Handle( Aspect_TypeMap ) the_aTypeMap;
106  void*                ptr_aTypeMap = jcas_GetHandle(env,aTypeMap);
107  
108  if ( ptr_aTypeMap != NULL ) the_aTypeMap = *(   (  Handle( Aspect_TypeMap )*  )ptr_aTypeMap   );
109
110 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
111 the_this->SetTypeMap(the_aTypeMap);
112
113 }
114 catch (Standard_Failure) {
115   Standard_SStream Err;
116   Err <<   Standard_Failure::Caught(); 
117   Err << (char) 0;
118   jcas_ThrowException(env,Err.str().c_str());
119 }
120 }
121 alock.Release();
122
123 }
124
125
126
127 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetWidthMap (JNIEnv *env, jobject theobj, jobject aWidthMap)
128 {
129
130 jcas_Locking alock(env);
131 {
132 try {
133  Handle( Aspect_WidthMap ) the_aWidthMap;
134  void*                ptr_aWidthMap = jcas_GetHandle(env,aWidthMap);
135  
136  if ( ptr_aWidthMap != NULL ) the_aWidthMap = *(   (  Handle( Aspect_WidthMap )*  )ptr_aWidthMap   );
137
138 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
139 the_this->SetWidthMap(the_aWidthMap);
140
141 }
142 catch (Standard_Failure) {
143   Standard_SStream Err;
144   Err <<   Standard_Failure::Caught(); 
145   Err << (char) 0;
146   jcas_ThrowException(env,Err.str().c_str());
147 }
148 }
149 alock.Release();
150
151 }
152
153
154
155 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetFontMap (JNIEnv *env, jobject theobj, jobject aFontMap, jboolean useMFT)
156 {
157
158 jcas_Locking alock(env);
159 {
160 try {
161  Handle( Aspect_FontMap ) the_aFontMap;
162  void*                ptr_aFontMap = jcas_GetHandle(env,aFontMap);
163  
164  if ( ptr_aFontMap != NULL ) the_aFontMap = *(   (  Handle( Aspect_FontMap )*  )ptr_aFontMap   );
165
166 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
167 the_this->SetFontMap(the_aFontMap,(Standard_Boolean) useMFT);
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_1Driver_SetMarkMap (JNIEnv *env, jobject theobj, jobject aMarkMap)
184 {
185
186 jcas_Locking alock(env);
187 {
188 try {
189  Handle( Aspect_MarkMap ) the_aMarkMap;
190  void*                ptr_aMarkMap = jcas_GetHandle(env,aMarkMap);
191  
192  if ( ptr_aMarkMap != NULL ) the_aMarkMap = *(   (  Handle( Aspect_MarkMap )*  )ptr_aMarkMap   );
193
194 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
195 the_this->SetMarkMap(the_aMarkMap);
196
197 }
198 catch (Standard_Failure) {
199   Standard_SStream Err;
200   Err <<   Standard_Failure::Caught(); 
201   Err << (char) 0;
202   jcas_ThrowException(env,Err.str().c_str());
203 }
204 }
205 alock.Release();
206
207 }
208
209
210
211 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetLineAttrib (JNIEnv *env, jobject theobj, jint ColorIndex, jint TypeIndex, jint WidthIndex)
212 {
213
214 jcas_Locking alock(env);
215 {
216 try {
217 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
218 the_this->SetLineAttrib((Standard_Integer) ColorIndex,(Standard_Integer) TypeIndex,(Standard_Integer) WidthIndex);
219
220 }
221 catch (Standard_Failure) {
222   Standard_SStream Err;
223   Err <<   Standard_Failure::Caught(); 
224   Err << (char) 0;
225   jcas_ThrowException(env,Err.str().c_str());
226 }
227 }
228 alock.Release();
229
230 }
231
232
233
234 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1SetTextAttrib_11 (JNIEnv *env, jobject theobj, jint ColorIndex, jint FontIndex)
235 {
236
237 jcas_Locking alock(env);
238 {
239 try {
240 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
241 the_this->SetTextAttrib((Standard_Integer) ColorIndex,(Standard_Integer) FontIndex);
242
243 }
244 catch (Standard_Failure) {
245   Standard_SStream Err;
246   Err <<   Standard_Failure::Caught(); 
247   Err << (char) 0;
248   jcas_ThrowException(env,Err.str().c_str());
249 }
250 }
251 alock.Release();
252
253 }
254
255
256
257 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1SetTextAttrib_12 (JNIEnv *env, jobject theobj, jint ColorIndex, jint FontIndex, jdouble aSlant, jdouble aHScale, jdouble aWScale, jboolean isUnderlined)
258 {
259
260 jcas_Locking alock(env);
261 {
262 try {
263 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
264 the_this->SetTextAttrib((Standard_Integer) ColorIndex,(Standard_Integer) FontIndex,(Quantity_PlaneAngle) aSlant,(Quantity_Factor) aHScale,(Quantity_Factor) aWScale,(Standard_Boolean) isUnderlined);
265
266 }
267 catch (Standard_Failure) {
268   Standard_SStream Err;
269   Err <<   Standard_Failure::Caught(); 
270   Err << (char) 0;
271   jcas_ThrowException(env,Err.str().c_str());
272 }
273 }
274 alock.Release();
275
276 }
277
278
279
280 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetPolyAttrib (JNIEnv *env, jobject theobj, jint ColorIndex, jint TileIndex, jboolean DrawEdge)
281 {
282
283 jcas_Locking alock(env);
284 {
285 try {
286 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
287 the_this->SetPolyAttrib((Standard_Integer) ColorIndex,(Standard_Integer) TileIndex,(Standard_Boolean) DrawEdge);
288
289 }
290 catch (Standard_Failure) {
291   Standard_SStream Err;
292   Err <<   Standard_Failure::Caught(); 
293   Err << (char) 0;
294   jcas_ThrowException(env,Err.str().c_str());
295 }
296 }
297 alock.Release();
298
299 }
300
301
302
303 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_SetMarkerAttrib (JNIEnv *env, jobject theobj, jint ColorIndex, jint WidthIndex, jboolean FillMarker)
304 {
305
306 jcas_Locking alock(env);
307 {
308 try {
309 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
310 the_this->SetMarkerAttrib((Standard_Integer) ColorIndex,(Standard_Integer) WidthIndex,(Standard_Boolean) FillMarker);
311
312 }
313 catch (Standard_Failure) {
314   Standard_SStream Err;
315   Err <<   Standard_Failure::Caught(); 
316   Err << (char) 0;
317   jcas_ThrowException(env,Err.str().c_str());
318 }
319 }
320 alock.Release();
321
322 }
323
324
325
326 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Driver_IsKnownImage (JNIEnv *env, jobject theobj, jobject anImage)
327 {
328 jboolean thejret;
329
330 jcas_Locking alock(env);
331 {
332 try {
333  Handle( Standard_Transient ) the_anImage;
334  void*                ptr_anImage = jcas_GetHandle(env,anImage);
335  
336  if ( ptr_anImage != NULL ) the_anImage = *(   (  Handle( Standard_Transient )*  )ptr_anImage   );
337
338 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
339  thejret = the_this->IsKnownImage(the_anImage);
340
341 }
342 catch (Standard_Failure) {
343   Standard_SStream Err;
344   Err <<   Standard_Failure::Caught(); 
345   Err << (char) 0;
346   jcas_ThrowException(env,Err.str().c_str());
347 }
348 }
349 alock.Release();
350 return thejret;
351 }
352
353
354
355 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Driver_SizeOfImageFile (JNIEnv *env, jobject theobj, jobject anImageFile, jobject aWidth, jobject aHeight)
356 {
357 jboolean thejret;
358
359 jcas_Locking alock(env);
360 {
361 try {
362 Standard_CString the_anImageFile = jcas_ConvertToCString(env,anImageFile);
363 Standard_Integer the_aWidth = jcas_GetInteger(env,aWidth);
364 Standard_Integer the_aHeight = jcas_GetInteger(env,aHeight);
365 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
366  thejret = the_this->SizeOfImageFile(the_anImageFile,the_aWidth,the_aHeight);
367 jcas_SetInteger(env,aWidth,the_aWidth);
368 jcas_SetInteger(env,aHeight,the_aHeight);
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 void JNICALL Java_SampleHLRJni_Aspect_1Driver_ClearImage (JNIEnv *env, jobject theobj, jobject anImageId)
385 {
386
387 jcas_Locking alock(env);
388 {
389 try {
390  Handle( Standard_Transient ) the_anImageId;
391  void*                ptr_anImageId = jcas_GetHandle(env,anImageId);
392  
393  if ( ptr_anImageId != NULL ) the_anImageId = *(   (  Handle( Standard_Transient )*  )ptr_anImageId   );
394
395 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
396 the_this->ClearImage(the_anImageId);
397
398 }
399 catch (Standard_Failure) {
400   Standard_SStream Err;
401   Err <<   Standard_Failure::Caught(); 
402   Err << (char) 0;
403   jcas_ThrowException(env,Err.str().c_str());
404 }
405 }
406 alock.Release();
407
408 }
409
410
411
412 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_ClearImageFile (JNIEnv *env, jobject theobj, jobject anImageFile)
413 {
414
415 jcas_Locking alock(env);
416 {
417 try {
418 Standard_CString the_anImageFile = jcas_ConvertToCString(env,anImageFile);
419 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
420 the_this->ClearImageFile(the_anImageFile);
421
422 }
423 catch (Standard_Failure) {
424   Standard_SStream Err;
425   Err <<   Standard_Failure::Caught(); 
426   Err << (char) 0;
427   jcas_ThrowException(env,Err.str().c_str());
428 }
429 }
430 alock.Release();
431
432 }
433
434
435
436 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawImage (JNIEnv *env, jobject theobj, jobject anImageId, jfloat aX, jfloat aY)
437 {
438
439 jcas_Locking alock(env);
440 {
441 try {
442  Handle( Standard_Transient ) the_anImageId;
443  void*                ptr_anImageId = jcas_GetHandle(env,anImageId);
444  
445  if ( ptr_anImageId != NULL ) the_anImageId = *(   (  Handle( Standard_Transient )*  )ptr_anImageId   );
446
447 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
448 the_this->DrawImage(the_anImageId,(Standard_ShortReal) aX,(Standard_ShortReal) aY);
449
450 }
451 catch (Standard_Failure) {
452   Standard_SStream Err;
453   Err <<   Standard_Failure::Caught(); 
454   Err << (char) 0;
455   jcas_ThrowException(env,Err.str().c_str());
456 }
457 }
458 alock.Release();
459
460 }
461
462
463
464 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawImageFile (JNIEnv *env, jobject theobj, jobject anImageFile, jfloat aX, jfloat aY, jdouble aScale)
465 {
466
467 jcas_Locking alock(env);
468 {
469 try {
470 Standard_CString the_anImageFile = jcas_ConvertToCString(env,anImageFile);
471 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
472 the_this->DrawImageFile(the_anImageFile,(Standard_ShortReal) aX,(Standard_ShortReal) aY,(Quantity_Factor) aScale);
473
474 }
475 catch (Standard_Failure) {
476   Standard_SStream Err;
477   Err <<   Standard_Failure::Caught(); 
478   Err << (char) 0;
479   jcas_ThrowException(env,Err.str().c_str());
480 }
481 }
482 alock.Release();
483
484 }
485
486
487
488 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawPolyline (JNIEnv *env, jobject theobj, jobject aListX, jobject aListY)
489 {
490
491 jcas_Locking alock(env);
492 {
493 try {
494 TShort_Array1OfShortReal* the_aListX = (TShort_Array1OfShortReal*) jcas_GetHandle(env,aListX);
495 if ( the_aListX == NULL ) {
496
497  // The following assumes availability of the default constructor (what may not
498  // always be the case). Therefore explicit exception is thrown if the null
499  // object has been passed.
500  // the_aListX = new TShort_Array1OfShortReal ();
501  // jcas_SetHandle ( env, aListX, the_aListX );
502  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
503
504 }  // end if
505 TShort_Array1OfShortReal* the_aListY = (TShort_Array1OfShortReal*) jcas_GetHandle(env,aListY);
506 if ( the_aListY == NULL ) {
507
508  // The following assumes availability of the default constructor (what may not
509  // always be the case). Therefore explicit exception is thrown if the null
510  // object has been passed.
511  // the_aListY = new TShort_Array1OfShortReal ();
512  // jcas_SetHandle ( env, aListY, the_aListY );
513  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
514
515 }  // end if
516 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
517 the_this->DrawPolyline(*the_aListX,*the_aListY);
518
519 }
520 catch (Standard_Failure) {
521   Standard_SStream Err;
522   Err <<   Standard_Failure::Caught(); 
523   Err << (char) 0;
524   jcas_ThrowException(env,Err.str().c_str());
525 }
526 }
527 alock.Release();
528
529 }
530
531
532
533 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawPolygon (JNIEnv *env, jobject theobj, jobject aListX, jobject aListY)
534 {
535
536 jcas_Locking alock(env);
537 {
538 try {
539 TShort_Array1OfShortReal* the_aListX = (TShort_Array1OfShortReal*) jcas_GetHandle(env,aListX);
540 if ( the_aListX == NULL ) {
541
542  // The following assumes availability of the default constructor (what may not
543  // always be the case). Therefore explicit exception is thrown if the null
544  // object has been passed.
545  // the_aListX = new TShort_Array1OfShortReal ();
546  // jcas_SetHandle ( env, aListX, the_aListX );
547  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
548
549 }  // end if
550 TShort_Array1OfShortReal* the_aListY = (TShort_Array1OfShortReal*) jcas_GetHandle(env,aListY);
551 if ( the_aListY == NULL ) {
552
553  // The following assumes availability of the default constructor (what may not
554  // always be the case). Therefore explicit exception is thrown if the null
555  // object has been passed.
556  // the_aListY = new TShort_Array1OfShortReal ();
557  // jcas_SetHandle ( env, aListY, the_aListY );
558  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
559
560 }  // end if
561 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
562 the_this->DrawPolygon(*the_aListX,*the_aListY);
563
564 }
565 catch (Standard_Failure) {
566   Standard_SStream Err;
567   Err <<   Standard_Failure::Caught(); 
568   Err << (char) 0;
569   jcas_ThrowException(env,Err.str().c_str());
570 }
571 }
572 alock.Release();
573
574 }
575
576
577
578 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawSegment (JNIEnv *env, jobject theobj, jfloat X1, jfloat Y1, jfloat X2, jfloat Y2)
579 {
580
581 jcas_Locking alock(env);
582 {
583 try {
584 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
585 the_this->DrawSegment((Standard_ShortReal) X1,(Standard_ShortReal) Y1,(Standard_ShortReal) X2,(Standard_ShortReal) Y2);
586
587 }
588 catch (Standard_Failure) {
589   Standard_SStream Err;
590   Err <<   Standard_Failure::Caught(); 
591   Err << (char) 0;
592   jcas_ThrowException(env,Err.str().c_str());
593 }
594 }
595 alock.Release();
596
597 }
598
599
600
601 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawText (JNIEnv *env, jobject theobj, jobject aText, jfloat Xpos, jfloat Ypos, jfloat anAngle, jshort aType)
602 {
603
604 jcas_Locking alock(env);
605 {
606 try {
607 TCollection_ExtendedString* the_aText = (TCollection_ExtendedString*) jcas_GetHandle(env,aText);
608 if ( the_aText == NULL ) {
609
610  // The following assumes availability of the default constructor (what may not
611  // always be the case). Therefore explicit exception is thrown if the null
612  // object has been passed.
613  // the_aText = new TCollection_ExtendedString ();
614  // jcas_SetHandle ( env, aText, the_aText );
615  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
616
617 }  // end if
618 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
619 the_this->DrawText(*the_aText,(Standard_ShortReal) Xpos,(Standard_ShortReal) Ypos,(Standard_ShortReal) anAngle,(Aspect_TypeOfText) aType);
620
621 }
622 catch (Standard_Failure) {
623   Standard_SStream Err;
624   Err <<   Standard_Failure::Caught(); 
625   Err << (char) 0;
626   jcas_ThrowException(env,Err.str().c_str());
627 }
628 }
629 alock.Release();
630
631 }
632
633
634
635 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawPolyText (JNIEnv *env, jobject theobj, jobject aText, jfloat Xpos, jfloat Ypos, jdouble aMarge, jfloat anAngle, jshort aType)
636 {
637
638 jcas_Locking alock(env);
639 {
640 try {
641 TCollection_ExtendedString* the_aText = (TCollection_ExtendedString*) jcas_GetHandle(env,aText);
642 if ( the_aText == NULL ) {
643
644  // The following assumes availability of the default constructor (what may not
645  // always be the case). Therefore explicit exception is thrown if the null
646  // object has been passed.
647  // the_aText = new TCollection_ExtendedString ();
648  // jcas_SetHandle ( env, aText, the_aText );
649  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
650
651 }  // end if
652 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
653 the_this->DrawPolyText(*the_aText,(Standard_ShortReal) Xpos,(Standard_ShortReal) Ypos,(Quantity_Ratio) aMarge,(Standard_ShortReal) anAngle,(Aspect_TypeOfText) aType);
654
655 }
656 catch (Standard_Failure) {
657   Standard_SStream Err;
658   Err <<   Standard_Failure::Caught(); 
659   Err << (char) 0;
660   jcas_ThrowException(env,Err.str().c_str());
661 }
662 }
663 alock.Release();
664
665 }
666
667
668
669 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawPoint (JNIEnv *env, jobject theobj, jfloat X, jfloat Y)
670 {
671
672 jcas_Locking alock(env);
673 {
674 try {
675 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
676 the_this->DrawPoint((Standard_ShortReal) X,(Standard_ShortReal) Y);
677
678 }
679 catch (Standard_Failure) {
680   Standard_SStream Err;
681   Err <<   Standard_Failure::Caught(); 
682   Err << (char) 0;
683   jcas_ThrowException(env,Err.str().c_str());
684 }
685 }
686 alock.Release();
687
688 }
689
690
691
692 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawMarker (JNIEnv *env, jobject theobj, jint aMarker, jfloat Xpos, jfloat Ypos, jfloat Width, jfloat Height, jfloat Angle)
693 {
694
695 jcas_Locking alock(env);
696 {
697 try {
698 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
699 the_this->DrawMarker((Standard_Integer) aMarker,(Standard_ShortReal) Xpos,(Standard_ShortReal) Ypos,(Standard_ShortReal) Width,(Standard_ShortReal) Height,(Standard_ShortReal) Angle);
700
701 }
702 catch (Standard_Failure) {
703   Standard_SStream Err;
704   Err <<   Standard_Failure::Caught(); 
705   Err << (char) 0;
706   jcas_ThrowException(env,Err.str().c_str());
707 }
708 }
709 alock.Release();
710
711 }
712
713
714
715 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawArc (JNIEnv *env, jobject theobj, jfloat X, jfloat Y, jfloat anXradius, jfloat anYradius, jfloat aStartAngle, jfloat anOpenAngle)
716 {
717 jboolean thejret;
718
719 jcas_Locking alock(env);
720 {
721 try {
722 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
723  thejret = the_this->DrawArc((Standard_ShortReal) X,(Standard_ShortReal) Y,(Standard_ShortReal) anXradius,(Standard_ShortReal) anYradius,(Standard_ShortReal) aStartAngle,(Standard_ShortReal) anOpenAngle);
724
725 }
726 catch (Standard_Failure) {
727   Standard_SStream Err;
728   Err <<   Standard_Failure::Caught(); 
729   Err << (char) 0;
730   jcas_ThrowException(env,Err.str().c_str());
731 }
732 }
733 alock.Release();
734 return thejret;
735 }
736
737
738
739 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Driver_DrawPolyArc (JNIEnv *env, jobject theobj, jfloat X, jfloat Y, jfloat anXradius, jfloat anYradius, jfloat aStartAngle, jfloat anOpenAngle)
740 {
741 jboolean thejret;
742
743 jcas_Locking alock(env);
744 {
745 try {
746 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
747  thejret = the_this->DrawPolyArc((Standard_ShortReal) X,(Standard_ShortReal) Y,(Standard_ShortReal) anXradius,(Standard_ShortReal) anYradius,(Standard_ShortReal) aStartAngle,(Standard_ShortReal) anOpenAngle);
748
749 }
750 catch (Standard_Failure) {
751   Standard_SStream Err;
752   Err <<   Standard_Failure::Caught(); 
753   Err << (char) 0;
754   jcas_ThrowException(env,Err.str().c_str());
755 }
756 }
757 alock.Release();
758 return thejret;
759 }
760
761
762
763 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginPolyline (JNIEnv *env, jobject theobj, jint aNumber)
764 {
765
766 jcas_Locking alock(env);
767 {
768 try {
769 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
770 the_this->BeginPolyline((Standard_Integer) aNumber);
771
772 }
773 catch (Standard_Failure) {
774   Standard_SStream Err;
775   Err <<   Standard_Failure::Caught(); 
776   Err << (char) 0;
777   jcas_ThrowException(env,Err.str().c_str());
778 }
779 }
780 alock.Release();
781
782 }
783
784
785
786 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginPolygon (JNIEnv *env, jobject theobj, jint aNumber)
787 {
788
789 jcas_Locking alock(env);
790 {
791 try {
792 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
793 the_this->BeginPolygon((Standard_Integer) aNumber);
794
795 }
796 catch (Standard_Failure) {
797   Standard_SStream Err;
798   Err <<   Standard_Failure::Caught(); 
799   Err << (char) 0;
800   jcas_ThrowException(env,Err.str().c_str());
801 }
802 }
803 alock.Release();
804
805 }
806
807
808
809 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginSegments (JNIEnv *env, jobject theobj)
810 {
811
812 jcas_Locking alock(env);
813 {
814 try {
815 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
816 the_this->BeginSegments();
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
828 }
829
830
831
832 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginArcs (JNIEnv *env, jobject theobj)
833 {
834
835 jcas_Locking alock(env);
836 {
837 try {
838 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
839 the_this->BeginArcs();
840
841 }
842 catch (Standard_Failure) {
843   Standard_SStream Err;
844   Err <<   Standard_Failure::Caught(); 
845   Err << (char) 0;
846   jcas_ThrowException(env,Err.str().c_str());
847 }
848 }
849 alock.Release();
850
851 }
852
853
854
855 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginPolyArcs (JNIEnv *env, jobject theobj)
856 {
857
858 jcas_Locking alock(env);
859 {
860 try {
861 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
862 the_this->BeginPolyArcs();
863
864 }
865 catch (Standard_Failure) {
866   Standard_SStream Err;
867   Err <<   Standard_Failure::Caught(); 
868   Err << (char) 0;
869   jcas_ThrowException(env,Err.str().c_str());
870 }
871 }
872 alock.Release();
873
874 }
875
876
877
878 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginMarkers (JNIEnv *env, jobject theobj)
879 {
880
881 jcas_Locking alock(env);
882 {
883 try {
884 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
885 the_this->BeginMarkers();
886
887 }
888 catch (Standard_Failure) {
889   Standard_SStream Err;
890   Err <<   Standard_Failure::Caught(); 
891   Err << (char) 0;
892   jcas_ThrowException(env,Err.str().c_str());
893 }
894 }
895 alock.Release();
896
897 }
898
899
900
901 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_BeginPoints (JNIEnv *env, jobject theobj)
902 {
903
904 jcas_Locking alock(env);
905 {
906 try {
907 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
908 the_this->BeginPoints();
909
910 }
911 catch (Standard_Failure) {
912   Standard_SStream Err;
913   Err <<   Standard_Failure::Caught(); 
914   Err << (char) 0;
915   jcas_ThrowException(env,Err.str().c_str());
916 }
917 }
918 alock.Release();
919
920 }
921
922
923
924 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_ClosePrimitive (JNIEnv *env, jobject theobj)
925 {
926
927 jcas_Locking alock(env);
928 {
929 try {
930 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
931 the_this->ClosePrimitive();
932
933 }
934 catch (Standard_Failure) {
935   Standard_SStream Err;
936   Err <<   Standard_Failure::Caught(); 
937   Err << (char) 0;
938   jcas_ThrowException(env,Err.str().c_str());
939 }
940 }
941 alock.Release();
942
943 }
944
945
946
947 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Driver_ColorMap (JNIEnv *env, jobject theobj)
948 {
949 jobject thejret;
950
951 jcas_Locking alock(env);
952 {
953 try {
954 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
955 Handle(Aspect_ColorMap)* theret = new Handle(Aspect_ColorMap);
956 *theret = the_this->ColorMap();
957 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_ColorMap",theret);
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 jobject JNICALL Java_SampleHLRJni_Aspect_1Driver_TypeMap (JNIEnv *env, jobject theobj)
974 {
975 jobject thejret;
976
977 jcas_Locking alock(env);
978 {
979 try {
980 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
981 Handle(Aspect_TypeMap)* theret = new Handle(Aspect_TypeMap);
982 *theret = the_this->TypeMap();
983 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_TypeMap",theret);
984
985 }
986 catch (Standard_Failure) {
987   Standard_SStream Err;
988   Err <<   Standard_Failure::Caught(); 
989   Err << (char) 0;
990   jcas_ThrowException(env,Err.str().c_str());
991 }
992 }
993 alock.Release();
994 return thejret;
995 }
996
997
998
999 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Driver_WidthMap (JNIEnv *env, jobject theobj)
1000 {
1001 jobject thejret;
1002
1003 jcas_Locking alock(env);
1004 {
1005 try {
1006 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1007 Handle(Aspect_WidthMap)* theret = new Handle(Aspect_WidthMap);
1008 *theret = the_this->WidthMap();
1009 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_WidthMap",theret);
1010
1011 }
1012 catch (Standard_Failure) {
1013   Standard_SStream Err;
1014   Err <<   Standard_Failure::Caught(); 
1015   Err << (char) 0;
1016   jcas_ThrowException(env,Err.str().c_str());
1017 }
1018 }
1019 alock.Release();
1020 return thejret;
1021 }
1022
1023
1024
1025 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Driver_FontMap (JNIEnv *env, jobject theobj)
1026 {
1027 jobject thejret;
1028
1029 jcas_Locking alock(env);
1030 {
1031 try {
1032 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1033 Handle(Aspect_FontMap)* theret = new Handle(Aspect_FontMap);
1034 *theret = the_this->FontMap();
1035 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_FontMap",theret);
1036
1037 }
1038 catch (Standard_Failure) {
1039   Standard_SStream Err;
1040   Err <<   Standard_Failure::Caught(); 
1041   Err << (char) 0;
1042   jcas_ThrowException(env,Err.str().c_str());
1043 }
1044 }
1045 alock.Release();
1046 return thejret;
1047 }
1048
1049
1050
1051 JNIEXPORT jobject JNICALL Java_SampleHLRJni_Aspect_1Driver_MarkMap (JNIEnv *env, jobject theobj)
1052 {
1053 jobject thejret;
1054
1055 jcas_Locking alock(env);
1056 {
1057 try {
1058 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1059 Handle(Aspect_MarkMap)* theret = new Handle(Aspect_MarkMap);
1060 *theret = the_this->MarkMap();
1061 thejret = jcas_CreateObject(env,"CASCADESamplesJni/Aspect_MarkMap",theret);
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 return thejret;
1073 }
1074
1075
1076
1077 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_WorkSpace (JNIEnv *env, jobject theobj, jobject Width, jobject Heigth)
1078 {
1079
1080 jcas_Locking alock(env);
1081 {
1082 try {
1083 Standard_Real the_Width = jcas_GetReal(env,Width);
1084 Standard_Real the_Heigth = jcas_GetReal(env,Heigth);
1085 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1086 the_this->WorkSpace(the_Width,the_Heigth);
1087 jcas_SetReal(env,Width,the_Width);
1088 jcas_SetReal(env,Heigth,the_Heigth);
1089
1090 }
1091 catch (Standard_Failure) {
1092   Standard_SStream Err;
1093   Err <<   Standard_Failure::Caught(); 
1094   Err << (char) 0;
1095   jcas_ThrowException(env,Err.str().c_str());
1096 }
1097 }
1098 alock.Release();
1099
1100 }
1101
1102
1103
1104 JNIEXPORT jdouble JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1Convert_11 (JNIEnv *env, jobject theobj, jint PV)
1105 {
1106 jdouble thejret;
1107
1108 jcas_Locking alock(env);
1109 {
1110 try {
1111 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1112  thejret = the_this->Convert((Standard_Integer) PV);
1113
1114 }
1115 catch (Standard_Failure) {
1116   Standard_SStream Err;
1117   Err <<   Standard_Failure::Caught(); 
1118   Err << (char) 0;
1119   jcas_ThrowException(env,Err.str().c_str());
1120 }
1121 }
1122 alock.Release();
1123 return thejret;
1124 }
1125
1126
1127
1128 JNIEXPORT jint JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1Convert_12 (JNIEnv *env, jobject theobj, jdouble DV)
1129 {
1130 jint thejret;
1131
1132 jcas_Locking alock(env);
1133 {
1134 try {
1135 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1136  thejret = the_this->Convert((Quantity_Length) DV);
1137
1138 }
1139 catch (Standard_Failure) {
1140   Standard_SStream Err;
1141   Err <<   Standard_Failure::Caught(); 
1142   Err << (char) 0;
1143   jcas_ThrowException(env,Err.str().c_str());
1144 }
1145 }
1146 alock.Release();
1147 return thejret;
1148 }
1149
1150
1151
1152 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1Convert_13 (JNIEnv *env, jobject theobj, jint PX, jint PY, jobject DX, jobject DY)
1153 {
1154
1155 jcas_Locking alock(env);
1156 {
1157 try {
1158 Standard_Real the_DX = jcas_GetReal(env,DX);
1159 Standard_Real the_DY = jcas_GetReal(env,DY);
1160 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1161 the_this->Convert((Standard_Integer) PX,(Standard_Integer) PY,the_DX,the_DY);
1162 jcas_SetReal(env,DX,the_DX);
1163 jcas_SetReal(env,DY,the_DY);
1164
1165 }
1166 catch (Standard_Failure) {
1167   Standard_SStream Err;
1168   Err <<   Standard_Failure::Caught(); 
1169   Err << (char) 0;
1170   jcas_ThrowException(env,Err.str().c_str());
1171 }
1172 }
1173 alock.Release();
1174
1175 }
1176
1177
1178
1179 JNIEXPORT void JNICALL Java_SampleHLRJni_Aspect_1Driver_Aspect_1Driver_1Convert_14 (JNIEnv *env, jobject theobj, jdouble DX, jdouble DY, jobject PX, jobject PY)
1180 {
1181
1182 jcas_Locking alock(env);
1183 {
1184 try {
1185 Standard_Integer the_PX = jcas_GetInteger(env,PX);
1186 Standard_Integer the_PY = jcas_GetInteger(env,PY);
1187 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1188 the_this->Convert((Quantity_Length) DX,(Quantity_Length) DY,the_PX,the_PY);
1189 jcas_SetInteger(env,PX,the_PX);
1190 jcas_SetInteger(env,PY,the_PY);
1191
1192 }
1193 catch (Standard_Failure) {
1194   Standard_SStream Err;
1195   Err <<   Standard_Failure::Caught(); 
1196   Err << (char) 0;
1197   jcas_ThrowException(env,Err.str().c_str());
1198 }
1199 }
1200 alock.Release();
1201
1202 }
1203
1204
1205
1206 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_Aspect_1Driver_UseMFT (JNIEnv *env, jobject theobj)
1207 {
1208 jboolean thejret;
1209
1210 jcas_Locking alock(env);
1211 {
1212 try {
1213 Handle(Aspect_Driver) the_this = *((Handle(Aspect_Driver)*) jcas_GetHandle(env,theobj));
1214  thejret = the_this->UseMFT();
1215
1216 }
1217 catch (Standard_Failure) {
1218   Standard_SStream Err;
1219   Err <<   Standard_Failure::Caught(); 
1220   Err << (char) 0;
1221   jcas_ThrowException(env,Err.str().c_str());
1222 }
1223 }
1224 alock.Release();
1225 return thejret;
1226 }
1227
1228
1229 }