1 /* 2 * Copyright (c) 2004, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include <stdlib.h> 27 #include <string.h> 28 #include <unistd.h> 29 #include <dlfcn.h> 30 31 #include <jni.h> 32 #include <sizecalc.h> 33 #include "sun_awt_UNIXToolkit.h" 34 35 #ifndef HEADLESS 36 #include "awt.h" 37 #include "gtk_interface.h" 38 #endif /* !HEADLESS */ 39 40 41 static jclass this_class = NULL; 42 static jmethodID icon_upcall_method = NULL; 43 44 45 /* 46 * Class: sun_awt_UNIXToolkit 47 * Method: check_gtk 48 * Signature: (I)Z 49 */ 50 JNIEXPORT jboolean JNICALL 51 Java_sun_awt_UNIXToolkit_check_1gtk(JNIEnv *env, jclass klass, jint version) { 52 #ifndef HEADLESS 53 return (jboolean)gtk_check_version(version); 54 #else 55 return JNI_FALSE; 56 #endif /* !HEADLESS */ 57 } 58 59 60 /* 61 * Class: sun_awt_UNIXToolkit 62 * Method: load_gtk 63 * Signature: (I)Z 64 */ 65 JNIEXPORT jboolean JNICALL 66 Java_sun_awt_UNIXToolkit_load_1gtk(JNIEnv *env, jclass klass, jint version, 67 jboolean verbose) { 68 #ifndef HEADLESS 69 return (jboolean)gtk_load(env, version, verbose); 70 #else 71 return JNI_FALSE; 72 #endif /* !HEADLESS */ 73 } 74 75 76 /* 77 * Class: sun_awt_UNIXToolkit 78 * Method: unload_gtk 79 * Signature: ()Z 80 */ 81 JNIEXPORT jboolean JNICALL 82 Java_sun_awt_UNIXToolkit_unload_1gtk(JNIEnv *env, jclass klass) 83 { 84 #ifndef HEADLESS 85 return (jboolean)gtk->unload(); 86 #else 87 return JNI_FALSE; 88 #endif /* !HEADLESS */ 89 } 90 91 jboolean init_method(JNIEnv *env, jobject this) 92 { 93 if (this_class == NULL) { 94 this_class = (*env)->NewGlobalRef(env, 95 (*env)->GetObjectClass(env, this)); 96 icon_upcall_method = (*env)->GetMethodID(env, this_class, 97 "loadIconCallback", "([BIIIIIZ)V"); 98 CHECK_NULL_RETURN(icon_upcall_method, JNI_FALSE); 99 } 100 return JNI_TRUE; 101 } 102 103 /* 104 * Class: sun_awt_UNIXToolkit 105 * Method: load_gtk_icon 106 * Signature: (Ljava/lang/String)Z 107 * 108 * This method assumes that GTK libs are present. 109 */ 110 JNIEXPORT jboolean JNICALL 111 Java_sun_awt_UNIXToolkit_load_1gtk_1icon(JNIEnv *env, jobject this, 112 jstring filename) 113 { 114 #ifndef HEADLESS 115 int len; 116 char *filename_str = NULL; 117 GError **error = NULL; 118 119 if (filename == NULL) 120 { 121 return JNI_FALSE; 122 } 123 124 len = (*env)->GetStringUTFLength(env, filename); 125 filename_str = (char *)SAFE_SIZE_ARRAY_ALLOC(malloc, 126 sizeof(char), len + 1); 127 if (filename_str == NULL) { 128 JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError"); 129 return JNI_FALSE; 130 } 131 if (!init_method(env, this) ) { 132 free(filename_str); 133 return JNI_FALSE; 134 } 135 (*env)->GetStringUTFRegion(env, filename, 0, len, filename_str); 136 jboolean result = gtk->get_file_icon_data(env, filename_str, error, 137 icon_upcall_method, this); 138 139 /* Release the strings we've allocated. */ 140 free(filename_str); 141 142 return result; 143 #else /* HEADLESS */ 144 return JNI_FALSE; 145 #endif /* !HEADLESS */ 146 } 147 148 /* 149 * Class: sun_awt_UNIXToolkit 150 * Method: load_stock_icon 151 * Signature: (ILjava/lang/String;IILjava/lang/String;)Z 152 * 153 * This method assumes that GTK libs are present. 154 */ 155 JNIEXPORT jboolean JNICALL 156 Java_sun_awt_UNIXToolkit_load_1stock_1icon(JNIEnv *env, jobject this, 157 jint widget_type, jstring stock_id, jint icon_size, 158 jint text_direction, jstring detail) 159 { 160 #ifndef HEADLESS 161 int len; 162 char *stock_id_str = NULL; 163 char *detail_str = NULL; 164 165 if (stock_id == NULL) 166 { 167 return JNI_FALSE; 168 } 169 170 len = (*env)->GetStringUTFLength(env, stock_id); 171 stock_id_str = (char *)SAFE_SIZE_ARRAY_ALLOC(malloc, 172 sizeof(char), len + 1); 173 if (stock_id_str == NULL) { 174 JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError"); 175 return JNI_FALSE; 176 } 177 (*env)->GetStringUTFRegion(env, stock_id, 0, len, stock_id_str); 178 179 /* Detail isn't required so check for NULL. */ 180 if (detail != NULL) 181 { 182 len = (*env)->GetStringUTFLength(env, detail); 183 detail_str = (char *)SAFE_SIZE_ARRAY_ALLOC(malloc, 184 sizeof(char), len + 1); 185 if (detail_str == NULL) { 186 JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError"); 187 return JNI_FALSE; 188 } 189 (*env)->GetStringUTFRegion(env, detail, 0, len, detail_str); 190 } 191 192 if (!init_method(env, this) ) { 193 return JNI_FALSE; 194 } 195 jboolean result = gtk->get_icon_data(env, widget_type, stock_id_str, 196 icon_size, text_direction, detail_str, 197 icon_upcall_method, this); 198 199 /* Release the strings we've allocated. */ 200 free(stock_id_str); 201 if (detail_str != NULL) 202 { 203 free(detail_str); 204 } 205 return result; 206 #else /* HEADLESS */ 207 return JNI_FALSE; 208 #endif /* !HEADLESS */ 209 } 210 211 /* 212 * Class: sun_awt_UNIXToolkit 213 * Method: nativeSync 214 * Signature: ()V 215 */ 216 JNIEXPORT void JNICALL 217 Java_sun_awt_UNIXToolkit_nativeSync(JNIEnv *env, jobject this) 218 { 219 #ifndef HEADLESS 220 AWT_LOCK(); 221 XSync(awt_display, False); 222 AWT_UNLOCK(); 223 #endif /* !HEADLESS */ 224 } 225 226 /* 227 * Class: sun_awt_SunToolkit 228 * Method: closeSplashScreen 229 * Signature: ()V 230 */ 231 JNIEXPORT void JNICALL 232 Java_sun_awt_SunToolkit_closeSplashScreen(JNIEnv *env, jclass cls) 233 { 234 typedef void (*SplashClose_t)(); 235 SplashClose_t splashClose; 236 void* hSplashLib = dlopen(0, RTLD_LAZY); 237 if (!hSplashLib) { 238 return; 239 } 240 splashClose = (SplashClose_t)dlsym(hSplashLib, 241 "SplashClose"); 242 if (splashClose) { 243 splashClose(); 244 } 245 dlclose(hSplashLib); 246 } 247 248 /* 249 * Class: sun_awt_UNIXToolkit 250 * Method: gtkCheckVersionImpl 251 * Signature: (III)Ljava/lang/String; 252 */ 253 JNIEXPORT jboolean JNICALL 254 Java_sun_awt_UNIXToolkit_gtkCheckVersionImpl(JNIEnv *env, jobject this, 255 jint major, jint minor, jint micro) 256 { 257 char *ret; 258 259 ret = gtk->gtk_check_version(major, minor, micro); 260 if (ret == NULL) { 261 return TRUE; 262 } 263 264 return FALSE; 265 } 266 267 /* 268 * Class: sun_awt_UNIXToolkit 269 * Method: get_gtk_version 270 * Signature: ()I 271 */ 272 JNIEXPORT jint JNICALL 273 Java_sun_awt_UNIXToolkit_get_1gtk_1version(JNIEnv *env, jclass klass) 274 { 275 #ifndef HEADLESS 276 return gtk ? gtk->version : GTK_ANY; 277 #else 278 return GTK_ANY; 279 #endif /* !HEADLESS */ 280 }