Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / drv / CASCADESamplesJni / CASCADESamplesJni_TopoDS_Shape_java.cxx
1 //
2 //                     Copyright (C) 1991 - 2000 by  
3 //                      Matra Datavision SA.  All rights reserved.
4 //  
5 //                     Copyright (C) 2001 - 2004 by
6 //                     Open CASCADE SA.  All rights reserved.
7 // 
8 // This file is part of the Open CASCADE Technology software.
9 //
10 // This software may be distributed and/or modified under the terms and
11 // conditions of the Open CASCADE Public License as defined by Open CASCADE SA
12 // and appearing in the file LICENSE included in the packaging of this file.
13 //  
14 // This software is distributed on an "AS IS" basis, without warranty of any
15 // kind, and Open CASCADE SA hereby disclaims all such warranties,
16 // including without limitation, any warranties of merchantability, fitness
17 // for a particular purpose or non-infringement. Please see the License for
18 // the specific terms and conditions governing rights and limitations under the
19 // License.
20
21 #include <CASCADESamplesJni_TopoDS_Shape.h>
22 #include <TopoDS_Shape.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 <TopLoc_Location.hxx>
31 #include <TopAbs_Orientation.hxx>
32 #include <TopoDS_TShape.hxx>
33 #include <TopAbs_ShapeEnum.hxx>
34 #include <Standard_Integer.hxx>
35
36
37 extern "C" {
38
39
40 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Create_10 (JNIEnv *env, jobject theobj)
41 {
42
43 jcas_Locking alock(env);
44 {
45 try {
46 TopoDS_Shape* theret = new TopoDS_Shape();
47 jcas_SetHandle(env,theobj,theret);
48
49 }
50 catch (Standard_Failure) {
51   Standard_SStream Err;
52   Err <<   Standard_Failure::Caught(); 
53   Err << (char) 0;
54   jcas_ThrowException(env,Err.str().c_str());
55 }
56 }
57 alock.Release();
58
59 }
60
61
62
63 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_IsNull (JNIEnv *env, jobject theobj)
64 {
65 jboolean thejret;
66
67 jcas_Locking alock(env);
68 {
69 try {
70 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
71  thejret = the_this->IsNull();
72
73 }
74 catch (Standard_Failure) {
75   Standard_SStream Err;
76   Err <<   Standard_Failure::Caught(); 
77   Err << (char) 0;
78   jcas_ThrowException(env,Err.str().c_str());
79 }
80 }
81 alock.Release();
82 return thejret;
83 }
84
85
86
87 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Nullify (JNIEnv *env, jobject theobj)
88 {
89
90 jcas_Locking alock(env);
91 {
92 try {
93 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
94 the_this->Nullify();
95
96 }
97 catch (Standard_Failure) {
98   Standard_SStream Err;
99   Err <<   Standard_Failure::Caught(); 
100   Err << (char) 0;
101   jcas_ThrowException(env,Err.str().c_str());
102 }
103 }
104 alock.Release();
105
106 }
107
108
109
110 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Location_11 (JNIEnv *env, jobject theobj)
111 {
112 jobject thejret;
113
114 jcas_Locking alock(env);
115 {
116 try {
117 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
118 const TopLoc_Location& theret = the_this->Location();
119 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopLoc_Location",&theret,0);
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 return thejret;
131 }
132
133
134
135 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Location_12 (JNIEnv *env, jobject theobj, jobject Loc)
136 {
137
138 jcas_Locking alock(env);
139 {
140 try {
141 TopLoc_Location* the_Loc = (TopLoc_Location*) jcas_GetHandle(env,Loc);
142 if ( the_Loc == NULL ) {
143
144  // The following assumes availability of the default constructor (what may not
145  // always be the case). Therefore explicit exception is thrown if the null
146  // object has been passed.
147  // the_Loc = new TopLoc_Location ();
148  // jcas_SetHandle ( env, Loc, the_Loc );
149  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
150
151 }  // end if
152 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
153 the_this->Location(*the_Loc);
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
165 }
166
167
168
169 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Located (JNIEnv *env, jobject theobj, jobject Loc)
170 {
171 jobject thejret;
172
173 jcas_Locking alock(env);
174 {
175 try {
176 TopLoc_Location* the_Loc = (TopLoc_Location*) jcas_GetHandle(env,Loc);
177 if ( the_Loc == NULL ) {
178
179  // The following assumes availability of the default constructor (what may not
180  // always be the case). Therefore explicit exception is thrown if the null
181  // object has been passed.
182  // the_Loc = new TopLoc_Location ();
183  // jcas_SetHandle ( env, Loc, the_Loc );
184  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
185
186 }  // end if
187 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
188 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Located(*the_Loc));
189 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
190
191 }
192 catch (Standard_Failure) {
193   Standard_SStream Err;
194   Err <<   Standard_Failure::Caught(); 
195   Err << (char) 0;
196   jcas_ThrowException(env,Err.str().c_str());
197 }
198 }
199 alock.Release();
200 return thejret;
201 }
202
203
204
205 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Orientation_11 (JNIEnv *env, jobject theobj)
206 {
207 jshort thejret;
208
209 jcas_Locking alock(env);
210 {
211 try {
212 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
213  thejret = the_this->Orientation();
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 return thejret;
225 }
226
227
228
229 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Orientation_12 (JNIEnv *env, jobject theobj, jshort Orient)
230 {
231
232 jcas_Locking alock(env);
233 {
234 try {
235 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
236 the_this->Orientation((TopAbs_Orientation) Orient);
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 jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Oriented (JNIEnv *env, jobject theobj, jshort Or)
253 {
254 jobject thejret;
255
256 jcas_Locking alock(env);
257 {
258 try {
259 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
260 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Oriented((TopAbs_Orientation) Or));
261 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
262
263 }
264 catch (Standard_Failure) {
265   Standard_SStream Err;
266   Err <<   Standard_Failure::Caught(); 
267   Err << (char) 0;
268   jcas_ThrowException(env,Err.str().c_str());
269 }
270 }
271 alock.Release();
272 return thejret;
273 }
274
275
276
277 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1TShape_11 (JNIEnv *env, jobject theobj)
278 {
279 jobject thejret;
280
281 jcas_Locking alock(env);
282 {
283 try {
284 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
285 Handle(TopoDS_TShape)* theret = new Handle(TopoDS_TShape);
286 *theret = the_this->TShape();
287 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_TShape",theret);
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 return thejret;
299 }
300
301
302
303 JNIEXPORT jshort JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_ShapeType (JNIEnv *env, jobject theobj)
304 {
305 jshort thejret;
306
307 jcas_Locking alock(env);
308 {
309 try {
310 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
311  thejret = the_this->ShapeType();
312
313 }
314 catch (Standard_Failure) {
315   Standard_SStream Err;
316   Err <<   Standard_Failure::Caught(); 
317   Err << (char) 0;
318   jcas_ThrowException(env,Err.str().c_str());
319 }
320 }
321 alock.Release();
322 return thejret;
323 }
324
325
326
327 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Free_11 (JNIEnv *env, jobject theobj)
328 {
329 jboolean thejret;
330
331 jcas_Locking alock(env);
332 {
333 try {
334 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
335  thejret = the_this->Free();
336
337 }
338 catch (Standard_Failure) {
339   Standard_SStream Err;
340   Err <<   Standard_Failure::Caught(); 
341   Err << (char) 0;
342   jcas_ThrowException(env,Err.str().c_str());
343 }
344 }
345 alock.Release();
346 return thejret;
347 }
348
349
350
351 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Free_12 (JNIEnv *env, jobject theobj, jboolean F)
352 {
353
354 jcas_Locking alock(env);
355 {
356 try {
357 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
358 the_this->Free((Standard_Boolean) F);
359
360 }
361 catch (Standard_Failure) {
362   Standard_SStream Err;
363   Err <<   Standard_Failure::Caught(); 
364   Err << (char) 0;
365   jcas_ThrowException(env,Err.str().c_str());
366 }
367 }
368 alock.Release();
369
370 }
371
372
373
374 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Modified_11 (JNIEnv *env, jobject theobj)
375 {
376 jboolean thejret;
377
378 jcas_Locking alock(env);
379 {
380 try {
381 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
382  thejret = the_this->Modified();
383
384 }
385 catch (Standard_Failure) {
386   Standard_SStream Err;
387   Err <<   Standard_Failure::Caught(); 
388   Err << (char) 0;
389   jcas_ThrowException(env,Err.str().c_str());
390 }
391 }
392 alock.Release();
393 return thejret;
394 }
395
396
397
398 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Modified_12 (JNIEnv *env, jobject theobj, jboolean M)
399 {
400
401 jcas_Locking alock(env);
402 {
403 try {
404 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
405 the_this->Modified((Standard_Boolean) M);
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 jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Checked_11 (JNIEnv *env, jobject theobj)
422 {
423 jboolean thejret;
424
425 jcas_Locking alock(env);
426 {
427 try {
428 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
429  thejret = the_this->Checked();
430
431 }
432 catch (Standard_Failure) {
433   Standard_SStream Err;
434   Err <<   Standard_Failure::Caught(); 
435   Err << (char) 0;
436   jcas_ThrowException(env,Err.str().c_str());
437 }
438 }
439 alock.Release();
440 return thejret;
441 }
442
443
444
445 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Checked_12 (JNIEnv *env, jobject theobj, jboolean C)
446 {
447
448 jcas_Locking alock(env);
449 {
450 try {
451 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
452 the_this->Checked((Standard_Boolean) C);
453
454 }
455 catch (Standard_Failure) {
456   Standard_SStream Err;
457   Err <<   Standard_Failure::Caught(); 
458   Err << (char) 0;
459   jcas_ThrowException(env,Err.str().c_str());
460 }
461 }
462 alock.Release();
463
464 }
465
466
467
468 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Orientable_11 (JNIEnv *env, jobject theobj)
469 {
470 jboolean thejret;
471
472 jcas_Locking alock(env);
473 {
474 try {
475 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
476  thejret = the_this->Orientable();
477
478 }
479 catch (Standard_Failure) {
480   Standard_SStream Err;
481   Err <<   Standard_Failure::Caught(); 
482   Err << (char) 0;
483   jcas_ThrowException(env,Err.str().c_str());
484 }
485 }
486 alock.Release();
487 return thejret;
488 }
489
490
491
492 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Orientable_12 (JNIEnv *env, jobject theobj, jboolean C)
493 {
494
495 jcas_Locking alock(env);
496 {
497 try {
498 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
499 the_this->Orientable((Standard_Boolean) C);
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
511 }
512
513
514
515 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Closed_11 (JNIEnv *env, jobject theobj)
516 {
517 jboolean thejret;
518
519 jcas_Locking alock(env);
520 {
521 try {
522 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
523  thejret = the_this->Closed();
524
525 }
526 catch (Standard_Failure) {
527   Standard_SStream Err;
528   Err <<   Standard_Failure::Caught(); 
529   Err << (char) 0;
530   jcas_ThrowException(env,Err.str().c_str());
531 }
532 }
533 alock.Release();
534 return thejret;
535 }
536
537
538
539 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Closed_12 (JNIEnv *env, jobject theobj, jboolean C)
540 {
541
542 jcas_Locking alock(env);
543 {
544 try {
545 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
546 the_this->Closed((Standard_Boolean) C);
547
548 }
549 catch (Standard_Failure) {
550   Standard_SStream Err;
551   Err <<   Standard_Failure::Caught(); 
552   Err << (char) 0;
553   jcas_ThrowException(env,Err.str().c_str());
554 }
555 }
556 alock.Release();
557
558 }
559
560
561
562 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Infinite_11 (JNIEnv *env, jobject theobj)
563 {
564 jboolean thejret;
565
566 jcas_Locking alock(env);
567 {
568 try {
569 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
570  thejret = the_this->Infinite();
571
572 }
573 catch (Standard_Failure) {
574   Standard_SStream Err;
575   Err <<   Standard_Failure::Caught(); 
576   Err << (char) 0;
577   jcas_ThrowException(env,Err.str().c_str());
578 }
579 }
580 alock.Release();
581 return thejret;
582 }
583
584
585
586 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Infinite_12 (JNIEnv *env, jobject theobj, jboolean C)
587 {
588
589 jcas_Locking alock(env);
590 {
591 try {
592 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
593 the_this->Infinite((Standard_Boolean) C);
594
595 }
596 catch (Standard_Failure) {
597   Standard_SStream Err;
598   Err <<   Standard_Failure::Caught(); 
599   Err << (char) 0;
600   jcas_ThrowException(env,Err.str().c_str());
601 }
602 }
603 alock.Release();
604
605 }
606
607
608
609 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Convex_11 (JNIEnv *env, jobject theobj)
610 {
611 jboolean thejret;
612
613 jcas_Locking alock(env);
614 {
615 try {
616 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
617  thejret = the_this->Convex();
618
619 }
620 catch (Standard_Failure) {
621   Standard_SStream Err;
622   Err <<   Standard_Failure::Caught(); 
623   Err << (char) 0;
624   jcas_ThrowException(env,Err.str().c_str());
625 }
626 }
627 alock.Release();
628 return thejret;
629 }
630
631
632
633 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1Convex_12 (JNIEnv *env, jobject theobj, jboolean C)
634 {
635
636 jcas_Locking alock(env);
637 {
638 try {
639 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
640 the_this->Convex((Standard_Boolean) C);
641
642 }
643 catch (Standard_Failure) {
644   Standard_SStream Err;
645   Err <<   Standard_Failure::Caught(); 
646   Err << (char) 0;
647   jcas_ThrowException(env,Err.str().c_str());
648 }
649 }
650 alock.Release();
651
652 }
653
654
655
656 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Move (JNIEnv *env, jobject theobj, jobject position)
657 {
658
659 jcas_Locking alock(env);
660 {
661 try {
662 TopLoc_Location* the_position = (TopLoc_Location*) jcas_GetHandle(env,position);
663 if ( the_position == NULL ) {
664
665  // The following assumes availability of the default constructor (what may not
666  // always be the case). Therefore explicit exception is thrown if the null
667  // object has been passed.
668  // the_position = new TopLoc_Location ();
669  // jcas_SetHandle ( env, position, the_position );
670  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
671
672 }  // end if
673 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
674 the_this->Move(*the_position);
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
686 }
687
688
689
690 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Moved (JNIEnv *env, jobject theobj, jobject position)
691 {
692 jobject thejret;
693
694 jcas_Locking alock(env);
695 {
696 try {
697 TopLoc_Location* the_position = (TopLoc_Location*) jcas_GetHandle(env,position);
698 if ( the_position == NULL ) {
699
700  // The following assumes availability of the default constructor (what may not
701  // always be the case). Therefore explicit exception is thrown if the null
702  // object has been passed.
703  // the_position = new TopLoc_Location ();
704  // jcas_SetHandle ( env, position, the_position );
705  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
706
707 }  // end if
708 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
709 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Moved(*the_position));
710 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
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 void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Reverse (JNIEnv *env, jobject theobj)
727 {
728
729 jcas_Locking alock(env);
730 {
731 try {
732 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
733 the_this->Reverse();
734
735 }
736 catch (Standard_Failure) {
737   Standard_SStream Err;
738   Err <<   Standard_Failure::Caught(); 
739   Err << (char) 0;
740   jcas_ThrowException(env,Err.str().c_str());
741 }
742 }
743 alock.Release();
744
745 }
746
747
748
749 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Reversed (JNIEnv *env, jobject theobj)
750 {
751 jobject thejret;
752
753 jcas_Locking alock(env);
754 {
755 try {
756 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
757 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Reversed());
758 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
759
760 }
761 catch (Standard_Failure) {
762   Standard_SStream Err;
763   Err <<   Standard_Failure::Caught(); 
764   Err << (char) 0;
765   jcas_ThrowException(env,Err.str().c_str());
766 }
767 }
768 alock.Release();
769 return thejret;
770 }
771
772
773
774 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Complement (JNIEnv *env, jobject theobj)
775 {
776
777 jcas_Locking alock(env);
778 {
779 try {
780 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
781 the_this->Complement();
782
783 }
784 catch (Standard_Failure) {
785   Standard_SStream Err;
786   Err <<   Standard_Failure::Caught(); 
787   Err << (char) 0;
788   jcas_ThrowException(env,Err.str().c_str());
789 }
790 }
791 alock.Release();
792
793 }
794
795
796
797 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Complemented (JNIEnv *env, jobject theobj)
798 {
799 jobject thejret;
800
801 jcas_Locking alock(env);
802 {
803 try {
804 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
805 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Complemented());
806 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
807
808 }
809 catch (Standard_Failure) {
810   Standard_SStream Err;
811   Err <<   Standard_Failure::Caught(); 
812   Err << (char) 0;
813   jcas_ThrowException(env,Err.str().c_str());
814 }
815 }
816 alock.Release();
817 return thejret;
818 }
819
820
821
822 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Compose (JNIEnv *env, jobject theobj, jshort Orient)
823 {
824
825 jcas_Locking alock(env);
826 {
827 try {
828 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
829 the_this->Compose((TopAbs_Orientation) Orient);
830
831 }
832 catch (Standard_Failure) {
833   Standard_SStream Err;
834   Err <<   Standard_Failure::Caught(); 
835   Err << (char) 0;
836   jcas_ThrowException(env,Err.str().c_str());
837 }
838 }
839 alock.Release();
840
841 }
842
843
844
845 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_Composed (JNIEnv *env, jobject theobj, jshort Orient)
846 {
847 jobject thejret;
848
849 jcas_Locking alock(env);
850 {
851 try {
852 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
853 TopoDS_Shape* theret = new TopoDS_Shape(the_this->Composed((TopAbs_Orientation) Orient));
854 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
855
856 }
857 catch (Standard_Failure) {
858   Standard_SStream Err;
859   Err <<   Standard_Failure::Caught(); 
860   Err << (char) 0;
861   jcas_ThrowException(env,Err.str().c_str());
862 }
863 }
864 alock.Release();
865 return thejret;
866 }
867
868
869
870 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_IsPartner (JNIEnv *env, jobject theobj, jobject other)
871 {
872 jboolean thejret;
873
874 jcas_Locking alock(env);
875 {
876 try {
877 TopoDS_Shape* the_other = (TopoDS_Shape*) jcas_GetHandle(env,other);
878 if ( the_other == NULL ) {
879
880  // The following assumes availability of the default constructor (what may not
881  // always be the case). Therefore explicit exception is thrown if the null
882  // object has been passed.
883  // the_other = new TopoDS_Shape ();
884  // jcas_SetHandle ( env, other, the_other );
885  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
886
887 }  // end if
888 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
889  thejret = the_this->IsPartner(*the_other);
890
891 }
892 catch (Standard_Failure) {
893   Standard_SStream Err;
894   Err <<   Standard_Failure::Caught(); 
895   Err << (char) 0;
896   jcas_ThrowException(env,Err.str().c_str());
897 }
898 }
899 alock.Release();
900 return thejret;
901 }
902
903
904
905 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_IsSame (JNIEnv *env, jobject theobj, jobject other)
906 {
907 jboolean thejret;
908
909 jcas_Locking alock(env);
910 {
911 try {
912 TopoDS_Shape* the_other = (TopoDS_Shape*) jcas_GetHandle(env,other);
913 if ( the_other == NULL ) {
914
915  // The following assumes availability of the default constructor (what may not
916  // always be the case). Therefore explicit exception is thrown if the null
917  // object has been passed.
918  // the_other = new TopoDS_Shape ();
919  // jcas_SetHandle ( env, other, the_other );
920  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
921
922 }  // end if
923 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
924  thejret = the_this->IsSame(*the_other);
925
926 }
927 catch (Standard_Failure) {
928   Standard_SStream Err;
929   Err <<   Standard_Failure::Caught(); 
930   Err << (char) 0;
931   jcas_ThrowException(env,Err.str().c_str());
932 }
933 }
934 alock.Release();
935 return thejret;
936 }
937
938
939
940 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_IsEqual (JNIEnv *env, jobject theobj, jobject other)
941 {
942 jboolean thejret;
943
944 jcas_Locking alock(env);
945 {
946 try {
947 TopoDS_Shape* the_other = (TopoDS_Shape*) jcas_GetHandle(env,other);
948 if ( the_other == NULL ) {
949
950  // The following assumes availability of the default constructor (what may not
951  // always be the case). Therefore explicit exception is thrown if the null
952  // object has been passed.
953  // the_other = new TopoDS_Shape ();
954  // jcas_SetHandle ( env, other, the_other );
955  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
956
957 }  // end if
958 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
959  thejret = the_this->IsEqual(*the_other);
960
961 }
962 catch (Standard_Failure) {
963   Standard_SStream Err;
964   Err <<   Standard_Failure::Caught(); 
965   Err << (char) 0;
966   jcas_ThrowException(env,Err.str().c_str());
967 }
968 }
969 alock.Release();
970 return thejret;
971 }
972
973
974
975 JNIEXPORT jboolean JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_IsNotEqual (JNIEnv *env, jobject theobj, jobject other)
976 {
977 jboolean thejret;
978
979 jcas_Locking alock(env);
980 {
981 try {
982 TopoDS_Shape* the_other = (TopoDS_Shape*) jcas_GetHandle(env,other);
983 if ( the_other == NULL ) {
984
985  // The following assumes availability of the default constructor (what may not
986  // always be the case). Therefore explicit exception is thrown if the null
987  // object has been passed.
988  // the_other = new TopoDS_Shape ();
989  // jcas_SetHandle ( env, other, the_other );
990  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
991
992 }  // end if
993 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
994  thejret = the_this->IsNotEqual(*the_other);
995
996 }
997 catch (Standard_Failure) {
998   Standard_SStream Err;
999   Err <<   Standard_Failure::Caught(); 
1000   Err << (char) 0;
1001   jcas_ThrowException(env,Err.str().c_str());
1002 }
1003 }
1004 alock.Release();
1005 return thejret;
1006 }
1007
1008
1009
1010 JNIEXPORT jint JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_HashCode (JNIEnv *env, jobject theobj, jint Upper)
1011 {
1012 jint thejret;
1013
1014 jcas_Locking alock(env);
1015 {
1016 try {
1017 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
1018  thejret = the_this->HashCode((Standard_Integer) Upper);
1019
1020 }
1021 catch (Standard_Failure) {
1022   Standard_SStream Err;
1023   Err <<   Standard_Failure::Caught(); 
1024   Err << (char) 0;
1025   jcas_ThrowException(env,Err.str().c_str());
1026 }
1027 }
1028 alock.Release();
1029 return thejret;
1030 }
1031
1032
1033
1034 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_EmptyCopy (JNIEnv *env, jobject theobj)
1035 {
1036
1037 jcas_Locking alock(env);
1038 {
1039 try {
1040 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
1041 the_this->EmptyCopy();
1042
1043 }
1044 catch (Standard_Failure) {
1045   Standard_SStream Err;
1046   Err <<   Standard_Failure::Caught(); 
1047   Err << (char) 0;
1048   jcas_ThrowException(env,Err.str().c_str());
1049 }
1050 }
1051 alock.Release();
1052
1053 }
1054
1055
1056
1057 JNIEXPORT jobject JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_EmptyCopied (JNIEnv *env, jobject theobj)
1058 {
1059 jobject thejret;
1060
1061 jcas_Locking alock(env);
1062 {
1063 try {
1064 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
1065 TopoDS_Shape* theret = new TopoDS_Shape(the_this->EmptyCopied());
1066 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TopoDS_Shape",theret);
1067
1068 }
1069 catch (Standard_Failure) {
1070   Standard_SStream Err;
1071   Err <<   Standard_Failure::Caught(); 
1072   Err << (char) 0;
1073   jcas_ThrowException(env,Err.str().c_str());
1074 }
1075 }
1076 alock.Release();
1077 return thejret;
1078 }
1079
1080
1081
1082 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_TopoDS_1Shape_1TShape_12 (JNIEnv *env, jobject theobj, jobject T)
1083 {
1084
1085 jcas_Locking alock(env);
1086 {
1087 try {
1088  Handle( TopoDS_TShape ) the_T;
1089  void*                ptr_T = jcas_GetHandle(env,T);
1090  
1091  if ( ptr_T != NULL ) the_T = *(   (  Handle( TopoDS_TShape )*  )ptr_T   );
1092
1093 TopoDS_Shape* the_this = (TopoDS_Shape*) jcas_GetHandle(env,theobj);
1094 the_this->TShape(the_T);
1095
1096 }
1097 catch (Standard_Failure) {
1098   Standard_SStream Err;
1099   Err <<   Standard_Failure::Caught(); 
1100   Err << (char) 0;
1101   jcas_ThrowException(env,Err.str().c_str());
1102 }
1103 }
1104 alock.Release();
1105
1106 }
1107
1108
1109
1110 JNIEXPORT void JNICALL Java_CASCADESamplesJni_TopoDS_1Shape_FinalizeValue(JNIEnv *, jclass, jlong theid)
1111 {
1112 if (theid) {
1113   TopoDS_Shape* theobj = (TopoDS_Shape*) theid;
1114   delete theobj;
1115 }
1116 }
1117
1118
1119 }