]> Pileus Git - ~andy/gtk/blob - gtk/gtkimmulticontext.c
f95ef3e705aedfc982aba3b0535d59c313fd4e65
[~andy/gtk] / gtk / gtkimmulticontext.c
1 /* GTK - The GIMP Toolkit
2  * Copyright (C) 2000 Red Hat, Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #include <string.h>
21 #include <locale.h>
22
23 #include "gtksignal.h"
24 #include "gtkimmulticontext.h"
25 #include "gtkimmodule.h"
26 #include "gtkradiomenuitem.h"
27
28 static void     gtk_im_multicontext_class_init         (GtkIMMulticontextClass  *class);
29 static void     gtk_im_multicontext_init               (GtkIMMulticontext       *im_multicontext);
30 static void     gtk_im_multicontext_finalize           (GObject                 *object);
31
32 static void     gtk_im_multicontext_set_slave          (GtkIMMulticontext       *multicontext,
33                                                         GtkIMContext            *slave,
34                                                         gboolean                 finalizing);
35
36 static void     gtk_im_multicontext_set_client_window  (GtkIMContext            *context,
37                                                         GdkWindow               *window);
38 static void     gtk_im_multicontext_get_preedit_string (GtkIMContext            *context,
39                                                         gchar                  **str,
40                                                         PangoAttrList          **attrs,
41                                                         gint                   *cursor_pos);
42 static gboolean gtk_im_multicontext_filter_keypress    (GtkIMContext            *context,
43                                                         GdkEventKey             *event);
44 static void     gtk_im_multicontext_focus_in           (GtkIMContext            *context);
45 static void     gtk_im_multicontext_focus_out          (GtkIMContext            *context);
46 static void     gtk_im_multicontext_reset              (GtkIMContext            *context);
47 static void     gtk_im_multicontext_set_cursor_location (GtkIMContext            *context,
48                                                         GdkRectangle            *area);
49 static void     gtk_im_multicontext_set_use_preedit    (GtkIMContext            *context,
50                                                         gboolean                 use_preedit);
51 static gboolean gtk_im_multicontext_get_surrounding    (GtkIMContext            *context,
52                                                         gchar                  **text,
53                                                         gint                    *cursor_index);
54 static void     gtk_im_multicontext_set_surrounding    (GtkIMContext            *context,
55                                                         const char              *text,
56                                                         gint                     len,
57                                                         gint                     cursor_index);
58
59 static void     gtk_im_multicontext_preedit_start_cb        (GtkIMContext      *slave,
60                                                              GtkIMMulticontext *multicontext);
61 static void     gtk_im_multicontext_preedit_end_cb          (GtkIMContext      *slave,
62                                                              GtkIMMulticontext *multicontext);
63 static void     gtk_im_multicontext_preedit_changed_cb      (GtkIMContext      *slave,
64                                                              GtkIMMulticontext *multicontext);
65 static void     gtk_im_multicontext_commit_cb               (GtkIMContext      *slave,
66                                                              const gchar       *str,
67                                                              GtkIMMulticontext *multicontext);
68 static gboolean gtk_im_multicontext_retrieve_surrounding_cb (GtkIMContext      *slave,
69                                                              GtkIMMulticontext *multicontext);
70 static gboolean gtk_im_multicontext_delete_surrounding_cb   (GtkIMContext      *slave,
71                                                              gint               offset,
72                                                              gint               n_chars,
73                                                              GtkIMMulticontext *multicontext);
74 static GtkIMContextClass *parent_class;
75
76 static const gchar *global_context_id = NULL;
77
78 GtkType
79 gtk_im_multicontext_get_type (void)
80 {
81   static GtkType im_multicontext_type = 0;
82  
83   if (!im_multicontext_type)
84     {
85       static const GTypeInfo im_multicontext_info =
86       {
87         sizeof (GtkIMMulticontextClass),
88         (GBaseInitFunc) NULL,
89         (GBaseFinalizeFunc) NULL,
90         (GClassInitFunc) gtk_im_multicontext_class_init,
91         NULL,           /* class_finalize */
92         NULL,           /* class_data */
93         sizeof (GtkIMMulticontext),
94         0,              /* n_preallocs */
95         (GInstanceInitFunc) gtk_im_multicontext_init,
96       };
97       
98       im_multicontext_type = g_type_register_static (GTK_TYPE_IM_CONTEXT,
99                                                      "GtkIMMulticontext",
100                                                      &im_multicontext_info, 0);
101     }
102
103   return im_multicontext_type;
104 }
105
106 static void
107 gtk_im_multicontext_class_init (GtkIMMulticontextClass *class)
108 {
109   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
110   GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (class);
111   
112   parent_class = g_type_class_peek_parent (class);
113
114   im_context_class->set_client_window = gtk_im_multicontext_set_client_window;
115   im_context_class->get_preedit_string = gtk_im_multicontext_get_preedit_string;
116   im_context_class->filter_keypress = gtk_im_multicontext_filter_keypress;
117   im_context_class->focus_in = gtk_im_multicontext_focus_in;
118   im_context_class->focus_out = gtk_im_multicontext_focus_out;
119   im_context_class->reset = gtk_im_multicontext_reset;
120   im_context_class->set_cursor_location = gtk_im_multicontext_set_cursor_location;
121   im_context_class->set_use_preedit = gtk_im_multicontext_set_use_preedit;
122   im_context_class->set_surrounding = gtk_im_multicontext_set_surrounding;
123   im_context_class->get_surrounding = gtk_im_multicontext_get_surrounding;
124
125   gobject_class->finalize = gtk_im_multicontext_finalize;
126 }
127
128 static void
129 gtk_im_multicontext_init (GtkIMMulticontext *multicontext)
130 {
131   multicontext->slave = NULL;
132 }
133
134 /**
135  * gtk_im_multicontext_new:
136  *
137  * Creates a new #GtkIMMulticontext.
138  *
139  * Returns: a new #GtkIMMulticontext.
140  **/
141 GtkIMContext *
142 gtk_im_multicontext_new (void)
143 {
144   return GTK_IM_CONTEXT (g_object_new (GTK_TYPE_IM_MULTICONTEXT, NULL));
145 }
146
147 static void
148 gtk_im_multicontext_finalize (GObject *object)
149 {
150   gtk_im_multicontext_set_slave (GTK_IM_MULTICONTEXT (object), NULL, TRUE);
151
152   G_OBJECT_CLASS (parent_class)->finalize (object);
153 }
154
155 static void
156 gtk_im_multicontext_set_slave (GtkIMMulticontext *multicontext,
157                                GtkIMContext      *slave,
158                                gboolean           finalizing)
159 {
160   if (multicontext->slave)
161     {
162       if (!finalizing)
163         gtk_im_context_reset (multicontext->slave);
164       
165       g_signal_handlers_disconnect_by_func (multicontext->slave,
166                                             gtk_im_multicontext_preedit_start_cb,
167                                             multicontext);
168       g_signal_handlers_disconnect_by_func (multicontext->slave,
169                                             gtk_im_multicontext_preedit_end_cb,
170                                             multicontext);
171       g_signal_handlers_disconnect_by_func (multicontext->slave,
172                                             gtk_im_multicontext_preedit_changed_cb,
173                                             multicontext);
174       g_signal_handlers_disconnect_by_func (multicontext->slave,
175                                             gtk_im_multicontext_commit_cb,
176                                             multicontext);
177
178       g_object_unref (multicontext->slave);
179       multicontext->slave = NULL;
180
181       if (!finalizing)
182         g_signal_emit_by_name (multicontext, "preedit_changed");
183     }
184   
185   multicontext->slave = slave;
186
187   if (multicontext->slave)
188     {
189       g_object_ref (multicontext->slave);
190
191       g_signal_connect (multicontext->slave, "preedit_start",
192                         G_CALLBACK (gtk_im_multicontext_preedit_start_cb),
193                         multicontext);
194       g_signal_connect (multicontext->slave, "preedit_end",
195                         G_CALLBACK (gtk_im_multicontext_preedit_end_cb),
196                         multicontext);
197       g_signal_connect (multicontext->slave, "preedit_changed",
198                         G_CALLBACK (gtk_im_multicontext_preedit_changed_cb),
199                         multicontext);
200       g_signal_connect (multicontext->slave, "commit",
201                         G_CALLBACK (gtk_im_multicontext_commit_cb),
202                         multicontext);
203       g_signal_connect (multicontext->slave, "retrieve_surrounding",
204                         G_CALLBACK (gtk_im_multicontext_retrieve_surrounding_cb),
205                         multicontext);
206       g_signal_connect (multicontext->slave, "delete_surrounding",
207                         G_CALLBACK (gtk_im_multicontext_delete_surrounding_cb),
208                         multicontext);
209       
210       if (multicontext->client_window)
211         gtk_im_context_set_client_window (slave, multicontext->client_window);
212     }
213 }
214
215 static GtkIMContext *
216 gtk_im_multicontext_get_slave (GtkIMMulticontext *multicontext)
217 {
218   if (!multicontext->slave)
219     {
220       if (!global_context_id)
221         {
222           const char *locale;
223           
224 #ifdef HAVE_LC_MESSAGES
225           locale = setlocale (LC_MESSAGES, NULL);
226 #else
227           locale = setlocale (LC_CTYPE, NULL);
228 #endif
229           global_context_id = _gtk_im_module_get_default_context_id (locale);
230         }
231         
232       gtk_im_multicontext_set_slave (multicontext, _gtk_im_module_create (global_context_id), FALSE);
233       multicontext->context_id = global_context_id;
234     }
235
236   return multicontext->slave;
237 }
238
239 static void
240 gtk_im_multicontext_set_client_window (GtkIMContext *context,
241                                        GdkWindow    *window)
242 {
243   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
244   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
245
246   multicontext->client_window = window;
247   
248   if (slave)
249     gtk_im_context_set_client_window (slave, window);
250 }
251
252 static void
253 gtk_im_multicontext_get_preedit_string (GtkIMContext   *context,
254                                         gchar         **str,
255                                         PangoAttrList **attrs,
256                                         gint           *cursor_pos)
257 {
258   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
259   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
260
261   if (slave)
262     gtk_im_context_get_preedit_string (slave, str, attrs, cursor_pos);
263   else
264     {
265       if (str)
266         *str = g_strdup ("");
267       if (attrs)
268         *attrs = pango_attr_list_new ();
269     }
270 }
271
272 static gboolean
273 gtk_im_multicontext_filter_keypress (GtkIMContext *context,
274                                      GdkEventKey  *event)
275 {
276   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
277   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
278
279   if (slave)
280     return gtk_im_context_filter_keypress (slave, event);
281   else
282     return FALSE;
283 }
284
285 static void
286 gtk_im_multicontext_focus_in (GtkIMContext   *context)
287 {
288   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
289   GtkIMContext *slave;
290
291   /* If the global context type is different from the context we were
292    * using before, get rid of the old slave and create a new one
293    * for the new global context type.
294    */
295   if (!multicontext->context_id ||
296       strcmp (global_context_id, multicontext->context_id) != 0)
297     gtk_im_multicontext_set_slave (multicontext, NULL, FALSE);
298
299   slave = gtk_im_multicontext_get_slave (multicontext);
300
301   if (slave)
302     gtk_im_context_focus_in (slave);
303 }
304
305 static void
306 gtk_im_multicontext_focus_out (GtkIMContext   *context)
307 {
308   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
309   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
310
311   if (slave)
312     gtk_im_context_focus_out (slave);
313 }
314
315 static void
316 gtk_im_multicontext_reset (GtkIMContext   *context)
317 {
318   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
319   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
320
321   if (slave)
322     gtk_im_context_reset (slave);
323 }
324
325 static void
326 gtk_im_multicontext_set_cursor_location (GtkIMContext   *context,
327                                          GdkRectangle   *area)
328 {
329   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
330   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
331
332   if (slave)
333     gtk_im_context_set_cursor_location (slave, area);
334 }
335
336 static void
337 gtk_im_multicontext_set_use_preedit (GtkIMContext   *context,
338                                      gboolean       use_preedit)
339 {
340   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
341   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
342
343   if (slave)
344     gtk_im_context_set_use_preedit (slave, use_preedit);
345 }
346
347 static gboolean
348 gtk_im_multicontext_get_surrounding (GtkIMContext  *context,
349                                      gchar        **text,
350                                      gint          *cursor_index)
351 {
352   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
353   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
354
355   if (slave)
356     return gtk_im_context_get_surrounding (context, text, cursor_index);
357   else
358     {
359       if (text)
360         *text = NULL;
361       if (cursor_index)
362         *cursor_index = 0;
363
364       return FALSE;
365     }
366 }
367
368 static void
369 gtk_im_multicontext_set_surrounding (GtkIMContext *context,
370                                      const char   *text,
371                                      gint          len,
372                                      gint          cursor_index)
373 {
374   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
375   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
376
377   if (slave)
378     gtk_im_context_set_surrounding (slave, text, len, cursor_index);
379 }
380
381 static void
382 gtk_im_multicontext_preedit_start_cb   (GtkIMContext      *slave,
383                                         GtkIMMulticontext *multicontext)
384 {
385   g_signal_emit_by_name (multicontext, "preedit_start");
386 }
387
388 static void
389 gtk_im_multicontext_preedit_end_cb (GtkIMContext      *slave,
390                                     GtkIMMulticontext *multicontext)
391 {
392   g_signal_emit_by_name (multicontext, "preedit_end");
393 }
394
395 static void
396 gtk_im_multicontext_preedit_changed_cb (GtkIMContext      *slave,
397                                         GtkIMMulticontext *multicontext)
398 {
399   g_signal_emit_by_name (multicontext, "preedit_changed");
400 }
401
402 static void
403 gtk_im_multicontext_commit_cb (GtkIMContext      *slave,
404                                const gchar       *str,
405                                GtkIMMulticontext *multicontext)
406 {
407   g_signal_emit_by_name (multicontext, "commit", str);;
408 }
409
410 static gboolean
411 gtk_im_multicontext_retrieve_surrounding_cb (GtkIMContext      *slave,
412                                              GtkIMMulticontext *multicontext)
413 {
414   gboolean result;
415   
416   g_signal_emit_by_name (multicontext, "retrieve_surrounding", &result);
417
418   return result;
419 }
420
421 static gboolean
422 gtk_im_multicontext_delete_surrounding_cb (GtkIMContext      *slave,
423                                            gint               offset,
424                                            gint               n_chars,
425                                            GtkIMMulticontext *multicontext)
426 {
427   gboolean result;
428   
429   g_signal_emit_by_name (multicontext, "delete_surrounding",
430                          offset, n_chars, &result);
431
432   return result;
433 }
434
435 static void
436 activate_cb (GtkWidget         *menuitem,
437              GtkIMMulticontext *context)
438 {
439   if (GTK_CHECK_MENU_ITEM (menuitem)->active)
440     {
441       const gchar *id = gtk_object_get_data (GTK_OBJECT (menuitem), "gtk-context-id");
442
443       gtk_im_context_reset (GTK_IM_CONTEXT (context));
444       
445       global_context_id = id;
446       gtk_im_multicontext_set_slave (context, NULL, FALSE);
447     }
448 }
449
450 /**
451  * gtk_im_multicontext_append_menuitems:
452  * @context: a #GtkIMMultiContext
453  * @menushell: a #GtkMenuShell
454  * 
455  * Add menuitems for various available input methods to a menu;
456  * the menuitems, when selected, will switch the input method
457  * for the context and the global default input method.
458  **/
459 void
460 gtk_im_multicontext_append_menuitems (GtkIMMulticontext *context,
461                                       GtkMenuShell      *menushell)
462 {
463   const GtkIMContextInfo **contexts;
464   gint n_contexts, i;
465   GSList *group = NULL;
466   
467   _gtk_im_module_list (&contexts, &n_contexts);
468
469   for (i=0; i < n_contexts; i++)
470     {
471       GtkWidget *menuitem;
472
473       menuitem = gtk_radio_menu_item_new_with_label (group,
474                                                      contexts[i]->context_name);
475       
476       if ((global_context_id == NULL && group == NULL) ||
477           (global_context_id &&
478            strcmp (contexts[i]->context_id, global_context_id) == 0))
479         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
480                                         TRUE);
481       
482       group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
483       
484       gtk_object_set_data (GTK_OBJECT (menuitem), "gtk-context-id",
485                            (char *)contexts[i]->context_id);
486       gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
487                           G_CALLBACK (activate_cb), context);
488
489       gtk_widget_show (menuitem);
490       gtk_menu_shell_append (menushell, menuitem);
491     }
492 }
493