/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #include #include #include "gdk.h" #include "gdkprivate.h" #ifndef HAVE_XCONVERTCASE #include "gdkkeysyms.h" #endif typedef struct _GdkPredicate GdkPredicate; typedef struct _GdkErrorTrap GdkErrorTrap; struct _GdkPredicate { GdkEventFunc func; gpointer data; }; struct _GdkErrorTrap { gint error_warnings; gint error_code; }; /* * Private function declarations */ static void gdk_exit_func (void); GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev, GdkEvent *event, gpointer data); /* Private variable declarations */ static int gdk_initialized = 0; /* 1 if the library is initialized, * 0 otherwise. */ static GSList *gdk_error_traps = NULL; /* List of error traps */ static GSList *gdk_error_trap_free_list = NULL; /* Free list */ #ifdef G_ENABLE_DEBUG static const GDebugKey gdk_debug_keys[] = { {"events", GDK_DEBUG_EVENTS}, {"misc", GDK_DEBUG_MISC}, {"dnd", GDK_DEBUG_DND}, {"color-context", GDK_DEBUG_COLOR_CONTEXT}, {"xim", GDK_DEBUG_XIM} }; static const int gdk_ndebug_keys = sizeof(gdk_debug_keys)/sizeof(GDebugKey); #endif /* G_ENABLE_DEBUG */ GdkArgContext * gdk_arg_context_new (gpointer cb_data) { GdkArgContext *result = g_new (GdkArgContext, 1); result->tables = g_ptr_array_new (); result->cb_data = cb_data; return result; } void gdk_arg_context_destroy (GdkArgContext *context) { g_ptr_array_free (context->tables, TRUE); g_free (context); } void gdk_arg_context_add_table (GdkArgContext *context, GdkArgDesc *table) { g_ptr_array_add (context->tables, table); } void gdk_arg_context_parse (GdkArgContext *context, gint *argc, gchar ***argv) { int i, j, k; /* Save a copy of the original argc and argv */ if (argc && argv) { for (i = 1; i < *argc; i++) { char *arg; if (!(*argv)[i][0] == '-' && (*argv)[i][1] == '-') continue; arg = (*argv)[i] + 2; /* '--' terminates list of arguments */ if (arg == 0) { (*argv)[i] = NULL; break; } for (j = 0; j < context->tables->len; j++) { GdkArgDesc *table = context->tables->pdata[j]; for (k = 0; table[k].name; k++) { switch (table[k].type) { case GDK_ARG_STRING: case GDK_ARG_CALLBACK: case GDK_ARG_INT: { int len = strlen (table[k].name); if (strncmp (arg, table[k].name, len) == 0 && (arg[len] == '=' || argc[len] == 0)) { char *value = NULL; (*argv)[i] = NULL; if (arg[len] == '=') value = arg + len + 1; else if (i < *argc - 1) { value = (*argv)[i + 1]; (*argv)[i+1] = NULL; i++; } else value = ""; switch (table[k].type) { case GDK_ARG_STRING: *(gchar **)table[k].location = g_strdup (value); break; case GDK_ARG_INT: *(gint *)table[k].location = atoi (value); break; case GDK_ARG_CALLBACK: (*table[k].callback)(table[k].name, value, context->cb_data); break; default: ; } goto next_arg; } break; } case GDK_ARG_BOOL: case GDK_ARG_NOBOOL: if (strcmp (arg, table[k].name) == 0) { (*argv)[i] = NULL; *(gboolean *)table[k].location = (table[k].type == GDK_ARG_BOOL) ? TRUE : FALSE; goto next_arg; } } } } next_arg: ; } for (i = 1; i < *argc; i++) { for (k = i; k < *argc; k++) if ((*argv)[k] != NULL) break; if (k > i) { k -= i; for (j = i + k; j < *argc; j++) (*argv)[j-k] = (*argv)[j]; *argc -= k; } } } } static void gdk_arg_debug_cb (const char *key, const char *value, gpointer user_data) { gdk_debug_flags |= g_parse_debug_string (value, (GDebugKey *) gdk_debug_keys, gdk_ndebug_keys); } static void gdk_arg_no_debug_cb (const char *key, const char *value, gpointer user_data) { gdk_debug_flags &= ~g_parse_debug_string (value, (GDebugKey *) gdk_debug_keys, gdk_ndebug_keys); } static void gdk_arg_name_cb (const char *key, const char *value, gpointer user_data) { g_set_prgname (value); } static GdkArgDesc gdk_args[] = { { "name", GDK_ARG_STRING, NULL, gdk_arg_name_cb }, #ifdef G_ENABLE_DEBUG { "gdk-debug", GDK_ARG_CALLBACK, NULL, gdk_arg_debug_cb }, { "gdk-no-debug", GDK_ARG_CALLBACK, NULL, gdk_arg_no_debug_cb }, #endif /* G_ENABLE_DEBUG */ { NULL } }; /* *-------------------------------------------------------------- * gdk_init_check * * Initialize the library for use. * * Arguments: * "argc" is the number of arguments. * "argv" is an array of strings. * * Results: * "argc" and "argv" are modified to reflect any arguments * which were not handled. (Such arguments should either * be handled by the application or dismissed). If initialization * fails, returns FALSE, otherwise TRUE. * * Side effects: * The library is initialized. * *-------------------------------------------------------------- */ gboolean gdk_init_check (int *argc, char ***argv) { gchar **argv_orig = NULL; gint argc_orig = 0; GdkArgContext *arg_context; gboolean result; int i; if (gdk_initialized) return TRUE; if (g_thread_supported ()) gdk_threads_mutex = g_mutex_new (); if (argc && argv) { argc_orig = *argc; argv_orig = g_malloc ((argc_orig + 1) * sizeof (char*)); for (i = 0; i < argc_orig; i++) argv_orig[i] = g_strdup ((*argv)[i]); argv_orig[argc_orig] = NULL; if (*argc > 0) { gchar *d; d = strrchr((*argv)[0],'/'); if (d != NULL) g_set_prgname (d + 1); else g_set_prgname ((*argv)[0]); } } #ifdef G_ENABLE_DEBUG { gchar *debug_string = getenv("GDK_DEBUG"); if (debug_string != NULL) gdk_debug_flags = g_parse_debug_string (debug_string, (GDebugKey *) gdk_debug_keys, gdk_ndebug_keys); } #endif /* G_ENABLE_DEBUG */ arg_context = gdk_arg_context_new (NULL); gdk_arg_context_add_table (arg_context, gdk_args); gdk_arg_context_add_table (arg_context, _gdk_windowing_args); gdk_arg_context_parse (arg_context, argc, argv); gdk_arg_context_destroy (arg_context); GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ())); result = _gdk_windowing_init_check (argc_orig, argv_orig); for (i = 0; i < argc_orig; i++) g_free(argv_orig[i]); g_free(argv_orig); if (!result) return FALSE; g_atexit (gdk_exit_func); gdk_events_init (); gdk_visual_init (); gdk_window_init (); gdk_image_init (); gdk_input_init (); gdk_dnd_init (); #ifdef USE_XIM gdk_im_open (); #endif gdk_initialized = 1; return TRUE; } void gdk_init (int *argc, char ***argv) { if (!gdk_init_check (argc, argv)) { g_warning ("cannot open display: %s", gdk_get_display ()); exit(1); } } /* *-------------------------------------------------------------- * gdk_exit * * Restores the library to an un-itialized state and exits * the program using the "exit" system call. * * Arguments: * "errorcode" is the error value to pass to "exit". * * Results: * Allocated structures are freed and the program exits * cleanly. * * Side effects: * *-------------------------------------------------------------- */ void gdk_exit (gint errorcode) { /* de-initialisation is done by the gdk_exit_funct(), no need to do this here (Alex J.) */ exit (errorcode); } /* *-------------------------------------------------------------- * gdk_exit_func * * This is the "atexit" function that makes sure the * library gets a chance to cleanup. * * Arguments: * * Results: * * Side effects: * The library is un-initialized and the program exits. * *-------------------------------------------------------------- */ static void gdk_exit_func (void) { static gboolean in_gdk_exit_func = FALSE; /* This is to avoid an infinite loop if a program segfaults in an atexit() handler (and yes, it does happen, especially if a program has trounced over memory too badly for even g_message to work) */ if (in_gdk_exit_func == TRUE) return; in_gdk_exit_func = TRUE; if (gdk_initialized) { #ifdef USE_XIM /* cleanup IC */ gdk_ic_cleanup (); /* close IM */ gdk_im_close (); #endif gdk_image_exit (); gdk_input_exit (); gdk_key_repeat_restore (); gdk_initialized = 0; } } /************************************************************* * gdk_error_trap_push: * Push an error trap. X errors will be trapped until * the corresponding gdk_error_pop(), which will return * the error code, if any. * arguments: * * results: *************************************************************/ void gdk_error_trap_push (void) { GSList *node; GdkErrorTrap *trap; if (gdk_error_trap_free_list) { node = gdk_error_trap_free_list; gdk_error_trap_free_list = gdk_error_trap_free_list->next; } else { node = g_slist_alloc (); node->data = g_new (GdkErrorTrap, 1); } node->next = gdk_error_traps; gdk_error_traps = node; trap = node->data; trap->error_code = gdk_error_code; trap->error_warnings = gdk_error_warnings; gdk_error_code = 0; gdk_error_warnings = 0; } /************************************************************* * gdk_error_trap_pop: * Pop an error trap added with gdk_error_push() * arguments: * * results: * 0, if no error occured, otherwise the error code. *************************************************************/ gint gdk_error_trap_pop (void) { GSList *node; GdkErrorTrap *trap; gint result; g_return_val_if_fail (gdk_error_traps != NULL, 0); node = gdk_error_traps; gdk_error_traps = gdk_error_traps->next; node->next = gdk_error_trap_free_list; gdk_error_trap_free_list = node; result = gdk_error_code; trap = node->data; gdk_error_code = trap->error_code; gdk_error_warnings = trap->error_warnings; return result; } #ifndef HAVE_XCONVERTCASE /* compatibility function from X11R6.3, since XConvertCase is not * supplied by X11R5. */ void gdk_keyval_convert_case (guint symbol, guint *lower, guint *upper) { guint xlower = symbol; guint xupper = symbol; switch (symbol >> 8) { #if defined (GDK_A) && defined (GDK_Ooblique) case 0: /* Latin 1 */ if ((symbol >= GDK_A) && (symbol <= GDK_Z)) xlower += (GDK_a - GDK_A); else if ((symbol >= GDK_a) && (symbol <= GDK_z)) xupper -= (GDK_a - GDK_A); else if ((symbol >= GDK_Agrave) && (symbol <= GDK_Odiaeresis)) xlower += (GDK_agrave - GDK_Agrave); else if ((symbol >= GDK_agrave) && (symbol <= GDK_odiaeresis)) xupper -= (GDK_agrave - GDK_Agrave); else if ((symbol >= GDK_Ooblique) && (symbol <= GDK_Thorn)) xlower += (GDK_oslash - GDK_Ooblique); else if ((symbol >= GDK_oslash) && (symbol <= GDK_thorn)) xupper -= (GDK_oslash - GDK_Ooblique); break; #endif /* LATIN1 */ #if defined (GDK_Aogonek) && defined (GDK_tcedilla) case 1: /* Latin 2 */ /* Assume the KeySym is a legal value (ignore discontinuities) */ if (symbol == GDK_Aogonek) xlower = GDK_aogonek; else if (symbol >= GDK_Lstroke && symbol <= GDK_Sacute) xlower += (GDK_lstroke - GDK_Lstroke); else if (symbol >= GDK_Scaron && symbol <= GDK_Zacute) xlower += (GDK_scaron - GDK_Scaron); else if (symbol >= GDK_Zcaron && symbol <= GDK_Zabovedot) xlower += (GDK_zcaron - GDK_Zcaron); else if (symbol == GDK_aogonek) xupper = GDK_Aogonek; else if (symbol >= GDK_lstroke && symbol <= GDK_sacute) xupper -= (GDK_lstroke - GDK_Lstroke); else if (symbol >= GDK_scaron && symbol <= GDK_zacute) xupper -= (GDK_scaron - GDK_Scaron); else if (symbol >= GDK_zcaron && symbol <= GDK_zabovedot) xupper -= (GDK_zcaron - GDK_Zcaron); else if (symbol >= GDK_Racute && symbol <= GDK_Tcedilla) xlower += (GDK_racute - GDK_Racute); else if (symbol >= GDK_racute && symbol <= GDK_tcedilla) xupper -= (GDK_racute - GDK_Racute); break; #endif /* LATIN2 */ #if defined (GDK_Hstroke) && defined (GDK_Cabovedot) case 2: /* Latin 3 */ /* Assume the KeySym is a legal value (ignore discontinuities) */ if (symbol >= GDK_Hstroke && symbol <= GDK_Hcircumflex) xlower += (GDK_hstroke - GDK_Hstroke); else if (symbol >= GDK_Gbreve && symbol <= GDK_Jcircumflex) xlower += (GDK_gbreve - GDK_Gbreve); else if (symbol >= GDK_hstroke && symbol <= GDK_hcircumflex) xupper -= (GDK_hstroke - GDK_Hstroke); else if (symbol >= GDK_gbreve && symbol <= GDK_jcircumflex) xupper -= (GDK_gbreve - GDK_Gbreve); else if (symbol >= GDK_Cabovedot && symbol <= GDK_Scircumflex) xlower += (GDK_cabovedot - GDK_Cabovedot); else if (symbol >= GDK_cabovedot && symbol <= GDK_scircumflex) xupper -= (GDK_cabovedot - GDK_Cabovedot); break; #endif /* LATIN3 */ #if defined (GDK_Rcedilla) && defined (GDK_Amacron) case 3: /* Latin 4 */ /* Assume the KeySym is a legal value (ignore discontinuities) */ if (symbol >= GDK_Rcedilla && symbol <= GDK_Tslash) xlower += (GDK_rcedilla - GDK_Rcedilla); else if (symbol >= GDK_rcedilla && symbol <= GDK_tslash) xupper -= (GDK_rcedilla - GDK_Rcedilla); else if (symbol == GDK_ENG) xlower = GDK_eng; else if (symbol == GDK_eng) xupper = GDK_ENG; else if (symbol >= GDK_Amacron && symbol <= GDK_Umacron) xlower += (GDK_amacron - GDK_Amacron); else if (symbol >= GDK_amacron && symbol <= GDK_umacron) xupper -= (GDK_amacron - GDK_Amacron); break; #endif /* LATIN4 */ #if defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu) case 6: /* Cyrillic */ /* Assume the KeySym is a legal value (ignore discontinuities) */ if (symbol >= GDK_Serbian_DJE && symbol <= GDK_Serbian_DZE) xlower -= (GDK_Serbian_DJE - GDK_Serbian_dje); else if (symbol >= GDK_Serbian_dje && symbol <= GDK_Serbian_dze) xupper += (GDK_Serbian_DJE - GDK_Serbian_dje); else if (symbol >= GDK_Cyrillic_YU && symbol <= GDK_Cyrillic_HARDSIGN) xlower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu); else if (symbol >= GDK_Cyrillic_yu && symbol <= GDK_Cyrillic_hardsign) xupper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu); break; #endif /* CYRILLIC */ #if defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma) case 7: /* Greek */ /* Assume the KeySym is a legal value (ignore discontinuities) */ if (symbol >= GDK_Greek_ALPHAaccent && symbol <= GDK_Greek_OMEGAaccent) xlower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent); else if (symbol >= GDK_Greek_alphaaccent && symbol <= GDK_Greek_omegaaccent && symbol != GDK_Greek_iotaaccentdieresis && symbol != GDK_Greek_upsilonaccentdieresis) xupper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent); else if (symbol >= GDK_Greek_ALPHA && symbol <= GDK_Greek_OMEGA) xlower += (GDK_Greek_alpha - GDK_Greek_ALPHA); else if (symbol >= GDK_Greek_alpha && symbol <= GDK_Greek_omega && symbol != GDK_Greek_finalsmallsigma) xupper -= (GDK_Greek_alpha - GDK_Greek_ALPHA); break; #endif /* GREEK */ } if (lower) *lower = xlower; if (upper) *upper = xupper; } #endif guint gdk_keyval_to_upper (guint keyval) { guint result; gdk_keyval_convert_case (keyval, NULL, &result); return result; } guint gdk_keyval_to_lower (guint keyval) { guint result; gdk_keyval_convert_case (keyval, &result, NULL); return result; } gboolean gdk_keyval_is_upper (guint keyval) { if (keyval) { guint upper_val = 0; gdk_keyval_convert_case (keyval, NULL, &upper_val); return upper_val == keyval; } return FALSE; } gboolean gdk_keyval_is_lower (guint keyval) { if (keyval) { guint lower_val = 0; gdk_keyval_convert_case (keyval, &lower_val, NULL); return lower_val == keyval; } return FALSE; } void gdk_threads_enter () { GDK_THREADS_ENTER (); } void gdk_threads_leave () { GDK_THREADS_LEAVE (); }