mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-28 14:31:10 +00:00
57dd3ef80f
2000-05-02 Tor Lillqvist <tml@iki.fi> * gdk/win32/gdkdrawable-win32.c (gdk_win32_draw_arc): Don't try to draw too narrow or too low arcs, they seem to fail, at least with some display drivers. * gdk/gdk.c (gdk_init_check): Use G_DIR_SEPARATOR.
694 lines
17 KiB
C
694 lines
17 KiB
C
/* 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 <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "gdk.h"
|
|
#include "gdkinternals.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], G_DIR_SEPARATOR);
|
|
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 ();
|
|
}
|
|
|