Plug rubberbox function :
[scilab.git] / scilab / modules / renderer / src / jni / XlFontManager.cpp
1 #include "XlFontManager.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/XlFontManager.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_renderer_utils_textRendering {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * XlFontManager::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 XlFontManager::~XlFontManager() {
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 }
62 // Constructors
63 XlFontManager::XlFontManager(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 jobjectArray_getInstalledFontsNameID=NULL;
108 jintgetSizeInstalledFontsNameID=NULL;
109 jintgetSizeAvailableFontsNameID=NULL;
110 jobjectArray_getAvailableFontsNameID=NULL;
111 jbooleanisAvailableFontNamejstringjava_lang_StringID=NULL;
112 jintaddFontjstringjava_lang_StringID=NULL;
113 jintchangeFontjintintjstringjava_lang_StringID=NULL;
114 jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID=NULL;
115 voidresetXlFontManagerID=NULL;
116 jintaddFontFromFilenamejstringjava_lang_StringID=NULL;
117 jintchangeFontFromFilenamejintintjstringjava_lang_StringID=NULL;
118
119
120 }
121
122 XlFontManager::XlFontManager(JavaVM * jvm_, jobject JObj) {
123         jvm=jvm_;
124
125         JNIEnv * curEnv = getCurrentEnv();
126
127 jclass localClass = curEnv->GetObjectClass(JObj);
128         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
129         curEnv->DeleteLocalRef(localClass);
130
131         if (this->instanceClass == NULL) {
132 throw GiwsException::JniObjectCreationException(curEnv, this->className());
133         }
134
135         this->instance = curEnv->NewGlobalRef(JObj) ;
136         if(this->instance == NULL){
137 throw GiwsException::JniObjectCreationException(curEnv, this->className());
138         }
139         /* Methods ID set to NULL */
140         jobjectArray_getInstalledFontsNameID=NULL;
141 jintgetSizeInstalledFontsNameID=NULL;
142 jintgetSizeAvailableFontsNameID=NULL;
143 jobjectArray_getAvailableFontsNameID=NULL;
144 jbooleanisAvailableFontNamejstringjava_lang_StringID=NULL;
145 jintaddFontjstringjava_lang_StringID=NULL;
146 jintchangeFontjintintjstringjava_lang_StringID=NULL;
147 jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID=NULL;
148 voidresetXlFontManagerID=NULL;
149 jintaddFontFromFilenamejstringjava_lang_StringID=NULL;
150 jintchangeFontFromFilenamejintintjstringjava_lang_StringID=NULL;
151
152
153 }
154
155 // Generic methods
156
157 void XlFontManager::synchronize() {
158 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
159 throw GiwsException::JniMonitorException(getCurrentEnv(), "XlFontManager");
160 }
161 }
162
163 void XlFontManager::endSynchronize() {
164 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
165 throw GiwsException::JniMonitorException(getCurrentEnv(), "XlFontManager");
166 }
167 }
168 // Method(s)
169
170 char** XlFontManager::getInstalledFontsName (){
171
172 JNIEnv * curEnv = getCurrentEnv();
173
174 if (jobjectArray_getInstalledFontsNameID==NULL) { /* Use the cache */
175  jobjectArray_getInstalledFontsNameID = curEnv->GetMethodID(this->instanceClass, "getInstalledFontsName", "()[Ljava/lang/String;" ) ;
176 if (jobjectArray_getInstalledFontsNameID == NULL) {
177 throw GiwsException::JniMethodNotFoundException(curEnv, "getInstalledFontsName");
178 }
179 }
180                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallObjectMethod( this->instance, jobjectArray_getInstalledFontsNameID ));
181                         if (curEnv->ExceptionCheck()) {
182 throw GiwsException::JniCallMethodException(curEnv);
183 }int lenRow;
184  lenRow = curEnv->GetArrayLength(res);
185
186 char **arrayOfString;
187 arrayOfString = new char *[lenRow];
188 for (jsize i = 0; i < lenRow; i++){
189 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
190 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
191 arrayOfString[i] = new char[strlen(tempString) + 1];
192
193 strcpy(arrayOfString[i], tempString);
194 curEnv->ReleaseStringUTFChars(resString, tempString);
195 curEnv->DeleteLocalRef(resString);
196 }
197
198 curEnv->DeleteLocalRef(res);
199 return arrayOfString;
200
201 }
202
203 int XlFontManager::getSizeInstalledFontsName (){
204
205 JNIEnv * curEnv = getCurrentEnv();
206
207 if (jintgetSizeInstalledFontsNameID==NULL) { /* Use the cache */
208  jintgetSizeInstalledFontsNameID = curEnv->GetMethodID(this->instanceClass, "getSizeInstalledFontsName", "()I" ) ;
209 if (jintgetSizeInstalledFontsNameID == NULL) {
210 throw GiwsException::JniMethodNotFoundException(curEnv, "getSizeInstalledFontsName");
211 }
212 }
213                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintgetSizeInstalledFontsNameID ));
214                         
215 return res;
216
217 }
218
219 int XlFontManager::getSizeAvailableFontsName (){
220
221 JNIEnv * curEnv = getCurrentEnv();
222
223 if (jintgetSizeAvailableFontsNameID==NULL) { /* Use the cache */
224  jintgetSizeAvailableFontsNameID = curEnv->GetMethodID(this->instanceClass, "getSizeAvailableFontsName", "()I" ) ;
225 if (jintgetSizeAvailableFontsNameID == NULL) {
226 throw GiwsException::JniMethodNotFoundException(curEnv, "getSizeAvailableFontsName");
227 }
228 }
229                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintgetSizeAvailableFontsNameID ));
230                         
231 return res;
232
233 }
234
235 char** XlFontManager::getAvailableFontsName (){
236
237 JNIEnv * curEnv = getCurrentEnv();
238
239 if (jobjectArray_getAvailableFontsNameID==NULL) { /* Use the cache */
240  jobjectArray_getAvailableFontsNameID = curEnv->GetMethodID(this->instanceClass, "getAvailableFontsName", "()[Ljava/lang/String;" ) ;
241 if (jobjectArray_getAvailableFontsNameID == NULL) {
242 throw GiwsException::JniMethodNotFoundException(curEnv, "getAvailableFontsName");
243 }
244 }
245                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallObjectMethod( this->instance, jobjectArray_getAvailableFontsNameID ));
246                         if (curEnv->ExceptionCheck()) {
247 throw GiwsException::JniCallMethodException(curEnv);
248 }int lenRow;
249  lenRow = curEnv->GetArrayLength(res);
250
251 char **arrayOfString;
252 arrayOfString = new char *[lenRow];
253 for (jsize i = 0; i < lenRow; i++){
254 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
255 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
256 arrayOfString[i] = new char[strlen(tempString) + 1];
257
258 strcpy(arrayOfString[i], tempString);
259 curEnv->ReleaseStringUTFChars(resString, tempString);
260 curEnv->DeleteLocalRef(resString);
261 }
262
263 curEnv->DeleteLocalRef(res);
264 return arrayOfString;
265
266 }
267
268 bool XlFontManager::isAvailableFontName (char const* fontname){
269
270 JNIEnv * curEnv = getCurrentEnv();
271
272 if (jbooleanisAvailableFontNamejstringjava_lang_StringID==NULL) { /* Use the cache */
273  jbooleanisAvailableFontNamejstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "isAvailableFontName", "(Ljava/lang/String;)Z" ) ;
274 if (jbooleanisAvailableFontNamejstringjava_lang_StringID == NULL) {
275 throw GiwsException::JniMethodNotFoundException(curEnv, "isAvailableFontName");
276 }
277 }
278 jstring fontname_ = curEnv->NewStringUTF( fontname );
279 if (fontname != NULL && fontname_ == NULL)
280 {
281 throw GiwsException::JniBadAllocException(curEnv);
282 }
283
284
285                         jboolean res =  static_cast<jboolean>( curEnv->CallBooleanMethod( this->instance, jbooleanisAvailableFontNamejstringjava_lang_StringID ,fontname_));
286                         curEnv->DeleteLocalRef(fontname_);
287
288 return (res == JNI_TRUE);
289
290 }
291
292 int XlFontManager::addFont (char const* fontName){
293
294 JNIEnv * curEnv = getCurrentEnv();
295
296 if (jintaddFontjstringjava_lang_StringID==NULL) { /* Use the cache */
297  jintaddFontjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "addFont", "(Ljava/lang/String;)I" ) ;
298 if (jintaddFontjstringjava_lang_StringID == NULL) {
299 throw GiwsException::JniMethodNotFoundException(curEnv, "addFont");
300 }
301 }
302 jstring fontName_ = curEnv->NewStringUTF( fontName );
303 if (fontName != NULL && fontName_ == NULL)
304 {
305 throw GiwsException::JniBadAllocException(curEnv);
306 }
307
308
309                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintaddFontjstringjava_lang_StringID ,fontName_));
310                         curEnv->DeleteLocalRef(fontName_);
311
312 return res;
313
314 }
315
316 int XlFontManager::changeFont (int index, char const* fontName){
317
318 JNIEnv * curEnv = getCurrentEnv();
319
320 if (jintchangeFontjintintjstringjava_lang_StringID==NULL) { /* Use the cache */
321  jintchangeFontjintintjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "changeFont", "(ILjava/lang/String;)I" ) ;
322 if (jintchangeFontjintintjstringjava_lang_StringID == NULL) {
323 throw GiwsException::JniMethodNotFoundException(curEnv, "changeFont");
324 }
325 }
326 jstring fontName_ = curEnv->NewStringUTF( fontName );
327 if (fontName != NULL && fontName_ == NULL)
328 {
329 throw GiwsException::JniBadAllocException(curEnv);
330 }
331
332
333                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintchangeFontjintintjstringjava_lang_StringID ,index, fontName_));
334                         curEnv->DeleteLocalRef(fontName_);
335
336 return res;
337
338 }
339
340 int XlFontManager::changeFontWithProperty (int index, char const* fontName, bool isBold, bool isItalic){
341
342 JNIEnv * curEnv = getCurrentEnv();
343
344 if (jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID==NULL) { /* Use the cache */
345  jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID = curEnv->GetMethodID(this->instanceClass, "changeFontWithProperty", "(ILjava/lang/String;ZZ)I" ) ;
346 if (jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID == NULL) {
347 throw GiwsException::JniMethodNotFoundException(curEnv, "changeFontWithProperty");
348 }
349 }
350 jstring fontName_ = curEnv->NewStringUTF( fontName );
351 if (fontName != NULL && fontName_ == NULL)
352 {
353 throw GiwsException::JniBadAllocException(curEnv);
354 }
355
356
357 jboolean isBold_ = (static_cast<bool>(isBold) ? JNI_TRUE : JNI_FALSE);
358
359 jboolean isItalic_ = (static_cast<bool>(isItalic) ? JNI_TRUE : JNI_FALSE);
360
361                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintchangeFontWithPropertyjintintjstringjava_lang_StringjbooleanbooleanjbooleanbooleanID ,index, fontName_, isBold_, isItalic_));
362                         curEnv->DeleteLocalRef(fontName_);
363
364 return res;
365
366 }
367
368 void XlFontManager::resetXlFontManager (){
369
370 JNIEnv * curEnv = getCurrentEnv();
371
372 if (voidresetXlFontManagerID==NULL) { /* Use the cache */
373  voidresetXlFontManagerID = curEnv->GetMethodID(this->instanceClass, "resetXlFontManager", "()V" ) ;
374 if (voidresetXlFontManagerID == NULL) {
375 throw GiwsException::JniMethodNotFoundException(curEnv, "resetXlFontManager");
376 }
377 }
378                          curEnv->CallVoidMethod( this->instance, voidresetXlFontManagerID );
379                         
380 }
381
382 int XlFontManager::addFontFromFilename (char const* FontFilename){
383
384 JNIEnv * curEnv = getCurrentEnv();
385
386 if (jintaddFontFromFilenamejstringjava_lang_StringID==NULL) { /* Use the cache */
387  jintaddFontFromFilenamejstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "addFontFromFilename", "(Ljava/lang/String;)I" ) ;
388 if (jintaddFontFromFilenamejstringjava_lang_StringID == NULL) {
389 throw GiwsException::JniMethodNotFoundException(curEnv, "addFontFromFilename");
390 }
391 }
392 jstring FontFilename_ = curEnv->NewStringUTF( FontFilename );
393 if (FontFilename != NULL && FontFilename_ == NULL)
394 {
395 throw GiwsException::JniBadAllocException(curEnv);
396 }
397
398
399                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintaddFontFromFilenamejstringjava_lang_StringID ,FontFilename_));
400                         curEnv->DeleteLocalRef(FontFilename_);
401
402 return res;
403
404 }
405
406 int XlFontManager::changeFontFromFilename (int index, char const* FontFilename){
407
408 JNIEnv * curEnv = getCurrentEnv();
409
410 if (jintchangeFontFromFilenamejintintjstringjava_lang_StringID==NULL) { /* Use the cache */
411  jintchangeFontFromFilenamejintintjstringjava_lang_StringID = curEnv->GetMethodID(this->instanceClass, "changeFontFromFilename", "(ILjava/lang/String;)I" ) ;
412 if (jintchangeFontFromFilenamejintintjstringjava_lang_StringID == NULL) {
413 throw GiwsException::JniMethodNotFoundException(curEnv, "changeFontFromFilename");
414 }
415 }
416 jstring FontFilename_ = curEnv->NewStringUTF( FontFilename );
417 if (FontFilename != NULL && FontFilename_ == NULL)
418 {
419 throw GiwsException::JniBadAllocException(curEnv);
420 }
421
422
423                         jint res =  static_cast<jint>( curEnv->CallIntMethod( this->instance, jintchangeFontFromFilenamejintintjstringjava_lang_StringID ,index, FontFilename_));
424                         curEnv->DeleteLocalRef(FontFilename_);
425
426 return res;
427
428 }
429
430 }