Xcos palette: add xcosPalGenerateAllIcon utility
[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 voidgenerateAllImagesjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
115
116
117 }
118
119 Palette::Palette(JavaVM * jvm_, jobject JObj) {
120         jvm=jvm_;
121
122         JNIEnv * curEnv = getCurrentEnv();
123
124 jclass localClass = curEnv->GetObjectClass(JObj);
125         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
126         curEnv->DeleteLocalRef(localClass);
127
128         if (this->instanceClass == NULL) {
129 throw GiwsException::JniObjectCreationException(curEnv, this->className());
130         }
131
132         this->instance = curEnv->NewGlobalRef(JObj) ;
133         if(this->instance == NULL){
134 throw GiwsException::JniObjectCreationException(curEnv, this->className());
135         }
136         /* Methods ID set to NULL */
137         voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
138 voidloadPaljstringjava_lang_StringID=NULL;
139 voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
140 voidremovejobjectArray_java_lang_Stringjava_lang_StringID=NULL;
141 voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID=NULL;
142 voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
143 voidgeneratePaletteIconjstringjava_lang_StringID=NULL;
144 voidgenerateAllImagesjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
145
146
147 }
148
149 // Generic methods
150
151 void Palette::synchronize() {
152 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
153 throw GiwsException::JniMonitorException(getCurrentEnv(), "Palette");
154 }
155 }
156
157 void Palette::endSynchronize() {
158 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
159 throw GiwsException::JniMonitorException(getCurrentEnv(), "Palette");
160 }
161 }
162 // Method(s)
163
164 void Palette::loadPal (JavaVM * jvm_, char const* name, char const* const* category, int categorySize){
165
166 JNIEnv * curEnv = NULL;
167 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
168 jclass cls = curEnv->FindClass( className().c_str() );
169
170 jmethodID voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "loadPal", "(Ljava/lang/String;[Ljava/lang/String;)V" ) ;
171 if (voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
172 throw GiwsException::JniMethodNotFoundException(curEnv, "loadPal");
173 }
174
175 jstring name_ = curEnv->NewStringUTF( name );
176 if (name != NULL && name_ == NULL)
177 {
178 throw GiwsException::JniBadAllocException(curEnv);
179 }
180
181 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
182
183 // create java array of strings.
184 jobjectArray category_ = curEnv->NewObjectArray( categorySize, stringArrayClass, NULL);
185 if (category_ == NULL)
186 {
187 throw GiwsException::JniBadAllocException(curEnv);
188 }
189
190 // convert each char * to java strings and fill the java array.
191 for ( int i = 0; i < categorySize; i++)
192 {
193 jstring TempString = curEnv->NewStringUTF( category[i] );
194 if (TempString == NULL)
195 {
196 throw GiwsException::JniBadAllocException(curEnv);
197 }
198
199 curEnv->SetObjectArrayElement( category_, i, TempString);
200
201 // avoid keeping reference on to many strings
202 curEnv->DeleteLocalRef(TempString);
203 }
204                          curEnv->CallStaticVoidMethod(cls, voidloadPaljstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,name_, category_);
205                         curEnv->DeleteLocalRef(stringArrayClass);
206 curEnv->DeleteLocalRef(name_);
207 curEnv->DeleteLocalRef(category_);
208 curEnv->DeleteLocalRef(cls);
209 if (curEnv->ExceptionCheck()) {
210 throw GiwsException::JniCallMethodException(curEnv);
211 }
212 }
213
214 void Palette::loadPal (JavaVM * jvm_, char const* name){
215
216 JNIEnv * curEnv = NULL;
217 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
218 jclass cls = curEnv->FindClass( className().c_str() );
219
220 jmethodID voidloadPaljstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "loadPal", "(Ljava/lang/String;)V" ) ;
221 if (voidloadPaljstringjava_lang_StringID == NULL) {
222 throw GiwsException::JniMethodNotFoundException(curEnv, "loadPal");
223 }
224
225 jstring name_ = curEnv->NewStringUTF( name );
226 if (name != NULL && name_ == NULL)
227 {
228 throw GiwsException::JniBadAllocException(curEnv);
229 }
230
231
232                          curEnv->CallStaticVoidMethod(cls, voidloadPaljstringjava_lang_StringID ,name_);
233                         curEnv->DeleteLocalRef(name_);
234 curEnv->DeleteLocalRef(cls);
235 if (curEnv->ExceptionCheck()) {
236 throw GiwsException::JniCallMethodException(curEnv);
237 }
238 }
239
240 void Palette::addCategory (JavaVM * jvm_, char const* const* name, int nameSize, bool visible){
241
242 JNIEnv * curEnv = NULL;
243 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
244 jclass cls = curEnv->FindClass( className().c_str() );
245
246 jmethodID voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "addCategory", "([Ljava/lang/String;Z)V" ) ;
247 if (voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID == NULL) {
248 throw GiwsException::JniMethodNotFoundException(curEnv, "addCategory");
249 }
250 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
251
252 // create java array of strings.
253 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
254 if (name_ == NULL)
255 {
256 throw GiwsException::JniBadAllocException(curEnv);
257 }
258
259 // convert each char * to java strings and fill the java array.
260 for ( int i = 0; i < nameSize; i++)
261 {
262 jstring TempString = curEnv->NewStringUTF( name[i] );
263 if (TempString == NULL)
264 {
265 throw GiwsException::JniBadAllocException(curEnv);
266 }
267
268 curEnv->SetObjectArrayElement( name_, i, TempString);
269
270 // avoid keeping reference on to many strings
271 curEnv->DeleteLocalRef(TempString);
272 }
273 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
274
275                          curEnv->CallStaticVoidMethod(cls, voidaddCategoryjobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID ,name_, visible_);
276                         curEnv->DeleteLocalRef(stringArrayClass);
277 curEnv->DeleteLocalRef(name_);
278 curEnv->DeleteLocalRef(cls);
279 if (curEnv->ExceptionCheck()) {
280 throw GiwsException::JniCallMethodException(curEnv);
281 }
282 }
283
284 void Palette::remove (JavaVM * jvm_, char const* const* name, int nameSize){
285
286 JNIEnv * curEnv = NULL;
287 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
288 jclass cls = curEnv->FindClass( className().c_str() );
289
290 jmethodID voidremovejobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "remove", "([Ljava/lang/String;)V" ) ;
291 if (voidremovejobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
292 throw GiwsException::JniMethodNotFoundException(curEnv, "remove");
293 }
294 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
295
296 // create java array of strings.
297 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
298 if (name_ == NULL)
299 {
300 throw GiwsException::JniBadAllocException(curEnv);
301 }
302
303 // convert each char * to java strings and fill the java array.
304 for ( int i = 0; i < nameSize; i++)
305 {
306 jstring TempString = curEnv->NewStringUTF( name[i] );
307 if (TempString == NULL)
308 {
309 throw GiwsException::JniBadAllocException(curEnv);
310 }
311
312 curEnv->SetObjectArrayElement( name_, i, TempString);
313
314 // avoid keeping reference on to many strings
315 curEnv->DeleteLocalRef(TempString);
316 }
317                          curEnv->CallStaticVoidMethod(cls, voidremovejobjectArray_java_lang_Stringjava_lang_StringID ,name_);
318                         curEnv->DeleteLocalRef(stringArrayClass);
319 curEnv->DeleteLocalRef(name_);
320 curEnv->DeleteLocalRef(cls);
321 if (curEnv->ExceptionCheck()) {
322 throw GiwsException::JniCallMethodException(curEnv);
323 }
324 }
325
326 void Palette::enable (JavaVM * jvm_, char const* const* name, int nameSize, bool status){
327
328 JNIEnv * curEnv = NULL;
329 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
330 jclass cls = curEnv->FindClass( className().c_str() );
331
332 jmethodID voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "enable", "([Ljava/lang/String;Z)V" ) ;
333 if (voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID == NULL) {
334 throw GiwsException::JniMethodNotFoundException(curEnv, "enable");
335 }
336 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
337
338 // create java array of strings.
339 jobjectArray name_ = curEnv->NewObjectArray( nameSize, stringArrayClass, NULL);
340 if (name_ == NULL)
341 {
342 throw GiwsException::JniBadAllocException(curEnv);
343 }
344
345 // convert each char * to java strings and fill the java array.
346 for ( int i = 0; i < nameSize; i++)
347 {
348 jstring TempString = curEnv->NewStringUTF( name[i] );
349 if (TempString == NULL)
350 {
351 throw GiwsException::JniBadAllocException(curEnv);
352 }
353
354 curEnv->SetObjectArrayElement( name_, i, TempString);
355
356 // avoid keeping reference on to many strings
357 curEnv->DeleteLocalRef(TempString);
358 }
359 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
360
361                          curEnv->CallStaticVoidMethod(cls, voidenablejobjectArray_java_lang_Stringjava_lang_StringjbooleanbooleanID ,name_, status_);
362                         curEnv->DeleteLocalRef(stringArrayClass);
363 curEnv->DeleteLocalRef(name_);
364 curEnv->DeleteLocalRef(cls);
365 if (curEnv->ExceptionCheck()) {
366 throw GiwsException::JniCallMethodException(curEnv);
367 }
368 }
369
370 void Palette::move (JavaVM * jvm_, char const* const* source, int sourceSize, char const* const* target, int targetSize){
371
372 JNIEnv * curEnv = NULL;
373 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
374 jclass cls = curEnv->FindClass( className().c_str() );
375
376 jmethodID voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "move", "([Ljava/lang/String;[Ljava/lang/String;)V" ) ;
377 if (voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
378 throw GiwsException::JniMethodNotFoundException(curEnv, "move");
379 }
380 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
381
382 // create java array of strings.
383 jobjectArray source_ = curEnv->NewObjectArray( sourceSize, stringArrayClass, NULL);
384 if (source_ == NULL)
385 {
386 throw GiwsException::JniBadAllocException(curEnv);
387 }
388
389 // convert each char * to java strings and fill the java array.
390 for ( int i = 0; i < sourceSize; i++)
391 {
392 jstring TempString = curEnv->NewStringUTF( source[i] );
393 if (TempString == NULL)
394 {
395 throw GiwsException::JniBadAllocException(curEnv);
396 }
397
398 curEnv->SetObjectArrayElement( source_, i, TempString);
399
400 // avoid keeping reference on to many strings
401 curEnv->DeleteLocalRef(TempString);
402 }
403
404 // create java array of strings.
405 jobjectArray target_ = curEnv->NewObjectArray( targetSize, stringArrayClass, NULL);
406 if (target_ == NULL)
407 {
408 throw GiwsException::JniBadAllocException(curEnv);
409 }
410
411 // convert each char * to java strings and fill the java array.
412 for ( int i = 0; i < targetSize; i++)
413 {
414 jstring TempString = curEnv->NewStringUTF( target[i] );
415 if (TempString == NULL)
416 {
417 throw GiwsException::JniBadAllocException(curEnv);
418 }
419
420 curEnv->SetObjectArrayElement( target_, i, TempString);
421
422 // avoid keeping reference on to many strings
423 curEnv->DeleteLocalRef(TempString);
424 }
425                          curEnv->CallStaticVoidMethod(cls, voidmovejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,source_, target_);
426                         curEnv->DeleteLocalRef(stringArrayClass);
427 curEnv->DeleteLocalRef(source_);
428 curEnv->DeleteLocalRef(target_);
429 curEnv->DeleteLocalRef(cls);
430 if (curEnv->ExceptionCheck()) {
431 throw GiwsException::JniCallMethodException(curEnv);
432 }
433 }
434
435 void Palette::generatePaletteIcon (JavaVM * jvm_, char const* iconPath){
436
437 JNIEnv * curEnv = NULL;
438 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
439 jclass cls = curEnv->FindClass( className().c_str() );
440
441 jmethodID voidgeneratePaletteIconjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "generatePaletteIcon", "(Ljava/lang/String;)V" ) ;
442 if (voidgeneratePaletteIconjstringjava_lang_StringID == NULL) {
443 throw GiwsException::JniMethodNotFoundException(curEnv, "generatePaletteIcon");
444 }
445
446 jstring iconPath_ = curEnv->NewStringUTF( iconPath );
447 if (iconPath != NULL && iconPath_ == NULL)
448 {
449 throw GiwsException::JniBadAllocException(curEnv);
450 }
451
452
453                          curEnv->CallStaticVoidMethod(cls, voidgeneratePaletteIconjstringjava_lang_StringID ,iconPath_);
454                         curEnv->DeleteLocalRef(iconPath_);
455 curEnv->DeleteLocalRef(cls);
456 if (curEnv->ExceptionCheck()) {
457 throw GiwsException::JniCallMethodException(curEnv);
458 }
459 }
460
461 void Palette::generateAllImages (JavaVM * jvm_, char const* const* path, int pathSize){
462
463 JNIEnv * curEnv = NULL;
464 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
465 jclass cls = curEnv->FindClass( className().c_str() );
466
467 jmethodID voidgenerateAllImagesjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "generateAllImages", "([Ljava/lang/String;)V" ) ;
468 if (voidgenerateAllImagesjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
469 throw GiwsException::JniMethodNotFoundException(curEnv, "generateAllImages");
470 }
471 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
472
473 // create java array of strings.
474 jobjectArray path_ = curEnv->NewObjectArray( pathSize, stringArrayClass, NULL);
475 if (path_ == NULL)
476 {
477 throw GiwsException::JniBadAllocException(curEnv);
478 }
479
480 // convert each char * to java strings and fill the java array.
481 for ( int i = 0; i < pathSize; i++)
482 {
483 jstring TempString = curEnv->NewStringUTF( path[i] );
484 if (TempString == NULL)
485 {
486 throw GiwsException::JniBadAllocException(curEnv);
487 }
488
489 curEnv->SetObjectArrayElement( path_, i, TempString);
490
491 // avoid keeping reference on to many strings
492 curEnv->DeleteLocalRef(TempString);
493 }
494                          curEnv->CallStaticVoidMethod(cls, voidgenerateAllImagesjobjectArray_java_lang_Stringjava_lang_StringID ,path_);
495                         curEnv->DeleteLocalRef(stringArrayClass);
496 curEnv->DeleteLocalRef(path_);
497 curEnv->DeleteLocalRef(cls);
498 if (curEnv->ExceptionCheck()) {
499 throw GiwsException::JniCallMethodException(curEnv);
500 }
501 }
502
503 }