Overview of input

[Owen Taylor <otaylor redhat com>]

I implemented a start on input method support for GTK+-1.4
over the last two days.

Input contexts are implemented as Gtk Objects. The class
heirarchy looks something like:

                  GtkIMContext--------------------\
                   /     |     \                   \
                  /      |      \                   \
   GtkIMMultiContext     |    GtkIMContextSimple     \
                         |                        GtkIMContextThai
                   GtkIMContextXIM
                   /            \
                  /              \
           GtkIMContextZH        GtkIMContextJA ....


 GtkIMContext is the abstract base class which defines a
 generic input method inteface. The current header file
 for this is appended. The input context / method interface
 here is intentionally much simpler than something like
 XIM - the only supported input styles are root window,
 and on-the-spot.

 GtkIMMulticontext is the class that will actually be
 instantiated for each entry widget. It proxies the
 function calls and signals to and from the actual
 object implementing the input method. This allows the
 input method to be picked to be appropriate for
 the user's locale and even allows that input method
 to be switched on the fly.

 The remaining classes implement the actual input methods.
 There will most likely be one input method built
 into GTK+, and the remaining input methods loaded
 from modules.
  
 GtkIMContextSimple is a simple input method that does
 direct keysym to unicode translation and table-driven
 composition. I've implemented this over the last few
 days, and it handles most of what you need for 
 European languages, Hebrew, Arabic, etc.

 GtkIMContextXIM is a (not yet implemented) base class
 for XIM-based input methods. Most of the interaction
 with XIM is implemented here. Subclasses, such
 as GtkIMContextZH, fill in the necessary information
 for using it with a particular language:

  - locale to use when looking up the IM
  - translation functions for strings

 Input methods for languages where no input method exists
 could be implemented by writing XIM-based input methods,
 but I would expect that in most cases people will simply
 write a module for GTK+ directly. Except for the CJK
 languages, the input methods should be quite small,
 and there is no need for all the complex machinery
 of XIM in such cases.

I think this overall scheme will provide a good compromise
between flexibility and ease of implementation, while
making things quite nice for the use. I haven't resolved
quite what to do about the issues I asked about earlier
about how global the chosen input method and input
method state should be. However, there should be no problem
accomodating different options with this setup.
 
Regards,
                                        Owen

========================================================================
/* GTK - The GIMP Toolkit
 * gtkimcontext.h: Abstract base class for input contexts
 * Copyright (C) 2000 Red Hat Software
 *
 * 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.
 */

#ifndef __GTK_IM_CONTEXT_H__
#define __GTK_IM_CONTEXT_H__

#include <gdk/gdk.h>
#include <gtk/gtkobject.h>
#include <pango/pango.h>


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#define GTK_TYPE_IM_CONTEXT              (gtk_im_context_get_type ())
#define GTK_IM_CONTEXT(obj)              (GTK_CHECK_CAST ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContext))
#define GTK_IM_CONTEXT_CLASS(klass)      (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))
#define GTK_IS_IM_CONTEXT(obj)           (GTK_CHECK_TYPE ((obj), GTK_TYPE_IM_CONTEXT))
#define GTK_IS_IM_CONTEXT_CLASS(klass)   (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT))
#define GTK_IM_CONTEXT_GET_CLASS(obj)    (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))


typedef struct _GtkIMContext       GtkIMContext;
typedef struct _GtkIMContextClass  GtkIMContextClass;

struct _GtkIMContext
{
  GtkObject object;
};

struct _GtkIMContextClass
{
  GtkObjectClass parent_class;

  /* Signals */
  void (*preedit_start)   (GtkIMContext *context);
  void (*preedit_end)     (GtkIMContext *context);
  void (*preedit_changed) (GtkIMContext *context);
  void (*commit)          (GtkIMContext *context, const gchar *str);

  /* Virtual functions */
  void     (*set_client_window)  (GtkIMContext   *context,
				  GdkWindow      *window);
  void     (*get_preedit_string) (GtkIMContext   *context,
				  gchar         **str,
				  PangoAttrList **attrs);
  gboolean (*filter_keypress)    (GtkIMContext   *context,
			          GdkEventKey    *event);
  void     (*focus_in)           (GtkIMContext   *context);
  void     (*focus_out)          (GtkIMContext   *context);
};

GtkType       gtk_im_context_get_type           (void);

void          gtk_im_context_set_client_window  (GtkIMContext   *context,
						 GdkWindow      *window);
void          gtk_im_context_get_preedit_string (GtkIMContext   *context,
						 char          **str,
						 PangoAttrList **attrs);
gboolean      gtk_im_context_filter_keypress    (GtkIMContext   *context,
						 GdkEventKey    *event);
void          gtk_im_context_focus_in           (GtkIMContext   *context);
void          gtk_im_context_focus_out          (GtkIMContext   *context);

#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* __GTK_IM_CONTEXT_H__ */