reorder children in save/load from xml
[scilab.git] / scilab / modules / graphic_objects / src / jni / CallXmlLoader.cpp
1 #include "CallXmlLoader.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws --disable-return-size-array --output-dir . --throws-exception-on-error --description-file graphic_objects.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_graphic_objects {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * CallXmlLoader::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 CallXmlLoader::~CallXmlLoader() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58 curEnv->DeleteGlobalRef(this->instance);
59 curEnv->DeleteGlobalRef(this->instanceClass);
60 }
61 // Constructors
62 CallXmlLoader::CallXmlLoader(JavaVM * jvm_) {
63 jmethodID constructObject = NULL ;
64 jobject localInstance ;
65 jclass localClass ;
66
67 const std::string construct="<init>";
68 const std::string param="()V";
69 jvm=jvm_;
70
71 JNIEnv * curEnv = getCurrentEnv();
72
73 localClass = curEnv->FindClass( this->className().c_str() ) ;
74 if (localClass == NULL) {
75   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
76 }
77
78 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
79
80 /* localClass is not needed anymore */
81 curEnv->DeleteLocalRef(localClass);
82
83 if (this->instanceClass == NULL) {
84 throw GiwsException::JniObjectCreationException(curEnv, this->className());
85 }
86
87
88 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
89 if(constructObject == NULL){
90 throw GiwsException::JniObjectCreationException(curEnv, this->className());
91 }
92
93 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
94 if(localInstance == NULL){
95 throw GiwsException::JniObjectCreationException(curEnv, this->className());
96 }
97  
98 this->instance = curEnv->NewGlobalRef(localInstance) ;
99 if(this->instance == NULL){
100 throw GiwsException::JniObjectCreationException(curEnv, this->className());
101 }
102 /* localInstance not needed anymore */
103 curEnv->DeleteLocalRef(localInstance);
104
105                 /* Methods ID set to NULL */
106 jintLoadjstringjava_lang_StringID=NULL;
107 jstringSavejintintjstringjava_lang_StringjbooleanbooleanID=NULL;
108 jintDomLoadjstringjava_lang_StringID=NULL;
109
110
111 }
112
113 CallXmlLoader::CallXmlLoader(JavaVM * jvm_, jobject JObj) {
114         jvm=jvm_;
115
116         JNIEnv * curEnv = getCurrentEnv();
117
118 jclass localClass = curEnv->GetObjectClass(JObj);
119         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
120         curEnv->DeleteLocalRef(localClass);
121
122         if (this->instanceClass == NULL) {
123 throw GiwsException::JniObjectCreationException(curEnv, this->className());
124         }
125
126         this->instance = curEnv->NewGlobalRef(JObj) ;
127         if(this->instance == NULL){
128 throw GiwsException::JniObjectCreationException(curEnv, this->className());
129         }
130         /* Methods ID set to NULL */
131         jintLoadjstringjava_lang_StringID=NULL;
132 jstringSavejintintjstringjava_lang_StringjbooleanbooleanID=NULL;
133 jintDomLoadjstringjava_lang_StringID=NULL;
134
135
136 }
137
138 // Generic methods
139
140 void CallXmlLoader::synchronize() {
141 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
142 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallXmlLoader");
143 }
144 }
145
146 void CallXmlLoader::endSynchronize() {
147 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
148 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallXmlLoader");
149 }
150 }
151 // Method(s)
152
153 int CallXmlLoader::Load (JavaVM * jvm_, char const* filename){
154
155 JNIEnv * curEnv = NULL;
156 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
157 jclass cls = initClass(curEnv);
158 if ( cls == NULL) {
159 throw GiwsException::JniCallMethodException(curEnv);
160 }
161
162 static jmethodID jintLoadjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "Load", "(Ljava/lang/String;)I" ) ;
163 if (jintLoadjstringjava_lang_StringID == NULL) {
164 throw GiwsException::JniMethodNotFoundException(curEnv, "Load");
165 }
166
167 jstring filename_ = curEnv->NewStringUTF( filename );
168 if (filename != NULL && filename_ == NULL)
169 {
170 throw GiwsException::JniBadAllocException(curEnv);
171 }
172
173
174                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintLoadjstringjava_lang_StringID ,filename_));
175                         curEnv->DeleteLocalRef(filename_);
176 if (curEnv->ExceptionCheck()) {
177 throw GiwsException::JniCallMethodException(curEnv);
178 }
179 return res;
180
181 }
182
183 char* CallXmlLoader::Save (JavaVM * jvm_, int figure, char const* filename, bool isReverse){
184
185 JNIEnv * curEnv = NULL;
186 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
187 jclass cls = initClass(curEnv);
188 if ( cls == NULL) {
189 throw GiwsException::JniCallMethodException(curEnv);
190 }
191
192 static jmethodID jstringSavejintintjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "Save", "(ILjava/lang/String;Z)Ljava/lang/String;" ) ;
193 if (jstringSavejintintjstringjava_lang_StringjbooleanbooleanID == NULL) {
194 throw GiwsException::JniMethodNotFoundException(curEnv, "Save");
195 }
196
197 jstring filename_ = curEnv->NewStringUTF( filename );
198 if (filename != NULL && filename_ == NULL)
199 {
200 throw GiwsException::JniBadAllocException(curEnv);
201 }
202
203
204 jboolean isReverse_ = (static_cast<bool>(isReverse) ? JNI_TRUE : JNI_FALSE);
205
206                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringSavejintintjstringjava_lang_StringjbooleanbooleanID ,figure, filename_, isReverse_));
207                         if (curEnv->ExceptionCheck()) {
208 throw GiwsException::JniCallMethodException(curEnv);
209 }if (res != NULL) { 
210
211 const char *tempString = curEnv->GetStringUTFChars(res, 0);
212 char * myStringBuffer = new char[strlen(tempString) + 1];
213 strcpy(myStringBuffer, tempString);
214 curEnv->ReleaseStringUTFChars(res, tempString);
215 curEnv->DeleteLocalRef(res);
216 curEnv->DeleteLocalRef(filename_);
217 if (curEnv->ExceptionCheck()) {
218 delete[] myStringBuffer;
219                                 throw GiwsException::JniCallMethodException(curEnv);
220 }
221 return myStringBuffer;
222  } else { 
223 curEnv->DeleteLocalRef(res);
224 return NULL;
225 }
226 }
227
228 int CallXmlLoader::DomLoad (JavaVM * jvm_, char const* filename){
229
230 JNIEnv * curEnv = NULL;
231 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
232 jclass cls = initClass(curEnv);
233 if ( cls == NULL) {
234 throw GiwsException::JniCallMethodException(curEnv);
235 }
236
237 static jmethodID jintDomLoadjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "DomLoad", "(Ljava/lang/String;)I" ) ;
238 if (jintDomLoadjstringjava_lang_StringID == NULL) {
239 throw GiwsException::JniMethodNotFoundException(curEnv, "DomLoad");
240 }
241
242 jstring filename_ = curEnv->NewStringUTF( filename );
243 if (filename != NULL && filename_ == NULL)
244 {
245 throw GiwsException::JniBadAllocException(curEnv);
246 }
247
248
249                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintDomLoadjstringjava_lang_StringID ,filename_));
250                         curEnv->DeleteLocalRef(filename_);
251 if (curEnv->ExceptionCheck()) {
252 throw GiwsException::JniCallMethodException(curEnv);
253 }
254 return res;
255
256 }
257
258 }