Update giws files with version 2.0.2 to improve performances:
[scilab.git] / scilab / modules / console / src / jni / CallScilabBridge.cpp
1 #include "CallScilabBridge.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/CallScilabBridge.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_gui_bridge
40 {
41
42 // Static declarations (if any)
43
44 // Returns the current env
45
46 JNIEnv * CallScilabBridge::getCurrentEnv()
47 {
48     JNIEnv * curEnv = NULL;
49     jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
50     if (res != JNI_OK)
51     {
52         throw GiwsException::JniException(getCurrentEnv());
53     }
54     return curEnv;
55 }
56 // Destructor
57
58 CallScilabBridge::~CallScilabBridge()
59 {
60     JNIEnv * curEnv = NULL;
61     this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
62     curEnv->DeleteGlobalRef(this->instance);
63     curEnv->DeleteGlobalRef(this->instanceClass);
64 }
65 // Constructors
66 CallScilabBridge::CallScilabBridge(JavaVM * jvm_)
67 {
68     jmethodID constructObject = NULL ;
69     jobject localInstance ;
70     jclass localClass ;
71
72     const std::string construct = "<init>";
73     const std::string param = "()V";
74     jvm = jvm_;
75
76     JNIEnv * curEnv = getCurrentEnv();
77
78     localClass = curEnv->FindClass( this->className().c_str() ) ;
79     if (localClass == NULL)
80     {
81         throw GiwsException::JniClassNotFoundException(curEnv, this->className());
82     }
83
84     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
85
86     /* localClass is not needed anymore */
87     curEnv->DeleteLocalRef(localClass);
88
89     if (this->instanceClass == NULL)
90     {
91         throw GiwsException::JniObjectCreationException(curEnv, this->className());
92     }
93
94
95     constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
96     if (constructObject == NULL)
97     {
98         throw GiwsException::JniObjectCreationException(curEnv, this->className());
99     }
100
101     localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
102     if (localInstance == NULL)
103     {
104         throw GiwsException::JniObjectCreationException(curEnv, this->className());
105     }
106
107     this->instance = curEnv->NewGlobalRef(localInstance) ;
108     if (this->instance == NULL)
109     {
110         throw GiwsException::JniObjectCreationException(curEnv, this->className());
111     }
112     /* localInstance not needed anymore */
113     curEnv->DeleteLocalRef(localInstance);
114
115     /* Methods ID set to NULL */
116     voiddisplayjstringjava_lang_StringID = NULL;
117     jstringreadLineID = NULL;
118     voidclearID = NULL;
119     voidclearjintintID = NULL;
120     jintgetCharWithoutOutputID = NULL;
121     voidtoHomeID = NULL;
122     voidscilabLinesUpdateID = NULL;
123     voidsetPromptjstringjava_lang_StringID = NULL;
124     jbooleanisWaitingForInputID = NULL;
125
126
127 }
128
129 CallScilabBridge::CallScilabBridge(JavaVM * jvm_, jobject JObj)
130 {
131     jvm = jvm_;
132
133     JNIEnv * curEnv = getCurrentEnv();
134
135     jclass localClass = curEnv->GetObjectClass(JObj);
136     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
137     curEnv->DeleteLocalRef(localClass);
138
139     if (this->instanceClass == NULL)
140     {
141         throw GiwsException::JniObjectCreationException(curEnv, this->className());
142     }
143
144     this->instance = curEnv->NewGlobalRef(JObj) ;
145     if (this->instance == NULL)
146     {
147         throw GiwsException::JniObjectCreationException(curEnv, this->className());
148     }
149     /* Methods ID set to NULL */
150     voiddisplayjstringjava_lang_StringID = NULL;
151     jstringreadLineID = NULL;
152     voidclearID = NULL;
153     voidclearjintintID = NULL;
154     jintgetCharWithoutOutputID = NULL;
155     voidtoHomeID = NULL;
156     voidscilabLinesUpdateID = NULL;
157     voidsetPromptjstringjava_lang_StringID = NULL;
158     jbooleanisWaitingForInputID = NULL;
159
160
161 }
162
163 // Generic methods
164
165 void CallScilabBridge::synchronize()
166 {
167     if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
168     {
169         throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
170     }
171 }
172
173 void CallScilabBridge::endSynchronize()
174 {
175     if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
176     {
177         throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
178     }
179 }
180 // Method(s)
181
182 void CallScilabBridge::display (JavaVM * jvm_, char const* dataToDisplay)
183 {
184
185     JNIEnv * curEnv = NULL;
186     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
187     jclass cls = initClass(curEnv);
188     if ( cls == NULL)
189     {
190         throw GiwsException::JniCallMethodException(curEnv);
191     }
192
193     static jmethodID voiddisplayjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "display", "(Ljava/lang/String;)V" ) ;
194     if (voiddisplayjstringjava_lang_StringID == NULL)
195     {
196         throw GiwsException::JniMethodNotFoundException(curEnv, "display");
197     }
198
199     jstring dataToDisplay_ = curEnv->NewStringUTF( dataToDisplay );
200     if (dataToDisplay != NULL && dataToDisplay_ == NULL)
201     {
202         throw GiwsException::JniBadAllocException(curEnv);
203     }
204
205
206     curEnv->CallStaticVoidMethod(cls, voiddisplayjstringjava_lang_StringID , dataToDisplay_);
207     curEnv->DeleteLocalRef(dataToDisplay_);
208     if (curEnv->ExceptionCheck())
209     {
210         throw GiwsException::JniCallMethodException(curEnv);
211     }
212 }
213
214 char* CallScilabBridge::readLine (JavaVM * jvm_)
215 {
216
217     JNIEnv * curEnv = NULL;
218     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
219     jclass cls = initClass(curEnv);
220     if ( cls == NULL)
221     {
222         throw GiwsException::JniCallMethodException(curEnv);
223     }
224
225     static jmethodID jstringreadLineID = curEnv->GetStaticMethodID(cls, "readLine", "()Ljava/lang/String;" ) ;
226     if (jstringreadLineID == NULL)
227     {
228
229         jvm_->DetachCurrentThread();
230         throw GiwsException::JniMethodNotFoundException(curEnv, "readLine");
231     }
232
233     jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringreadLineID ));
234     if (curEnv->ExceptionCheck())
235     {
236
237         jvm_->DetachCurrentThread();
238         throw GiwsException::JniCallMethodException(curEnv);
239     }
240     if (res != NULL)
241     {
242
243         const char *tempString = curEnv->GetStringUTFChars(res, 0);
244         char * myStringBuffer = new char[strlen(tempString) + 1];
245         strcpy(myStringBuffer, tempString);
246         curEnv->ReleaseStringUTFChars(res, tempString);
247         curEnv->DeleteLocalRef(res);
248         if (curEnv->ExceptionCheck())
249         {
250             delete[] myStringBuffer;
251
252             jvm_->DetachCurrentThread();
253             throw GiwsException::JniCallMethodException(curEnv);
254         }
255         jvm_->DetachCurrentThread();
256
257         return myStringBuffer;
258     }
259     else
260     {
261         curEnv->DeleteLocalRef(res);
262         return NULL;
263     }
264 }
265
266 void CallScilabBridge::clear (JavaVM * jvm_)
267 {
268
269     JNIEnv * curEnv = NULL;
270     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
271     jclass cls = initClass(curEnv);
272     if ( cls == NULL)
273     {
274         throw GiwsException::JniCallMethodException(curEnv);
275     }
276
277     static jmethodID voidclearID = curEnv->GetStaticMethodID(cls, "clear", "()V" ) ;
278     if (voidclearID == NULL)
279     {
280         throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
281     }
282
283     curEnv->CallStaticVoidMethod(cls, voidclearID );
284     if (curEnv->ExceptionCheck())
285     {
286         throw GiwsException::JniCallMethodException(curEnv);
287     }
288 }
289
290 void CallScilabBridge::clear (JavaVM * jvm_, int nbLines)
291 {
292
293     JNIEnv * curEnv = NULL;
294     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
295     jclass cls = initClass(curEnv);
296     if ( cls == NULL)
297     {
298         throw GiwsException::JniCallMethodException(curEnv);
299     }
300
301     static jmethodID voidclearjintintID = curEnv->GetStaticMethodID(cls, "clear", "(I)V" ) ;
302     if (voidclearjintintID == NULL)
303     {
304         throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
305     }
306
307     curEnv->CallStaticVoidMethod(cls, voidclearjintintID , nbLines);
308     if (curEnv->ExceptionCheck())
309     {
310         throw GiwsException::JniCallMethodException(curEnv);
311     }
312 }
313
314 int CallScilabBridge::getCharWithoutOutput (JavaVM * jvm_)
315 {
316
317     JNIEnv * curEnv = NULL;
318     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
319     jclass cls = initClass(curEnv);
320     if ( cls == NULL)
321     {
322         throw GiwsException::JniCallMethodException(curEnv);
323     }
324
325     static jmethodID jintgetCharWithoutOutputID = curEnv->GetStaticMethodID(cls, "getCharWithoutOutput", "()I" ) ;
326     if (jintgetCharWithoutOutputID == NULL)
327     {
328         throw GiwsException::JniMethodNotFoundException(curEnv, "getCharWithoutOutput");
329     }
330
331     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetCharWithoutOutputID ));
332     if (curEnv->ExceptionCheck())
333     {
334         throw GiwsException::JniCallMethodException(curEnv);
335     }
336     return res;
337
338 }
339
340 void CallScilabBridge::toHome (JavaVM * jvm_)
341 {
342
343     JNIEnv * curEnv = NULL;
344     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
345     jclass cls = initClass(curEnv);
346     if ( cls == NULL)
347     {
348         throw GiwsException::JniCallMethodException(curEnv);
349     }
350
351     static jmethodID voidtoHomeID = curEnv->GetStaticMethodID(cls, "toHome", "()V" ) ;
352     if (voidtoHomeID == NULL)
353     {
354         throw GiwsException::JniMethodNotFoundException(curEnv, "toHome");
355     }
356
357     curEnv->CallStaticVoidMethod(cls, voidtoHomeID );
358     if (curEnv->ExceptionCheck())
359     {
360         throw GiwsException::JniCallMethodException(curEnv);
361     }
362 }
363
364 void CallScilabBridge::scilabLinesUpdate (JavaVM * jvm_)
365 {
366
367     JNIEnv * curEnv = NULL;
368     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
369     jclass cls = initClass(curEnv);
370     if ( cls == NULL)
371     {
372         throw GiwsException::JniCallMethodException(curEnv);
373     }
374
375     static jmethodID voidscilabLinesUpdateID = curEnv->GetStaticMethodID(cls, "scilabLinesUpdate", "()V" ) ;
376     if (voidscilabLinesUpdateID == NULL)
377     {
378         throw GiwsException::JniMethodNotFoundException(curEnv, "scilabLinesUpdate");
379     }
380
381     curEnv->CallStaticVoidMethod(cls, voidscilabLinesUpdateID );
382     if (curEnv->ExceptionCheck())
383     {
384         throw GiwsException::JniCallMethodException(curEnv);
385     }
386 }
387
388 void CallScilabBridge::setPrompt (JavaVM * jvm_, char const* promptToSet)
389 {
390
391     JNIEnv * curEnv = NULL;
392     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
393     jclass cls = initClass(curEnv);
394     if ( cls == NULL)
395     {
396         throw GiwsException::JniCallMethodException(curEnv);
397     }
398
399     static jmethodID voidsetPromptjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPrompt", "(Ljava/lang/String;)V" ) ;
400     if (voidsetPromptjstringjava_lang_StringID == NULL)
401     {
402         throw GiwsException::JniMethodNotFoundException(curEnv, "setPrompt");
403     }
404
405     jstring promptToSet_ = curEnv->NewStringUTF( promptToSet );
406     if (promptToSet != NULL && promptToSet_ == NULL)
407     {
408         throw GiwsException::JniBadAllocException(curEnv);
409     }
410
411
412     curEnv->CallStaticVoidMethod(cls, voidsetPromptjstringjava_lang_StringID , promptToSet_);
413     curEnv->DeleteLocalRef(promptToSet_);
414     if (curEnv->ExceptionCheck())
415     {
416         throw GiwsException::JniCallMethodException(curEnv);
417     }
418 }
419
420 bool CallScilabBridge::isWaitingForInput (JavaVM * jvm_)
421 {
422
423     JNIEnv * curEnv = NULL;
424     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
425     jclass cls = initClass(curEnv);
426     if ( cls == NULL)
427     {
428         throw GiwsException::JniCallMethodException(curEnv);
429     }
430
431     static jmethodID jbooleanisWaitingForInputID = curEnv->GetStaticMethodID(cls, "isWaitingForInput", "()Z" ) ;
432     if (jbooleanisWaitingForInputID == NULL)
433     {
434         throw GiwsException::JniMethodNotFoundException(curEnv, "isWaitingForInput");
435     }
436
437     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWaitingForInputID ));
438     if (curEnv->ExceptionCheck())
439     {
440         throw GiwsException::JniCallMethodException(curEnv);
441     }
442     return (res == JNI_TRUE);
443
444 }
445
446 }