forked from AuroraMiddleware/gtk
00c5e83871
1999-10-31 Tor Lillqvist <tml@iki.fi> * gdk/gdkkeysyms.h: Add new keysyms from X11R6.4 (including EuroSign). * gdk/gdktypes.h: Add note about wchar_t not necessarily being the same type as GdkWChar, especially on Win32. * gdk/win32/*.c: Change gdk_root_parent to be a pointer. * gdk/win32/*.c: Assume all strings are UTF-8. Convert to Unicode before passing to Windows GDI for drawing etc. Convert to the system default codepage before passing to Windows as window titles. * gdk/win32/gdkprivate.h: Add more fields to GdkWindowPrivate to support changing input locale on the fly. * gdk/win32/gdkevent.c: Support input language (keyboard locale) on-the-fly changes. Convert incoming characters from the current codepage to Unicode (and then to a UTF-8 multi-byte string) based on the current input language. Use keysym<->Unicode mapping tables and functions borrowed from xterm sources. Support IMEs (Input Method Editors) for CJK languages. On non-CJK editions of Win9x, use the ActiveX-based Active IMM (Input Method Manager) if available. IMEs and the Active IMM are available under the disguise of Chinese, Korean and Japanese support for IE and Outlook Express from "Windows Update" for Win98. On Win2k, the CJK support is present in all editions (as long as you install it). Call DispatchMessage from gdk_events_queue() (and thus gdk_WindowProc()), instead of duplicating the code in gdk_WindowProc(). Reworked the grab handling and propagation code, factored out duplicated code snippets into separate functions. Other cleanups, too. * gdk/win32/surrogate-dimm.h: Provide just the bits we need from the <dimm.h> header describing the Active IMM. * gdk/win32/gdkfont.c: Pretend to support fontsets, but so far just do the same as for "single" fonts. * gdk/win32/gdk.c: Call CoInitialize() (COM initialisation) from gdk_init_check, and CoUninitialize() from gdk_exit_func. Handle the new keysyms from gdkkeysyms.h. * gtk/gtkfontsel.c (Win32): Load the font for the preview as a fontset, so that gtkentry uses wide characters. * gtk/gtkrc.c (Win32): Get the locale with gwin_getlocale(). Call GTk+'s system directory "gtk+", not "gtk".
404 lines
10 KiB
C
404 lines
10 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 <gdk/gdk.h>
|
|
#include "gdkx.h"
|
|
|
|
/* We emulate the GDK_SELECTION window properties by storing
|
|
* it's data in a per-window hashtable.
|
|
*/
|
|
|
|
typedef struct {
|
|
guchar *data;
|
|
gint length;
|
|
gint format;
|
|
GdkAtom type;
|
|
} GdkSelProp;
|
|
|
|
static GHashTable *sel_prop_table = NULL;
|
|
|
|
void
|
|
gdk_selection_init (void)
|
|
{
|
|
if (sel_prop_table == NULL)
|
|
sel_prop_table = g_hash_table_new (g_int_hash, g_int_equal);
|
|
}
|
|
|
|
void
|
|
gdk_sel_prop_store (GdkWindow *owner,
|
|
GdkAtom type,
|
|
gint format,
|
|
guchar *data,
|
|
gint length)
|
|
{
|
|
GdkSelProp *prop;
|
|
|
|
prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (owner));
|
|
if (prop != NULL)
|
|
{
|
|
g_free (prop->data);
|
|
g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (owner));
|
|
}
|
|
prop = g_new (GdkSelProp, 1);
|
|
prop->data = data;
|
|
prop->length = length;
|
|
prop->format = format;
|
|
prop->type = type;
|
|
g_hash_table_insert (sel_prop_table, &GDK_DRAWABLE_XID (owner), prop);
|
|
}
|
|
|
|
gint
|
|
gdk_selection_owner_set (GdkWindow *owner,
|
|
GdkAtom selection,
|
|
guint32 time,
|
|
gint send_event)
|
|
{
|
|
gchar *sel_name;
|
|
HWND xwindow;
|
|
|
|
GDK_NOTE (SELECTION,
|
|
(sel_name = gdk_atom_name (selection),
|
|
g_print ("gdk_selection_owner_set: %#x %#x (%s)\n",
|
|
(owner ? GDK_DRAWABLE_XID (owner) : 0),
|
|
selection, sel_name),
|
|
g_free (sel_name)));
|
|
|
|
if (selection != gdk_clipboard_atom)
|
|
return FALSE;
|
|
|
|
if (owner != NULL)
|
|
xwindow = GDK_DRAWABLE_XID (owner);
|
|
else
|
|
xwindow = NULL;
|
|
|
|
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n", xwindow));
|
|
if (!OpenClipboard (xwindow))
|
|
{
|
|
g_warning ("gdk_selection_owner_set: OpenClipboard failed");
|
|
return FALSE;
|
|
}
|
|
GDK_NOTE (SELECTION, g_print ("...EmptyClipboard()\n"));
|
|
if (!EmptyClipboard ())
|
|
{
|
|
g_warning ("gdk_selection_owner_set: EmptyClipboard failed");
|
|
CloseClipboard ();
|
|
return FALSE;
|
|
}
|
|
#if 0
|
|
/* No delayed rendering */
|
|
if (xwindow != NULL)
|
|
SetClipboardData (CF_TEXT, NULL);
|
|
#endif
|
|
GDK_NOTE (SELECTION, g_print ("...CloseClipboard()\n"));
|
|
if (!CloseClipboard ())
|
|
{
|
|
g_warning ("gdk_selection_owner_set: CloseClipboard failed");
|
|
return FALSE;
|
|
}
|
|
if (owner != NULL)
|
|
{
|
|
/* Send ourselves an ersatz selection request message so that
|
|
* gdk_property_change will be called to store the clipboard data.
|
|
*/
|
|
SendMessage (xwindow, gdk_selection_request_msg,
|
|
selection, 0);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GdkWindow*
|
|
gdk_selection_owner_get (GdkAtom selection)
|
|
{
|
|
GdkWindow *window;
|
|
gchar *sel_name;
|
|
|
|
#if 1
|
|
/* XXX Hmm, gtk selections seem to work best with this. This causes
|
|
* gtk to always get the clipboard contents from Windows, and not
|
|
* from the editable's own stashed-away copy.
|
|
*/
|
|
return NULL;
|
|
#else
|
|
if (selection != gdk_clipboard_atom)
|
|
window = NULL;
|
|
else
|
|
window = gdk_window_lookup (GetClipboardOwner ());
|
|
|
|
#endif
|
|
|
|
GDK_NOTE (SELECTION,
|
|
(sel_name = gdk_atom_name (selection),
|
|
g_print ("gdk_selection_owner_get: %#x (%s) = %#x\n",
|
|
selection, sel_name,
|
|
(window ? GDK_DRAWABLE_XID (window) : 0)),
|
|
g_free (sel_name)));
|
|
|
|
return window;
|
|
}
|
|
|
|
void
|
|
gdk_selection_convert (GdkWindow *requestor,
|
|
GdkAtom selection,
|
|
GdkAtom target,
|
|
guint32 time)
|
|
{
|
|
HGLOBAL hdata;
|
|
GdkSelProp *prop;
|
|
guchar *ptr, *data, *datap, *p;
|
|
guint i, length, slength;
|
|
gchar *sel_name, *tgt_name;
|
|
|
|
g_return_if_fail (requestor != NULL);
|
|
if (GDK_DRAWABLE_DESTROYED (requestor))
|
|
return;
|
|
|
|
GDK_NOTE (SELECTION,
|
|
(sel_name = gdk_atom_name (selection),
|
|
tgt_name = gdk_atom_name (target),
|
|
g_print ("gdk_selection_convert: %#x %#x (%s) %#x (%s)\n",
|
|
GDK_DRAWABLE_XID (requestor), selection, sel_name, target, tgt_name),
|
|
g_free (sel_name),
|
|
g_free (tgt_name)));
|
|
|
|
if (selection == gdk_clipboard_atom)
|
|
{
|
|
/* Converting the CLIPBOARD selection means he wants the
|
|
* contents of the clipboard. Get the clipboard data,
|
|
* and store it for later.
|
|
*/
|
|
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n",
|
|
GDK_DRAWABLE_XID (requestor)));
|
|
if (!OpenClipboard (GDK_DRAWABLE_XID (requestor)))
|
|
{
|
|
g_warning ("gdk_selection_convert: OpenClipboard failed");
|
|
return;
|
|
}
|
|
|
|
GDK_NOTE (SELECTION, g_print ("...GetClipboardData(CF_TEXT)\n"));
|
|
if ((hdata = GetClipboardData (CF_TEXT)) != NULL)
|
|
{
|
|
if ((ptr = GlobalLock (hdata)) != NULL)
|
|
{
|
|
length = GlobalSize (hdata);
|
|
|
|
GDK_NOTE (SELECTION, g_print ("...got data: %d bytes: %.10s\n",
|
|
length, ptr));
|
|
|
|
slength = 0;
|
|
p = ptr;
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
if (*p == '\0')
|
|
break;
|
|
else if (*p != '\r')
|
|
slength++;
|
|
p++;
|
|
}
|
|
|
|
data = datap = g_malloc (slength + 1);
|
|
p = ptr;
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
if (*p == '\0')
|
|
break;
|
|
else if (*p != '\r')
|
|
*datap++ = *p;
|
|
p++;
|
|
}
|
|
*datap++ = '\0';
|
|
gdk_sel_prop_store (requestor, GDK_TARGET_STRING, 8,
|
|
data, strlen (data) + 1);
|
|
|
|
GlobalUnlock (hdata);
|
|
}
|
|
}
|
|
GDK_NOTE (SELECTION, g_print ("...CloseClipboard()\n"));
|
|
CloseClipboard ();
|
|
|
|
|
|
/* Send ourselves an ersatz selection notify message so that we actually
|
|
* fetch the data.
|
|
*/
|
|
SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
|
|
}
|
|
else if (selection == gdk_win32_dropfiles_atom)
|
|
{
|
|
/* This means he wants the names of the dropped files.
|
|
* gdk_dropfiles_filter already has stored the text/uri-list
|
|
* data, tempoarily on gdk_root_parent's selection "property".
|
|
*/
|
|
GdkSelProp *prop;
|
|
|
|
prop = g_hash_table_lookup (sel_prop_table, &gdk_root_parent->drawable.xwindow);
|
|
|
|
if (prop != NULL)
|
|
{
|
|
g_hash_table_remove (sel_prop_table, &gdk_root_parent->drawable.xwindow);
|
|
gdk_sel_prop_store (requestor, prop->type, prop->format,
|
|
prop->data, prop->length);
|
|
g_free (prop);
|
|
SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_warning ("gdk_selection_convert: General case not implemented");
|
|
}
|
|
}
|
|
|
|
gint
|
|
gdk_selection_property_get (GdkWindow *requestor,
|
|
guchar **data,
|
|
GdkAtom *ret_type,
|
|
gint *ret_format)
|
|
{
|
|
GdkSelProp *prop;
|
|
|
|
g_return_val_if_fail (requestor != NULL, 0);
|
|
g_return_val_if_fail (GDK_IS_WINDOW (requestor), 0);
|
|
|
|
if (GDK_DRAWABLE_DESTROYED (requestor))
|
|
return 0;
|
|
|
|
GDK_NOTE (SELECTION, g_print ("gdk_selection_property_get: %#x\n",
|
|
GDK_DRAWABLE_XID (requestor)));
|
|
|
|
prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (requestor));
|
|
|
|
if (prop == NULL)
|
|
{
|
|
*data = NULL;
|
|
return 0;
|
|
}
|
|
*data = g_malloc (prop->length);
|
|
if (prop->length > 0)
|
|
memmove (*data, prop->data, prop->length);
|
|
if (ret_type)
|
|
*ret_type = prop->type;
|
|
if (ret_format)
|
|
*ret_format = prop->format;
|
|
|
|
return prop->length;
|
|
}
|
|
|
|
void
|
|
gdk_selection_property_delete (GdkWindow *window)
|
|
{
|
|
GdkSelProp *prop;
|
|
|
|
prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (window));
|
|
if (prop != NULL)
|
|
{
|
|
g_free (prop->data);
|
|
g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (window));
|
|
}
|
|
else
|
|
g_warning ("huh?");
|
|
}
|
|
|
|
void
|
|
gdk_selection_send_notify (guint32 requestor,
|
|
GdkAtom selection,
|
|
GdkAtom target,
|
|
GdkAtom property,
|
|
guint32 time)
|
|
{
|
|
gchar *sel_name, *tgt_name, *prop_name;
|
|
|
|
GDK_NOTE (SELECTION,
|
|
(sel_name = gdk_atom_name (selection),
|
|
tgt_name = gdk_atom_name (target),
|
|
prop_name = gdk_atom_name (property),
|
|
g_print ("gdk_selection_send_notify: %#x %#x (%s) %#x (%s) %#x (%s)\n",
|
|
requestor,
|
|
selection, sel_name,
|
|
target, tgt_name,
|
|
property, prop_name),
|
|
g_free (sel_name),
|
|
g_free (tgt_name),
|
|
g_free (prop_name)));
|
|
|
|
/* Send ourselves a selection clear message so that gtk thinks we don't
|
|
* have the selection, and will claim it anew when needed, and
|
|
* we thus get a chance to store data in the Windows clipboard.
|
|
* Otherwise, if a gtkeditable does a copy to clipboard several times
|
|
* only the first one actually gets copied to the Windows clipboard,
|
|
* as only he first one causes a call to gdk_property_change.
|
|
*
|
|
* Hmm, there is something fishy with this. Cut and paste inside the
|
|
* same app didn't work, the gtkeditable immediately forgot the
|
|
* clipboard contents in gtk_editable_selection_clear as a result of
|
|
* this message. OTOH, when I changed gdk_selection_owner_get to
|
|
* always return NULL, it works. Sigh.
|
|
*/
|
|
|
|
SendMessage ((HWND) requestor, gdk_selection_clear_msg, selection, 0);
|
|
}
|
|
|
|
gint
|
|
gdk_text_property_to_text_list (GdkAtom encoding,
|
|
gint format,
|
|
guchar *text,
|
|
gint length,
|
|
gchar ***list)
|
|
{
|
|
GDK_NOTE (SELECTION,
|
|
g_print ("gdk_text_property_to_text_list not implemented\n"));
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
gdk_free_text_list (gchar **list)
|
|
{
|
|
g_return_if_fail (list != NULL);
|
|
|
|
/* ??? */
|
|
}
|
|
|
|
gint
|
|
gdk_string_to_compound_text (gchar *str,
|
|
GdkAtom *encoding,
|
|
gint *format,
|
|
guchar **ctext,
|
|
gint *length)
|
|
{
|
|
g_warning ("gdk_string_to_compound_text: Not implemented");
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
gdk_free_compound_text (guchar *ctext)
|
|
{
|
|
g_warning ("gdk_free_compound_text: Not implemented");
|
|
}
|