860aaa8a4bd843e9a473b9c850a0663b1f1cce64
[scilab.git] / scilab / modules / xcos / src / jni / Palette.cpp
1 #include "Palette.hxx"
2 /* Generated by GIWS (version 2.0.1) with command:
3 giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/Palette.giws.xml 
4 */
5 /*
6
7 This is generated code.
8
9 This software is a computer program whose purpose is to hide the complexity
10 of accessing Java objects/methods from C++ code.
11
12 This software is governed by the CeCILL-B license under French law and
13 abiding by the rules of distribution of free software.  You can  use, 
14 modify and/ or redistribute the software under the terms of the CeCILL-B
15 license as circulated by CEA, CNRS and INRIA at the following URL
16 "http://www.cecill.info". 
17
18 As a counterpart to the access to the source code and  rights to copy,
19 modify and redistribute granted by the license, users are provided only
20 with a limited warranty  and the software's author,  the holder of the
21 economic rights,  and the successive licensors  have only  limited
22 liability. 
23
24 In this respect, the user's attention is drawn to the risks associated
25 with loading,  using,  modifying and/or developing or reproducing the
26 software by the user in light of its specific status of free software,
27 that may mean  that it is complicated to manipulate,  and  that  also
28 therefore means  that it is reserved for developers  and  experienced
29 professionals having in-depth computer knowledge. Users are therefore
30 encouraged to load and test the software's suitability as regards their
31 requirements in conditions enabling the security of their systems and/or 
32 data to be ensured and,  more generally, to use and operate it in the 
33 same conditions as regards security. 
34
35 The fact that you are presently reading this means that you have had
36 knowledge of the CeCILL-B license and that you accept its terms.
37 */
38
39 namespace org_scilab_modules_xcos_palette {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * Palette::getCurrentEnv() {
46 JNIEnv * curEnv = NULL;
47 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
48 if (res != JNI_OK) {
49 throw GiwsException::JniException(getCurrentEnv());
50 }
51 return curEnv;
52 }
53 // Destructor
54
55 Palette::~Palette() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58
59 curEnv->DeleteGlobalRef(this->instance);
60 curEnv->DeleteGlobalRef(this->instanceClass);
61 curEnv->DeleteGlobalRef(this->stringArrayClass);}
62 // Constructors
63 Palette::Palette(JavaVM * jvm_) {
64 jmethodID constructObject = NULL ;
65 jobject localInstance ;
66 jclass localClass ;
67
68 const std::string construct="<init>";
69 const std::string param="()V";
70 jvm=jvm_;
71
72 JNIEnv * curEnv = getCurrentEnv();
73
74 localClass = curEnv->FindClass( this->className().c_str() ) ;
75 if (localClass == NULL) {
76   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
77 }
78
79 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
80
81 /* localClass is not needed anymore */
82 curEnv->DeleteLocalRef(localClass);
83
84 if (this->instanceClass == NULL) {
85 throw GiwsException::JniObjectCreationException(curEnv, this->className());
86 }
87
88
89 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
90 if(constructObject == NULL){
91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
92 }
93
94 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
95 if(localInstance == NULL){
96 throw GiwsException::JniObjectCreationException(curEnv, this->className());
97 }
98  
99 this->instance = curEnv->NewGlobalRef(localInstance) ;
100 if(this->instance == NULL){
101 throw GiwsException::JniObjectCreationException(curEnv, this->className());
102 }
103 /* localInstance not needed anymore */
104 curEnv->DeleteLocalRef(localInstance);
105
106                 /* Methods ID set to NULL */
107 voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
108 voidloadPaljstringjava_lang_StringID=NULL;
109 voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
110 voidremovejobjectArray_java_lang_Stringjava_lang_StringID=NULL;
111 voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
112 voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
113 voidgeneratePaletteIconjstringjava_lang_StringID=NULL;
114
115
116 }
117
118 Palette::Palette(JavaVM * jvm_, jobject JObj) {
119         jvm=jvm_;
120
121         JNIEnv * curEnv = getCurrentEnv();
122
123 jclass localClass = curEnv->GetObjectClass(JObj);
124         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
125         curEnv->DeleteLocalRef(localClass);
126
127         if (this->instanceClass == NULL) {
128 throw GiwsException::JniObjectCreationException(curEnv, this->className());
129         }
130
131         this->instance = curEnv->NewGlobalRef(JObj) ;
132         if(this->instance == NULL){
133 throw GiwsException::JniObjectCreationException(curEnv, this->className());
134         }
135         /* Methods ID set to NULL */
136         voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
137 voidloadPaljstringjava_lang_StringID=NULL;
138 voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
139 voidremovejobjectArray_java_lang_Stringjava_lang_StringID=NULL;
140 voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
141 voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
142 voidgeneratePaletteIconjstringjava_lang_StringID=NULL;
143
144
145 }
146
147 // Generic methods
148
149 void Palette::synchronize() {
150 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
151 throw GiwsException::JniMonitorException(getCurrentEnv(), "Palette");
152 }
153 }
154
155 void Palette::endSynchronize() {
156 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
157 throw GiwsException::JniMonitorException(getCurrentEnv(), "Palette");
158 }
159 }
160 // Method(s)
161
162 void Palette::loadPal (JavaVM * jvm_, char const* name, char const* const* category, int categorySize){
163
164 JNIEnv * curEnv = NULL;
165 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
166 jclass cls = curEnv->FindClass( className().c_str() );
167
168 jmethodID voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "loadPal", "(Ljava/lang/String;[Ljava/lang/String;)V" ) ;
169 if (voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
170 throw GiwsException::JniMethodNotFoundException(curEnv, "loadPal");
171 }
172
173 jstring name_ = curEnv->NewStringUTF( name );
174 if (name != NULL && name_ == NULL)
175 {
176 throw GiwsException::JniBadAllocException(curEnv);
177 }
178
179 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
180
181 // create java array of strings.
182 jobjectArray category_ = curEnv->NewObjectArray( categorySize, stringArrayClass, NULL);
183 if (category_ == NULL)
184 {
185 throw GiwsException::JniBadAllocException(curEnv);
186 }
187
188 // convert each char * to java strings and fill the java array.
189 for ( int i = 0; i < categorySize; i++)
190 {
191 jstring TempString = curEnv->NewStringUTF( category[i] );
192 if (TempString == NULL)
193 {
194 throw GiwsException::JniBadAllocException(curEnv);
195 }
196
197 curEnv->SetObjectArrayElement( category_, i, TempString);
198
199 // avoid keeping reference on to many strings
200 curEnv->DeleteLocalRef(TempString);
201 }
202                          curEnv->CallStaticVoidMethod(cls, voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,name_, category_);
203                         curEnv->DeleteLocalRef(stringArrayClass);
204 curEnv->DeleteLocalRef(name_);
205 curEnv->DeleteLocalRef(category_);
206 curEnv->DeleteLocalRef(cls);
207 if (curEnv->ExceptionCheck()) {
208 throw GiwsException::JniCallMethodException(curEnv);
209 }
210 }
211
212 void Palette::loadPal (JavaVM * jvm_, char const* name){
213
214 JNIEnv * curEnv = NULL;
215 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
216 jclass cls = curEnv->FindClass( className().c_str() );
217
218 jmethodID voidloadPaljstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "loadPal", "(Ljava/lang/String;)V" ) ;
219 if (voidloadPaljstringjava_lang_StringID == NULL) {
220 throw GiwsException::JniMethodNotFoundException(curEnv, "loadPal");
221 }
222
223 jstring name_ = curEnv->NewStringUTF( name );
224 if (name != NULL && name_ == NULL)
225 {
226 throw GiwsException::JniBadAllocException(curEnv);
227 }
228
229
230                          curEnv->CallStaticVoidMethod(cls, voidloadPaljstringjava_lang_StringID ,name_);
231                         curEnv->DeleteLocalRef(name_);
232 curEnv->DeleteLocalRef(cls);
233 if (curEnv->ExceptionCheck()) {
234 throw GiwsException::JniCallMethodException(curEnv);
235 }
236 }
237
238 void Palette::addCategory (JavaVM * jvm_, char const* const* name, int nameSize, bool visible){
239
240 JNIEnv * curEnv = NULL;
241 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
242 jclass cls = curEnv->FindClass( className().c_str() );
243
244 jmethodID voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "addCategory", "([Ljava/lang/String;Z)V" ) ;
245 if (voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID == NULL) {
246 throw GiwsException::JniMethodNotFoundException(curEnv, "addCategory");
247 }
248 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
249
250 // create java array of strings.
251 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
252 if (name_ == NULL)
253 {
254 throw GiwsException::JniBadAllocException(curEnv);
255 }
256
257 // convert each char * to java strings and fill the java array.
258 for ( int i = 0; i < nameSize; i++)
259 {
260 jstring TempString = curEnv->NewStringUTF( name[i] );
261 if (TempString == NULL)
262 {
263 throw GiwsException::JniBadAllocException(curEnv);
264 }
265
266 curEnv->SetObjectArrayElement( name_, i, TempString);
267
268 // avoid keeping reference on to many strings
269 curEnv->DeleteLocalRef(TempString);
270 }
271 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
272
273                          curEnv->CallStaticVoidMethod(cls, voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID ,name_, visible_);
274                         curEnv->DeleteLocalRef(stringArrayClass);
275 curEnv->DeleteLocalRef(name_);
276 curEnv->DeleteLocalRef(cls);
277 if (curEnv->ExceptionCheck()) {
278 throw GiwsException::JniCallMethodException(curEnv);
279 }
280 }
281
282 void Palette::remove (JavaVM * jvm_, char const* const* name, int nameSize){
283
284 JNIEnv * curEnv = NULL;
285 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
286 jclass cls = curEnv->FindClass( className().c_str() );
287
288 jmethodID voidremovejobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "remove", "([Ljava/lang/String;)V" ) ;
289 if (voidremovejobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
290 throw GiwsException::JniMethodNotFoundException(curEnv, "remove");
291 }
292 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
293
294 // create java array of strings.
295 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
296 if (name_ == NULL)
297 {
298 throw GiwsException::JniBadAllocException(curEnv);
299 }
300
301 // convert each char * to java strings and fill the java array.
302 for ( int i = 0; i < nameSize; i++)
303 {
304 jstring TempString = curEnv->NewStringUTF( name[i] );
305 if (TempString == NULL)
306 {
307 throw GiwsException::JniBadAllocException(curEnv);
308 }
309
310 curEnv->SetObjectArrayElement( name_, i, TempString);
311
312 // avoid keeping reference on to many strings
313 curEnv->DeleteLocalRef(TempString);
314 }
315                          curEnv->CallStaticVoidMethod(cls, voidremovejobjectArray_java_lang_Stringjava_lang_StringID ,name_);
316                         curEnv->DeleteLocalRef(stringArrayClass);
317 curEnv->DeleteLocalRef(name_);
318 curEnv->DeleteLocalRef(cls);
319 if (curEnv->ExceptionCheck()) {
320 throw GiwsException::JniCallMethodException(curEnv);
321 }
322 }
323
324 void Palette::enable (JavaVM * jvm_, char const* const* name, int nameSize, bool status){
325
326 JNIEnv * curEnv = NULL;
327 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
328 jclass cls = curEnv->FindClass( className().c_str() );
329
330 jmethodID voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "enable", "([Ljava/lang/String;Z)V" ) ;
331 if (voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID == NULL) {
332 throw GiwsException::JniMethodNotFoundException(curEnv, "enable");
333 }
334 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
335
336 // create java array of strings.
337 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
338 if (name_ == NULL)
339 {
340 throw GiwsException::JniBadAllocException(curEnv);
341 }
342
343 // convert each char * to java strings and fill the java array.
344 for ( int i = 0; i < nameSize; i++)
345 {
346 jstring TempString = curEnv->NewStringUTF( name[i] );
347 if (TempString == NULL)
348 {
349 throw GiwsException::JniBadAllocException(curEnv);
350 }
351
352 curEnv->SetObjectArrayElement( name_, i, TempString);
353
354 // avoid keeping reference on to many strings
355 curEnv->DeleteLocalRef(TempString);
356 }
357 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
358
359                          curEnv->CallStaticVoidMethod(cls, voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID ,name_, status_);
360                         curEnv->DeleteLocalRef(stringArrayClass);
361 curEnv->DeleteLocalRef(name_);
362 curEnv->DeleteLocalRef(cls);
363 if (curEnv->ExceptionCheck()) {
364 throw GiwsException::JniCallMethodException(curEnv);
365 }
366 }
367
368 void Palette::move (JavaVM * jvm_, char const* const* source, int sourceSize, char const* const* target, int targetSize){
369
370 JNIEnv * curEnv = NULL;
371 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
372 jclass cls = curEnv->FindClass( className().c_str() );
373
374 jmethodID voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "move", "([Ljava/lang/String;[Ljava/lang/String;)V" ) ;
375 if (voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
376 throw GiwsException::JniMethodNotFoundException(curEnv, "move");
377 }
378 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
379
380 // create java array of strings.
381 jobjectArray source_ = curEnv->NewObjectArray( sourceSize, stringArrayClass, NULL);
382 if (source_ == NULL)
383 {
384 throw GiwsException::JniBadAllocException(curEnv);
385 }
386
387 // convert each char * to java strings and fill the java array.
388 for ( int i = 0; i < sourceSize; i++)
389 {
390 jstring TempString = curEnv->NewStringUTF( source[i] );
391 if (TempString == NULL)
392 {
393 throw GiwsException::JniBadAllocException(curEnv);
394 }
395
396 curEnv->SetObjectArrayElement( source_, i, TempString);
397
398 // avoid keeping reference on to many strings
399 curEnv->DeleteLocalRef(TempString);
400 }
401
402 // create java array of strings.
403 jobjectArray target_ = curEnv->NewObjectArray( targetSize, stringArrayClass, NULL);
404 if (target_ == NULL)
405 {
406 throw GiwsException::JniBadAllocException(curEnv);
407 }
408
409 // convert each char * to java strings and fill the java array.
410 for ( int i = 0; i < targetSize; i++)
411 {
412 jstring TempString = curEnv->NewStringUTF( target[i] );
413 if (TempString == NULL)
414 {
415 throw GiwsException::JniBadAllocException(curEnv);
416 }
417
418 curEnv->SetObjectArrayElement( target_, i, TempString);
419
420 // avoid keeping reference on to many strings
421 curEnv->DeleteLocalRef(TempString);
422 }
423                          curEnv->CallStaticVoidMethod(cls, voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,source_, target_);
424                         curEnv->DeleteLocalRef(stringArrayClass);
425 curEnv->DeleteLocalRef(source_);
426 curEnv->DeleteLocalRef(target_);
427 curEnv->DeleteLocalRef(cls);
428 if (curEnv->ExceptionCheck()) {
429 throw GiwsException::JniCallMethodException(curEnv);
430 }
431 }
432
433 void Palette::generatePaletteIcon (JavaVM * jvm_, char const* iconPath){
434
435 JNIEnv * curEnv = NULL;
436 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
437 jclass cls = curEnv->FindClass( className().c_str() );
438
439 jmethodID voidgeneratePaletteIconjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "generatePaletteIcon", "(Ljava/lang/String;)V" ) ;
440 if (voidgeneratePaletteIconjstringjava_lang_StringID == NULL) {
441 throw GiwsException::JniMethodNotFoundException(curEnv, "generatePaletteIcon");
442 }
443
444 jstring iconPath_ = curEnv->NewStringUTF( iconPath );
445 if (iconPath != NULL && iconPath_ == NULL)
446 {
447 throw GiwsException::JniBadAllocException(curEnv);
448 }
449
450
451                          curEnv->CallStaticVoidMethod(cls, voidgeneratePaletteIconjstringjava_lang_StringID ,iconPath_);
452                         curEnv->DeleteLocalRef(iconPath_);
453 curEnv->DeleteLocalRef(cls);
454 if (curEnv->ExceptionCheck()) {
455 throw GiwsException::JniCallMethodException(curEnv);
456 }
457 }
458
459 }