[gtk+/gtk-2-24] W32: Prefer the deadkey combinations that the OS uses
- From: Руслан Ижбулатов <ruslanizhb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/gtk-2-24] W32: Prefer the deadkey combinations that the OS uses
- Date: Fri, 25 Nov 2016 17:01:52 +0000 (UTC)
commit 61de4e7b67ccff9297188717b2ab12f0adab32d0
Author: Руслан Ижбулатов <lrn1986 gmail com>
Date: Sat Jul 30 20:35:51 2016 +0000
W32: Prefer the deadkey combinations that the OS uses
Pick the W32 API for possible deadkey+<something> combinations
and prefer these to other sources of deadkey combos.
Specifically, if W32 API supports at least one combo for a particular
deadkey, only use that data and do not attempt to do other, unsupported
combinations, even if they make sense otherwise.
This is needed to, for example, correctly support US-International
keyboard layout, which produces a combined character for <' + a>
combo, but not for <' + s>, for example.
This is achieved by stashing all the deadkeys that we find in
an array, then doing extra loop through all virtual key codes and
trying to combine them with each of these deadkeys. Any combinations
that produce a single character are cached for later use.
In GTK Simple IM context, call a new GDK W32 function to do a lookup
on that cached combination table early on, among the "special cases"
(which are now partially obsolete).
A limitation of this code is that combinations with more than
one deadkey are not supported, except for combinations that consist
entirely of 2 known deadkeys. The upshot is that lookups should
be relatively fast, as deadkey array stays small and the combination
tree stays shallow.
Note that the use of ToUnicodeEx() seems suboptimal, as it should
be possible to just load a keyboard library (KBD*.DLL) manually
and obtain and use its key table directly. However, that is much more
complicated and would result in a significant rewrite of gdkkeys-win32.
The code from this commit, though hacky, is a direct addition to
existing code and should cover vast majority of the use-cases.
https://bugzilla.gnome.org/show_bug.cgi?id=569581
gdk/gdk.symbols | 1 +
gdk/win32/gdkkeys-win32.c | 405 +++++++++++++++++++++++++++++++++++++++++++--
gdk/win32/gdkwin32keys.h | 24 +++
gtk/gtkimcontextsimple.c | 32 ++++
4 files changed, 448 insertions(+), 14 deletions(-)
---
diff --git a/gdk/gdk.symbols b/gdk/gdk.symbols
index b2bd9eb..44b0354 100644
--- a/gdk/gdk.symbols
+++ b/gdk/gdk.symbols
@@ -1286,6 +1286,7 @@ gdk_win32_selection_add_targets
#if IN_HEADER(__GDK_WIN32_H__)
#if IN_FILE(__GDK_KEYS_WIN32_C__)
gdk_win32_keymap_get_type G_GNUC_CONST
+gdk_win32_keymap_check_compose
#endif
#endif
#endif
diff --git a/gdk/win32/gdkkeys-win32.c b/gdk/win32/gdkkeys-win32.c
index edc26b2..b971774 100644
--- a/gdk/win32/gdkkeys-win32.c
+++ b/gdk/win32/gdkkeys-win32.c
@@ -38,6 +38,87 @@
#include "gdkkeys.h"
#include "gdkwin32keys.h"
+enum _GdkWin32KeyLevelState
+{
+ GDK_WIN32_LEVEL_NONE = 0,
+ GDK_WIN32_LEVEL_SHIFT,
+ GDK_WIN32_LEVEL_ALTGR,
+ GDK_WIN32_LEVEL_SHIFT_ALTGR,
+ GDK_WIN32_LEVEL_COUNT
+};
+
+typedef enum _GdkWin32KeyLevelState GdkWin32KeyLevelState;
+
+struct _GdkWin32KeyNode
+{
+ /* Non-spacing version of the dead key */
+ guint undead_gdk_keycode;
+
+ /* Virtual key code */
+ guint8 vk;
+
+ /* Level for which this virtual key code produces this gdk_keycode */
+ GdkWin32KeyLevelState level;
+
+ /* GDK (X11) code for this key */
+ guint gdk_keycode;
+
+ /* Array of GdkWin32KeyNode should be sorted by gdk_keycode, then by level */
+ GArray *combinations;
+};
+
+typedef struct _GdkWin32KeyNode GdkWin32KeyNode;
+
+/*
+Example:
+ GdkWin32KeyNode
+ {
+ undead_gdk_keycode = 0x0b4 GDK_KEY_acute (')
+ vk = 0xde VK_OEM_7
+ level = GDK_WIN32_LEVEL_NONE
+ gdk_keycode = 0xfe51 GDK_KEY_dead_acute
+ combinations =
+ {
+ GdkWin32KeyNode
+ {
+ undead_gdk_keycode = 0x061 GDK_KEY_a (a)
+ level = GDK_WIN32_LEVEL_NONE
+ vk = 0x41 VK_A
+ gdk_keycode = 0xe1 GDK_KEY_aacute á
+ combinations = NULL
+ },
+ GdkWin32KeyNode
+ {
+ unicode_char = 0x041 GDK_KEY_A (A)
+ level = GDK_WIN32_LEVEL_SHIFT
+ vk = 0x41 VK_A
+ gdk_keycode = 0x0c1 GDK_KEY_Aacute Á
+ combinations = NULL
+ },
+ { ... }
+ }
+ }
+
+Thus:
+
+GDK_KEY_dead_acute + GDK_KEY_a
+= GDK_KEY_aacute
+
+GDK_KEY_dead_acute + GDK_KEY_A
+= GDK_KEY_Aacute
+
+GDK_KEY_dead_acute + GDK_KEY_s
+matches partially
+(GDK_KEY_dead_acute is a known dead key, but does not combine with GDK_KEY_s)
+and resolves into:
+GDK_KEY_acute + GDK_KEY_s
+
+GDK_KEY_dead_somethingelse + GDK_KEY_anything
+does not match at all
+(W32 API did not provide any deadkey info for GDK_KEY_dead_somethingelse)
+and the caller will try other matching mechanisms for compose_buffer
+*/
+
struct _GdkWin32KeyGroupOptions
{
/* character that should be used as the decimal separator */
@@ -53,6 +134,8 @@ struct _GdkWin32KeyGroupOptions
gboolean has_altgr;
gboolean capslock_tested;
+
+ GArray *dead_keys;
};
typedef struct _GdkWin32KeyGroupOptions GdkWin32KeyGroupOptions;
@@ -92,17 +175,6 @@ struct _GdkWin32Keymap
guint8 active_layout;
};
-enum _GdkWin32KeyLevelState
-{
- GDK_WIN32_LEVEL_NONE = 0,
- GDK_WIN32_LEVEL_SHIFT,
- GDK_WIN32_LEVEL_ALTGR,
- GDK_WIN32_LEVEL_SHIFT_ALTGR,
- GDK_WIN32_LEVEL_COUNT
-};
-
-typedef enum _GdkWin32KeyLevelState GdkWin32KeyLevelState;
-
G_DEFINE_TYPE (GdkWin32Keymap, gdk_win32_keymap, GDK_TYPE_KEYMAP)
guint _gdk_keymap_serial = 0;
@@ -114,10 +186,23 @@ static GdkKeymap *default_keymap = NULL;
static void update_keymap (GdkKeymap *gdk_keymap);
static void
+gdk_win32_key_group_options_clear (GdkWin32KeyGroupOptions *options)
+{
+ g_clear_pointer (&options->dead_keys, g_array_unref);
+}
+
+static void
+gdk_win32_key_node_clear (GdkWin32KeyNode *node)
+{
+ g_clear_pointer (&node->combinations, g_array_unref);
+}
+
+static void
gdk_win32_keymap_init (GdkWin32Keymap *keymap)
{
keymap->layout_handles = g_array_new (FALSE, FALSE, sizeof (HKL));
keymap->options = g_array_new (FALSE, FALSE, sizeof (GdkWin32KeyGroupOptions));
+ g_array_set_clear_func (keymap->options, (GDestroyNotify) gdk_win32_key_group_options_clear);
keymap->keysym_tab = NULL;
keymap->active_layout = 0;
update_keymap (GDK_KEYMAP (keymap));
@@ -481,6 +566,26 @@ check_that_active_layout_is_in_sync (GdkWin32Keymap *keymap)
}
}
+static gint
+sort_key_nodes_by_gdk_keyval (gconstpointer a,
+ gconstpointer b)
+{
+ const GdkWin32KeyNode *one = a;
+ const GdkWin32KeyNode *two = b;
+
+ if (one->gdk_keycode < two->gdk_keycode)
+ return -1;
+ else if (one->gdk_keycode > two->gdk_keycode)
+ return 1;
+
+ if (one->level < two->level)
+ return -1;
+ else if (one->level > two->level)
+ return 1;
+
+ return 0;
+}
+
static void
update_keymap (GdkKeymap *gdk_keymap)
{
@@ -577,6 +682,8 @@ update_keymap (GdkKeymap *gdk_keymap)
options->scancode_rshift = 0;
options->has_altgr = FALSE;
options->capslock_tested = FALSE;
+ options->dead_keys = g_array_new (FALSE, FALSE, sizeof (GdkWin32KeyNode));
+ g_array_set_clear_func (options->dead_keys, (GDestroyNotify) gdk_win32_key_node_clear);
g_array_index (keymap->layout_handles, HKL, i) = hkls[i];
@@ -624,9 +731,10 @@ update_keymap (GdkKeymap *gdk_keymap)
if ((*ksymp == 0) ||
((vk == VK_DECIMAL) && (level == GDK_WIN32_LEVEL_NONE)))
{
- wchar_t wcs[10];
- gint k;
- guint keysym;
+ wchar_t wcs[10];
+ gint k;
+ guint keysym;
+ GdkWin32KeyNode dead_key;
wcs[0] = wcs[1] = 0;
k = ToUnicodeEx (vk, scancode, key_state,
@@ -663,6 +771,13 @@ update_keymap (GdkKeymap *gdk_keymap)
/* Use dead keysyms instead of "undead" ones */
handle_dead (keysym, ksymp);
+
+ dead_key.undead_gdk_keycode = keysym;
+ dead_key.vk = vk;
+ dead_key.level = level;
+ dead_key.gdk_keycode = *ksymp;
+ dead_key.combinations = NULL;
+ g_array_append_val (options->dead_keys, dead_key);
break;
case 0:
/* Seems to be necessary to "reset" the keyboard layout
@@ -738,12 +853,274 @@ update_keymap (GdkKeymap *gdk_keymap)
}
}
+ scancode = 0x0;
+
+ for (group = 0; group < hkls_len; group++)
+ {
+ options = &g_array_index (keymap->options, GdkWin32KeyGroupOptions, group);
+
+ for (i = 0; i < options->dead_keys->len; i++)
+ {
+ wchar_t wcs[10];
+ gint k;
+ GdkWin32KeyNode *dead_key;
+ GdkWin32KeyNode combo;
+
+ dead_key = &g_array_index (options->dead_keys, GdkWin32KeyNode, i);
+
+ for (vk = 0; vk < KEY_STATE_SIZE; vk++)
+ {
+ for (level = GDK_WIN32_LEVEL_NONE; level < GDK_WIN32_LEVEL_COUNT; level++)
+ {
+ /* Prime the ToUnicodeEx() internal state */
+ wcs[0] = wcs[1] = 0;
+ set_level_vks (key_state, dead_key->level);
+ k = ToUnicodeEx (dead_key->vk, scancode, key_state,
+ wcs, G_N_ELEMENTS (wcs),
+ 0, hkls[group]);
+ switch (k)
+ {
+ case -1:
+ /* Okay */
+ break;
+ default:
+ /* Expected a dead key, got something else */
+ reset_after_dead (key_state, hkls[group]);
+ continue;
+ }
+
+ /* Check how it combines with vk */
+ wcs[0] = wcs[1] = 0;
+ set_level_vks (key_state, level);
+ k = ToUnicodeEx (vk, scancode, key_state,
+ wcs, G_N_ELEMENTS (wcs),
+ 0, hkls[group]);
+
+ if (k == 0)
+ {
+ reset_after_dead (key_state, hkls[group]);
+ }
+ else if (k == -1)
+ {
+ /* Dead key chaining? TODO: support this (deeper tree?) */
+ reset_after_dead (key_state, hkls[group]);
+ }
+ else if (k == 1)
+ {
+ combo.vk = vk;
+ combo.level = level;
+ combo.gdk_keycode = gdk_unicode_to_keyval (wcs[0]);
+ combo.undead_gdk_keycode = combo.gdk_keycode;
+ combo.combinations = NULL;
+
+ if (dead_key->combinations == NULL)
+ {
+ dead_key->combinations = g_array_new (FALSE, FALSE, sizeof (GdkWin32KeyNode));
+ g_array_set_clear_func (dead_key->combinations, (GDestroyNotify)
gdk_win32_key_node_clear);
+ }
+
+#if 0
+ {
+ char *dead_key_undead_u8, *wcs_u8;
+ wchar_t t = gdk_keyval_to_unicode (dead_key->undead_gdk_keycode);
+ dead_key_undead_u8 = g_utf16_to_utf8 (&t, 1, NULL, NULL, NULL);
+ wcs_u8 = g_utf16_to_utf8 (wcs, 1, NULL, NULL, NULL);
+ g_fprintf (stdout, "%d %s%s0x%02x (%s) + %s%s0x%02x = 0x%04x (%s)\n", group,
+ (dead_key->level == GDK_WIN32_LEVEL_SHIFT || dead_key->level ==
GDK_WIN32_LEVEL_SHIFT_ALTGR) ? "SHIFT-" : " ",
+ (dead_key->level == GDK_WIN32_LEVEL_ALTGR || dead_key->level ==
GDK_WIN32_LEVEL_SHIFT_ALTGR) ? "ALTGR-" : " ",
+ dead_key->vk,
+ dead_key_undead_u8,
+ (combo.level == GDK_WIN32_LEVEL_SHIFT || combo.level ==
GDK_WIN32_LEVEL_SHIFT_ALTGR) ? "SHIFT-" : " ",
+ (combo.level == GDK_WIN32_LEVEL_ALTGR || combo.level ==
GDK_WIN32_LEVEL_SHIFT_ALTGR) ? "ALTGR-" : " ",
+ vk,
+ wcs[0],
+ wcs_u8);
+ g_free (dead_key_undead_u8);
+ g_free (wcs_u8);
+ }
+#endif
+
+ g_array_append_val (dead_key->combinations, combo);
+ }
+ }
+ }
+ }
+
+ g_array_sort (options->dead_keys, (GCompareFunc) sort_key_nodes_by_gdk_keyval);
+ }
+
GDK_NOTE (EVENTS, print_keysym_tab (keymap));
check_that_active_layout_is_in_sync (keymap);
current_serial = _gdk_keymap_serial;
}
+static gboolean
+find_deadkey_by_keyval (GArray *dead_keys,
+ guint16 keyval,
+ gsize *index)
+{
+ gsize deadkey_i;
+ gsize deadkey_i_max;
+
+ if (dead_keys->len == 0)
+ return FALSE;
+
+ deadkey_i = 0;
+ deadkey_i_max = dead_keys->len - 1;
+
+ while (deadkey_i != deadkey_i_max)
+ {
+ GdkWin32KeyNode *dead_key;
+ gsize middle;
+
+ if (g_array_index (dead_keys, GdkWin32KeyNode, deadkey_i).gdk_keycode == keyval)
+ {
+ break;
+ }
+ else if (g_array_index (dead_keys, GdkWin32KeyNode, deadkey_i_max).gdk_keycode == keyval)
+ {
+ deadkey_i = deadkey_i_max;
+ break;
+ }
+ else if (deadkey_i + 1 == deadkey_i_max)
+ {
+ break;
+ }
+
+ middle = deadkey_i + (deadkey_i_max - deadkey_i) / 2;
+ dead_key = &g_array_index (dead_keys, GdkWin32KeyNode, middle);
+
+ if (dead_key->gdk_keycode < keyval)
+ deadkey_i = middle;
+ else if (dead_key->gdk_keycode > keyval)
+ deadkey_i_max = middle;
+ else
+ deadkey_i = deadkey_i_max = middle;
+ }
+
+ if (g_array_index (dead_keys, GdkWin32KeyNode, deadkey_i).gdk_keycode == keyval)
+ {
+ *index = deadkey_i;
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+GdkWin32KeymapMatch
+gdk_win32_keymap_check_compose (GdkWin32Keymap *keymap,
+ guint *compose_buffer,
+ gsize compose_buffer_len,
+ guint16 *output,
+ gsize *output_len)
+{
+ gint partial_match;
+ guint8 active_group;
+ gsize deadkey_i, node_i;
+ GdkWin32KeyNode *dead_key;
+ GdkWin32KeyGroupOptions *options;
+ GdkWin32KeymapMatch match;
+ gsize output_size;
+
+ g_return_val_if_fail (output != NULL && output_len != NULL, GDK_WIN32_KEYMAP_MATCH_NONE);
+
+ if (compose_buffer_len < 1)
+ return GDK_WIN32_KEYMAP_MATCH_NONE;
+
+ output_size = *output_len;
+
+ active_group = _gdk_win32_keymap_get_active_group (keymap);
+ options = &g_array_index (keymap->options, GdkWin32KeyGroupOptions, active_group);
+
+ partial_match = -1;
+ match = GDK_WIN32_KEYMAP_MATCH_NONE;
+
+ if (find_deadkey_by_keyval (options->dead_keys, compose_buffer[0], &deadkey_i))
+ {
+ while (deadkey_i > 0 &&
+ g_array_index (options->dead_keys, GdkWin32KeyNode, deadkey_i - 1).gdk_keycode ==
compose_buffer[0])
+ deadkey_i--;
+
+ /* Hardcoded 2-tier tree here (dead key + non dead key = character).
+ * TODO: support trees with arbitrary depth for dead key chaining.
+ */
+ dead_key = &g_array_index (options->dead_keys, GdkWin32KeyNode, deadkey_i);
+
+ /* "Partial match" means "matched the whole sequence except the last key"
+ * (right now the sequence only has 2 keys, so this turns into "matched
+ * at least the first key").
+ * "last key" should be identified by having NULL further combinations.
+ * As a heuristic, convert the buffer contents into keyvals and use
+ * them as-is (normally there should be a separate unichar buffer for
+ * each combination, but we do not store these).
+ */
+ partial_match = deadkey_i;
+
+ if (compose_buffer_len < 2)
+ match = GDK_WIN32_KEYMAP_MATCH_INCOMPLETE;
+
+ for (node_i = 0;
+ match != GDK_WIN32_KEYMAP_MATCH_INCOMPLETE &&
+ node_i < dead_key->combinations->len;
+ node_i++)
+ {
+ GdkWin32KeyNode *node;
+
+ node = &g_array_index (dead_key->combinations, GdkWin32KeyNode, node_i);
+
+ if (keymap->keysym_tab[(node->vk * keymap->layout_handles->len + active_group) *
GDK_WIN32_LEVEL_COUNT + node->level] == compose_buffer[1])
+ {
+ match = GDK_WIN32_KEYMAP_MATCH_EXACT;
+ *output_len = 0;
+
+ if (*output_len < output_size && node->gdk_keycode != 0)
+ output[(*output_len)++] = node->gdk_keycode;
+
+ break;
+ }
+ }
+ }
+
+ if (match == GDK_WIN32_KEYMAP_MATCH_EXACT ||
+ match == GDK_WIN32_KEYMAP_MATCH_INCOMPLETE)
+ {
+ return match;
+ }
+
+ if (partial_match >= 0)
+ {
+ if (compose_buffer_len == 2)
+ {
+ dead_key = &g_array_index (options->dead_keys, GdkWin32KeyNode, partial_match);
+ *output_len = 0;
+
+ if (output_size >= 1)
+ output[(*output_len)++] = dead_key->undead_gdk_keycode;
+
+ if (output_size >= 2)
+ {
+ gsize second_deadkey_i;
+
+ /* Special case for "deadkey + deadkey = space-version-of-deadkey, space-version-of-deadkey"
combinations.
+ * Normally the result is a sequence of 2 unichars, but we do not store this.
+ * For "deadkey + nondeadkey = space-version-of-deadkey, nondeadkey", we can use compose_buffer
+ * contents as-is, but space version of a dead key need to be looked up separately.
+ */
+ if (find_deadkey_by_keyval (options->dead_keys, compose_buffer[1], &second_deadkey_i))
+ output[(*output_len)++] = g_array_index (options->dead_keys, GdkWin32KeyNode,
second_deadkey_i).undead_gdk_keycode;
+ else
+ output[(*output_len)++] = compose_buffer[1];
+ }
+ }
+
+ return GDK_WIN32_KEYMAP_MATCH_PARTIAL;
+ }
+
+ return GDK_WIN32_KEYMAP_MATCH_NONE;
+}
+
guint8
_gdk_win32_keymap_get_rshift_scancode (GdkWin32Keymap *keymap)
{
diff --git a/gdk/win32/gdkwin32keys.h b/gdk/win32/gdkwin32keys.h
index c271d67..cbd1dfc 100644
--- a/gdk/win32/gdkwin32keys.h
+++ b/gdk/win32/gdkwin32keys.h
@@ -26,6 +26,24 @@
G_BEGIN_DECLS
+/**
+ * GdkWin32KeymapMatch:
+ * @GDK_WIN32_KEYMAP_MATCH_NONE: no matches found. Output is not valid.
+ * @GDK_WIN32_KEYMAP_MATCH_INCOMPLETE: the sequence matches so far, but is incomplete. Output is not valid.
+ * @GDK_WIN32_KEYMAP_MATCH_PARTIAL: the sequence matches up to the last key,
+ * which does not match. Output is valid.
+ * @GDK_WIN32_KEYMAP_MATCH_EXACT: the sequence matches exactly. Output is valid.
+ *
+ * An enumeration describing the result of a deadkey combination matching.
+ */
+typedef enum
+{
+ GDK_WIN32_KEYMAP_MATCH_NONE,
+ GDK_WIN32_KEYMAP_MATCH_INCOMPLETE,
+ GDK_WIN32_KEYMAP_MATCH_PARTIAL,
+ GDK_WIN32_KEYMAP_MATCH_EXACT
+} GdkWin32KeymapMatch;
+
#ifdef GDK_COMPILATION
typedef struct _GdkWin32Keymap GdkWin32Keymap;
#else
@@ -42,6 +60,12 @@ typedef struct _GdkWin32KeymapClass GdkWin32KeymapClass;
GType gdk_win32_keymap_get_type (void);
+GdkWin32KeymapMatch gdk_win32_keymap_check_compose (GdkWin32Keymap *keymap,
+ guint *compose_buffer,
+ gsize compose_buffer_len,
+ guint16 *output,
+ gsize *output_len);
+
G_END_DECLS
#endif /* __GDK_WIN32_KEYMAP_H__ */
diff --git a/gtk/gtkimcontextsimple.c b/gtk/gtkimcontextsimple.c
index 1c40e9d..6d8b3bd 100644
--- a/gtk/gtkimcontextsimple.c
+++ b/gtk/gtkimcontextsimple.c
@@ -18,6 +18,7 @@
*/
#include "config.h"
+
#include <stdlib.h>
#include <string.h>
@@ -30,6 +31,10 @@
#include "gtkintl.h"
#include "gtkalias.h"
+#ifdef GDK_WINDOWING_WIN32
+#include <win32/gdkwin32.h>
+#endif
+
typedef struct _GtkComposeTable GtkComposeTable;
typedef struct _GtkComposeTableCompact GtkComposeTableCompact;
@@ -1058,6 +1063,33 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
}
else
{
+#ifdef GDK_WINDOWING_WIN32
+ guint16 output[2];
+ gsize output_size = 2;
+
+ switch (gdk_win32_keymap_check_compose (GDK_WIN32_KEYMAP (gdk_keymap_get_default ()),
+ context_simple->compose_buffer,
+ n_compose,
+ output, &output_size))
+ {
+ case GDK_WIN32_KEYMAP_MATCH_NONE:
+ break;
+ case GDK_WIN32_KEYMAP_MATCH_EXACT:
+ case GDK_WIN32_KEYMAP_MATCH_PARTIAL:
+ for (i = 0; i < output_size; i++)
+ {
+ guint32 output_char = gdk_keyval_to_unicode (output[i]);
+ gtk_im_context_simple_commit_char (GTK_IM_CONTEXT (context_simple),
+ output_char);
+ }
+ context_simple->compose_buffer[0] = 0;
+ return TRUE;
+ case GDK_WIN32_KEYMAP_MATCH_INCOMPLETE:
+ return TRUE;
+ }
+#endif
+
+
tmp_list = context_simple->tables;
while (tmp_list)
{
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
