Help generation: add the ability to generate an image from inlined Scilab code
[scilab.git] / scilab / modules / helptools / src / jni / SciDocMain.cpp
1 #include "SciDocMain.hxx"
2 /* Generated by GIWS (version 2.0.1) with command:
3 giws -e -r -f BuildDocObjectv2.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_helptools
40 {
41
42 // Static declarations (if any)
43
44 // Returns the current env
45
46 JNIEnv * SciDocMain::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 SciDocMain::~SciDocMain()
59 {
60     JNIEnv * curEnv = NULL;
61     this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
62
63     curEnv->DeleteGlobalRef(this->instance);
64     curEnv->DeleteGlobalRef(this->instanceClass);
65 }
66 // Constructors
67 SciDocMain::SciDocMain(JavaVM * jvm_)
68 {
69     jmethodID constructObject = NULL ;
70     jobject localInstance ;
71     jclass localClass ;
72
73     const std::string construct = "<init>";
74     const std::string param = "()V";
75     jvm = jvm_;
76
77     JNIEnv * curEnv = getCurrentEnv();
78
79     localClass = curEnv->FindClass( this->className().c_str() ) ;
80     if (localClass == NULL)
81     {
82         throw GiwsException::JniClassNotFoundException(curEnv, this->className());
83     }
84
85     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
86
87     /* localClass is not needed anymore */
88     curEnv->DeleteLocalRef(localClass);
89
90     if (this->instanceClass == NULL)
91     {
92         throw GiwsException::JniObjectCreationException(curEnv, this->className());
93     }
94
95
96     constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
97     if (constructObject == NULL)
98     {
99         throw GiwsException::JniObjectCreationException(curEnv, this->className());
100     }
101
102     localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
103     if (localInstance == NULL)
104     {
105         throw GiwsException::JniObjectCreationException(curEnv, this->className());
106     }
107
108     this->instance = curEnv->NewGlobalRef(localInstance) ;
109     if (this->instance == NULL)
110     {
111         throw GiwsException::JniObjectCreationException(curEnv, this->className());
112     }
113     /* localInstance not needed anymore */
114     curEnv->DeleteLocalRef(localInstance);
115
116     /* Methods ID set to NULL */
117     voidbuildDocumentationjstringjava_lang_StringID = NULL;
118     jbooleansetOutputDirectoryjstringjava_lang_StringID = NULL;
119     voidsetWorkingLanguagejstringjava_lang_StringID = NULL;
120     voidsetExportFormatjstringjava_lang_StringID = NULL;
121     voidsetIsToolboxjbooleanbooleanID = NULL;
122     jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID = NULL;
123     voidgenerateJavahelpjstringjava_lang_Stringjstringjava_lang_StringID = NULL;
124
125
126 }
127
128 SciDocMain::SciDocMain(JavaVM * jvm_, jobject JObj)
129 {
130     jvm = jvm_;
131
132     JNIEnv * curEnv = getCurrentEnv();
133
134     jclass localClass = curEnv->GetObjectClass(JObj);
135     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
136     curEnv->DeleteLocalRef(localClass);
137
138     if (this->instanceClass == NULL)
139     {
140         throw GiwsException::JniObjectCreationException(curEnv, this->className());
141     }
142
143     this->instance = curEnv->NewGlobalRef(JObj) ;
144     if (this->instance == NULL)
145     {
146         throw GiwsException::JniObjectCreationException(curEnv, this->className());
147     }
148     /* Methods ID set to NULL */
149     voidbuildDocumentationjstringjava_lang_StringID = NULL;
150     jbooleansetOutputDirectoryjstringjava_lang_StringID = NULL;
151     voidsetWorkingLanguagejstringjava_lang_StringID = NULL;
152     voidsetExportFormatjstringjava_lang_StringID = NULL;
153     voidsetIsToolboxjbooleanbooleanID = NULL;
154     jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID = NULL;
155     voidgenerateJavahelpjstringjava_lang_Stringjstringjava_lang_StringID = NULL;
156
157
158 }
159
160 // Generic methods
161
162 void SciDocMain::synchronize()
163 {
164     if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
165     {
166         throw GiwsException::JniMonitorException(getCurrentEnv(), "SciDocMain");
167     }
168 }
169
170 void SciDocMain::endSynchronize()
171 {
172     if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
173     {
174         throw GiwsException::JniMonitorException(getCurrentEnv(), "SciDocMain");
175     }
176 }
177 // Method(s)
178
179 void SciDocMain::buildDocumentation (char const* type)
180 {
181
182     JNIEnv * curEnv = getCurrentEnv();
183
184     if (voidbuildDocumentationjstringjava_lang_StringID == NULL) /* Use the cache */
185     {
186         voidbuildDocumentationjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "buildDocumentation", "(Ljava/lang/String;)V" ) ;
187         if (voidbuildDocumentationjstringjava_lang_StringID == NULL)
188         {
189             throw GiwsException::JniMethodNotFoundException(curEnv, "buildDocumentation");
190         }
191     }
192     jstring type_ = curEnv->NewStringUTF( type );
193     if (type != NULL && type_ == NULL)
194     {
195         throw GiwsException::JniBadAllocException(curEnv);
196     }
197
198
199     curEnv->CallVoidMethod( this->instance, voidbuildDocumentationjstringjava_lang_StringID , type_);
200     curEnv->DeleteLocalRef(type_);
201
202 }
203
204 bool SciDocMain::setOutputDirectory (char const* directory)
205 {
206
207     JNIEnv * curEnv = getCurrentEnv();
208
209     if (jbooleansetOutputDirectoryjstringjava_lang_StringID == NULL) /* Use the cache */
210     {
211         jbooleansetOutputDirectoryjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "setOutputDirectory", "(Ljava/lang/String;)Z" ) ;
212         if (jbooleansetOutputDirectoryjstringjava_lang_StringID == NULL)
213         {
214             throw GiwsException::JniMethodNotFoundException(curEnv, "setOutputDirectory");
215         }
216     }
217     jstring directory_ = curEnv->NewStringUTF( directory );
218     if (directory != NULL && directory_ == NULL)
219     {
220         throw GiwsException::JniBadAllocException(curEnv);
221     }
222
223
224     jboolean res =  static_cast<jboolean>( curEnv->CallBooleanMethod( this->instance, jbooleansetOutputDirectoryjstringjava_lang_StringID , directory_));
225     curEnv->DeleteLocalRef(directory_);
226
227     return (res == JNI_TRUE);
228
229 }
230
231 void SciDocMain::setWorkingLanguage (char const* language)
232 {
233
234     JNIEnv * curEnv = getCurrentEnv();
235
236     if (voidsetWorkingLanguagejstringjava_lang_StringID == NULL) /* Use the cache */
237     {
238         voidsetWorkingLanguagejstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "setWorkingLanguage", "(Ljava/lang/String;)V" ) ;
239         if (voidsetWorkingLanguagejstringjava_lang_StringID == NULL)
240         {
241             throw GiwsException::JniMethodNotFoundException(curEnv, "setWorkingLanguage");
242         }
243     }
244     jstring language_ = curEnv->NewStringUTF( language );
245     if (language != NULL && language_ == NULL)
246     {
247         throw GiwsException::JniBadAllocException(curEnv);
248     }
249
250
251     curEnv->CallVoidMethod( this->instance, voidsetWorkingLanguagejstringjava_lang_StringID , language_);
252     curEnv->DeleteLocalRef(language_);
253
254 }
255
256 void SciDocMain::setExportFormat (char const* format)
257 {
258
259     JNIEnv * curEnv = getCurrentEnv();
260
261     if (voidsetExportFormatjstringjava_lang_StringID == NULL) /* Use the cache */
262     {
263         voidsetExportFormatjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "setExportFormat", "(Ljava/lang/String;)V" ) ;
264         if (voidsetExportFormatjstringjava_lang_StringID == NULL)
265         {
266             throw GiwsException::JniMethodNotFoundException(curEnv, "setExportFormat");
267         }
268     }
269     jstring format_ = curEnv->NewStringUTF( format );
270     if (format != NULL && format_ == NULL)
271     {
272         throw GiwsException::JniBadAllocException(curEnv);
273     }
274
275
276     curEnv->CallVoidMethod( this->instance, voidsetExportFormatjstringjava_lang_StringID , format_);
277     curEnv->DeleteLocalRef(format_);
278
279 }
280
281 void SciDocMain::setIsToolbox (bool isToolbox)
282 {
283
284     JNIEnv * curEnv = getCurrentEnv();
285
286     if (voidsetIsToolboxjbooleanbooleanID == NULL) /* Use the cache */
287     {
288         voidsetIsToolboxjbooleanbooleanID = curEnv->GetMethodID(this->instanceClass, "setIsToolbox", "(Z)V" ) ;
289         if (voidsetIsToolboxjbooleanbooleanID == NULL)
290         {
291             throw GiwsException::JniMethodNotFoundException(curEnv, "setIsToolbox");
292         }
293     }
294     jboolean isToolbox_ = (static_cast<bool>(isToolbox) ? JNI_TRUE : JNI_FALSE);
295
296     curEnv->CallVoidMethod( this->instance, voidsetIsToolboxjbooleanbooleanID , isToolbox_);
297
298 }
299
300 char* SciDocMain::process (char const* sourceDoc, char const* styleSheet)
301 {
302
303     JNIEnv * curEnv = getCurrentEnv();
304
305     if (jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID == NULL) /* Use the cache */
306     {
307         jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "process", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;" ) ;
308         if (jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID == NULL)
309         {
310             throw GiwsException::JniMethodNotFoundException(curEnv, "process");
311         }
312     }
313     jstring sourceDoc_ = curEnv->NewStringUTF( sourceDoc );
314     if (sourceDoc != NULL && sourceDoc_ == NULL)
315     {
316         throw GiwsException::JniBadAllocException(curEnv);
317     }
318
319
320     jstring styleSheet_ = curEnv->NewStringUTF( styleSheet );
321     if (styleSheet != NULL && styleSheet_ == NULL)
322     {
323         throw GiwsException::JniBadAllocException(curEnv);
324     }
325
326
327     jstring res =  static_cast<jstring>( curEnv->CallObjectMethod( this->instance, jstringprocessjstringjava_lang_Stringjstringjava_lang_StringID , sourceDoc_, styleSheet_));
328     if (curEnv->ExceptionCheck())
329     {
330         throw GiwsException::JniCallMethodException(curEnv);
331     }
332     if (res != NULL)
333     {
334
335         const char *tempString = curEnv->GetStringUTFChars(res, 0);
336         char * myStringBuffer = new char[strlen(tempString) + 1];
337         strcpy(myStringBuffer, tempString);
338         curEnv->ReleaseStringUTFChars(res, tempString);
339         curEnv->DeleteLocalRef(res);
340         curEnv->DeleteLocalRef(sourceDoc_);
341         curEnv->DeleteLocalRef(styleSheet_);
342
343         return myStringBuffer;
344     }
345     else
346     {
347         curEnv->DeleteLocalRef(res);
348         return NULL;
349     }
350 }
351
352 void SciDocMain::generateJavahelp (JavaVM * jvm_, char const* outputDir, char const* language)
353 {
354
355     JNIEnv * curEnv = NULL;
356     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
357     jclass cls = curEnv->FindClass( className().c_str() );
358
359     jmethodID voidgenerateJavahelpjstringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "generateJavahelp", "(Ljava/lang/String;Ljava/lang/String;)V" ) ;
360     if (voidgenerateJavahelpjstringjava_lang_Stringjstringjava_lang_StringID == NULL)
361     {
362         throw GiwsException::JniMethodNotFoundException(curEnv, "generateJavahelp");
363     }
364
365     jstring outputDir_ = curEnv->NewStringUTF( outputDir );
366     if (outputDir != NULL && outputDir_ == NULL)
367     {
368         throw GiwsException::JniBadAllocException(curEnv);
369     }
370
371
372     jstring language_ = curEnv->NewStringUTF( language );
373     if (language != NULL && language_ == NULL)
374     {
375         throw GiwsException::JniBadAllocException(curEnv);
376     }
377
378
379     curEnv->CallStaticVoidMethod(cls, voidgenerateJavahelpjstringjava_lang_Stringjstringjava_lang_StringID , outputDir_, language_);
380     curEnv->DeleteLocalRef(outputDir_);
381     curEnv->DeleteLocalRef(language_);
382     curEnv->DeleteLocalRef(cls);
383     if (curEnv->ExceptionCheck())
384     {
385         throw GiwsException::JniCallMethodException(curEnv);
386     }
387 }
388
389 }