Pileus Git - ~andy/gtk/blob - 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 <config.h>
  21
  22 #include <string.h>
  23 #include <locale.h>
  24
  25 #include "gtkimmulticontext.h"
  26 #include "gtkimmodule.h"
  27 #include "gtkmain.h"
  28 #include "gtkradiomenuitem.h"
  29 #include "gtkintl.h"
  30 #include "gtkprivate.h" /* To get redefinition of GTK_LOCALE_DIR on Win32 */
  31 #include "gtkalias.h"
  32
  33 struct _GtkIMMulticontextPrivate
  34 {
  35   GdkWindow *client_window;
  36   GdkRectangle cursor_location;
  37
  38   guint use_preedit : 1;
  39   guint have_cursor_location : 1;
  40   guint focus_in : 1;
  41 };
  42
  43 static void     gtk_im_multicontext_finalize           (GObject                 *object);
  44
  45 static void     gtk_im_multicontext_set_slave          (GtkIMMulticontext       *multicontext,
  46                                                         GtkIMContext            *slave,
  47                                                         gboolean                 finalizing);
  48
  49 static void     gtk_im_multicontext_set_client_window  (GtkIMContext            *context,
  50                                                         GdkWindow               *window);
  51 static void     gtk_im_multicontext_get_preedit_string (GtkIMContext            *context,
  52                                                         gchar                  **str,
  53                                                         PangoAttrList          **attrs,
  54                                                         gint                   *cursor_pos);
  55 static gboolean gtk_im_multicontext_filter_keypress    (GtkIMContext            *context,
  56                                                         GdkEventKey             *event);
  57 static void     gtk_im_multicontext_focus_in           (GtkIMContext            *context);
  58 static void     gtk_im_multicontext_focus_out          (GtkIMContext            *context);
  59 static void     gtk_im_multicontext_reset              (GtkIMContext            *context);
  60 static void     gtk_im_multicontext_set_cursor_location (GtkIMContext            *context,
  61                                                         GdkRectangle            *area);
  62 static void     gtk_im_multicontext_set_use_preedit    (GtkIMContext            *context,
  63                                                         gboolean                 use_preedit);
  64 static gboolean gtk_im_multicontext_get_surrounding    (GtkIMContext            *context,
  65                                                         gchar                  **text,
  66                                                         gint                    *cursor_index);
  67 static void     gtk_im_multicontext_set_surrounding    (GtkIMContext            *context,
  68                                                         const char              *text,
  69                                                         gint                     len,
  70                                                         gint                     cursor_index);
  71
  72 static void     gtk_im_multicontext_preedit_start_cb        (GtkIMContext      *slave,
  73                                                              GtkIMMulticontext *multicontext);
  74 static void     gtk_im_multicontext_preedit_end_cb          (GtkIMContext      *slave,
  75                                                              GtkIMMulticontext *multicontext);
  76 static void     gtk_im_multicontext_preedit_changed_cb      (GtkIMContext      *slave,
  77                                                              GtkIMMulticontext *multicontext);
  78 static void     gtk_im_multicontext_commit_cb               (GtkIMContext      *slave,
  79                                                              const gchar       *str,
  80                                                              GtkIMMulticontext *multicontext);
  81 static gboolean gtk_im_multicontext_retrieve_surrounding_cb (GtkIMContext      *slave,
  82                                                              GtkIMMulticontext *multicontext);
  83 static gboolean gtk_im_multicontext_delete_surrounding_cb   (GtkIMContext      *slave,
  84                                                              gint               offset,
  85                                                              gint               n_chars,
  86                                                              GtkIMMulticontext *multicontext);
  87
  88 static const gchar *global_context_id = NULL;
  89
  90 G_DEFINE_TYPE (GtkIMMulticontext, gtk_im_multicontext, GTK_TYPE_IM_CONTEXT)
  91
  92 static void
  93 gtk_im_multicontext_class_init (GtkIMMulticontextClass *class)
  94 {
  95   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
  96   GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (class);
  97
  98   im_context_class->set_client_window = gtk_im_multicontext_set_client_window;
  99   im_context_class->get_preedit_string = gtk_im_multicontext_get_preedit_string;
 100   im_context_class->filter_keypress = gtk_im_multicontext_filter_keypress;
 101   im_context_class->focus_in = gtk_im_multicontext_focus_in;
 102   im_context_class->focus_out = gtk_im_multicontext_focus_out;
 103   im_context_class->reset = gtk_im_multicontext_reset;
 104   im_context_class->set_cursor_location = gtk_im_multicontext_set_cursor_location;
 105   im_context_class->set_use_preedit = gtk_im_multicontext_set_use_preedit;
 106   im_context_class->set_surrounding = gtk_im_multicontext_set_surrounding;
 107   im_context_class->get_surrounding = gtk_im_multicontext_get_surrounding;
 108
 109   gobject_class->finalize = gtk_im_multicontext_finalize;
 110
 111   g_type_class_add_private (gobject_class, sizeof (GtkIMMulticontextPrivate));
 112 }
 113
 114 static void
 115 gtk_im_multicontext_init (GtkIMMulticontext *multicontext)
 116 {
 117   multicontext->slave = NULL;
 118
 119   multicontext->priv = G_TYPE_INSTANCE_GET_PRIVATE (multicontext, GTK_TYPE_IM_MULTICONTEXT, GtkIMMulticontextPrivate);
 120   multicontext->priv->use_preedit = TRUE;
 121   multicontext->priv->have_cursor_location = FALSE;
 122   multicontext->priv->focus_in = FALSE;
 123 }
 124
 125 /**
 126  * gtk_im_multicontext_new:
 127  *
 128  * Creates a new #GtkIMMulticontext.
 129  *
 130  * Returns: a new #GtkIMMulticontext.
 131  **/
 132 GtkIMContext *
 133 gtk_im_multicontext_new (void)
 134 {
 135   return g_object_new (GTK_TYPE_IM_MULTICONTEXT, NULL);
 136 }
 137
 138 static void
 139 gtk_im_multicontext_finalize (GObject *object)
 140 {
 141   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (object);
 142
 143   gtk_im_multicontext_set_slave (multicontext, NULL, TRUE);
 144
 145   G_OBJECT_CLASS (gtk_im_multicontext_parent_class)->finalize (object);
 146 }
 147
 148 static void
 149 gtk_im_multicontext_set_slave (GtkIMMulticontext *multicontext,
 150                                GtkIMContext      *slave,
 151                                gboolean           finalizing)
 152 {
 153   GtkIMMulticontextPrivate *priv = multicontext->priv;
 154   gboolean need_preedit_changed = FALSE;
 155
 156   if (multicontext->slave)
 157     {
 158       if (!finalizing)
 159         gtk_im_context_reset (multicontext->slave);
 160
 161       g_signal_handlers_disconnect_by_func (multicontext->slave,
 162                                             gtk_im_multicontext_preedit_start_cb,
 163                                             multicontext);
 164       g_signal_handlers_disconnect_by_func (multicontext->slave,
 165                                             gtk_im_multicontext_preedit_end_cb,
 166                                             multicontext);
 167       g_signal_handlers_disconnect_by_func (multicontext->slave,
 168                                             gtk_im_multicontext_preedit_changed_cb,
 169                                             multicontext);
 170       g_signal_handlers_disconnect_by_func (multicontext->slave,
 171                                             gtk_im_multicontext_commit_cb,
 172                                             multicontext);
 173
 174       g_object_unref (multicontext->slave);
 175       multicontext->slave = NULL;
 176
 177       if (!finalizing)
 178         need_preedit_changed = TRUE;
 179     }
 180
 181   multicontext->slave = slave;
 182
 183   if (multicontext->slave)
 184     {
 185       g_object_ref (multicontext->slave);
 186
 187       g_signal_connect (multicontext->slave, "preedit_start",
 188                         G_CALLBACK (gtk_im_multicontext_preedit_start_cb),
 189                         multicontext);
 190       g_signal_connect (multicontext->slave, "preedit_end",
 191                         G_CALLBACK (gtk_im_multicontext_preedit_end_cb),
 192                         multicontext);
 193       g_signal_connect (multicontext->slave, "preedit_changed",
 194                         G_CALLBACK (gtk_im_multicontext_preedit_changed_cb),
 195                         multicontext);
 196       g_signal_connect (multicontext->slave, "commit",
 197                         G_CALLBACK (gtk_im_multicontext_commit_cb),
 198                         multicontext);
 199       g_signal_connect (multicontext->slave, "retrieve_surrounding",
 200                         G_CALLBACK (gtk_im_multicontext_retrieve_surrounding_cb),
 201                         multicontext);
 202       g_signal_connect (multicontext->slave, "delete_surrounding",
 203                         G_CALLBACK (gtk_im_multicontext_delete_surrounding_cb),
 204                         multicontext);
 205
 206       if (!priv->use_preedit)   /* Default is TRUE */
 207         gtk_im_context_set_use_preedit (slave, FALSE);
 208       if (priv->client_window)
 209         gtk_im_context_set_client_window (slave, priv->client_window);
 210       if (priv->have_cursor_location)
 211         gtk_im_context_set_cursor_location (slave, &priv->cursor_location);
 212       if (priv->focus_in)
 213         gtk_im_context_focus_in (slave);
 214     }
 215
 216   if (need_preedit_changed)
 217     g_signal_emit_by_name (multicontext, "preedit_changed");
 218 }
 219
 220 static GtkIMContext *
 221 gtk_im_multicontext_get_slave (GtkIMMulticontext *multicontext)
 222 {
 223   if (!multicontext->slave)
 224     {
 225       GtkIMContext *slave;
 226
 227       if (!global_context_id)
 228         {
 229           gchar *locale = _gtk_get_lc_ctype ();
 230           global_context_id = _gtk_im_module_get_default_context_id (locale);
 231           g_free (locale);
 232         }
 233
 234       slave = _gtk_im_module_create (global_context_id);
 235       gtk_im_multicontext_set_slave (multicontext, slave, FALSE);
 236       g_object_unref (slave);
 237
 238       multicontext->context_id = global_context_id;
 239     }
 240
 241   return multicontext->slave;
 242 }
 243
 244 static void
 245 gtk_im_multicontext_set_client_window (GtkIMContext *context,
 246                                        GdkWindow    *window)
 247 {
 248   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 249
 250   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 251
 252   multicontext->priv->client_window = window;
 253
 254   if (slave)
 255     gtk_im_context_set_client_window (slave, window);
 256 }
 257
 258 static void
 259 gtk_im_multicontext_get_preedit_string (GtkIMContext   *context,
 260                                         gchar         **str,
 261                                         PangoAttrList **attrs,
 262                                         gint           *cursor_pos)
 263 {
 264   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 265   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 266
 267   if (slave)
 268     gtk_im_context_get_preedit_string (slave, str, attrs, cursor_pos);
 269   else
 270     {
 271       if (str)
 272         *str = g_strdup ("");
 273       if (attrs)
 274         *attrs = pango_attr_list_new ();
 275     }
 276 }
 277
 278 static gboolean
 279 gtk_im_multicontext_filter_keypress (GtkIMContext *context,
 280                                      GdkEventKey  *event)
 281 {
 282   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 283   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 284
 285   if (slave)
 286     return gtk_im_context_filter_keypress (slave, event);
 287   else
 288     return FALSE;
 289 }
 290
 291 static void
 292 gtk_im_multicontext_focus_in (GtkIMContext   *context)
 293 {
 294   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 295   GtkIMContext *slave;
 296
 297   /* If the global context type is different from the context we were
 298    * using before, get rid of the old slave and create a new one
 299    * for the new global context type.
 300    */
 301   if (!multicontext->context_id ||
 302       strcmp (global_context_id, multicontext->context_id) != 0)
 303     gtk_im_multicontext_set_slave (multicontext, NULL, FALSE);
 304
 305   slave = gtk_im_multicontext_get_slave (multicontext);
 306
 307   multicontext->priv->focus_in = TRUE;
 308
 309   if (slave)
 310     gtk_im_context_focus_in (slave);
 311 }
 312
 313 static void
 314 gtk_im_multicontext_focus_out (GtkIMContext   *context)
 315 {
 316   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 317   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 318
 319   multicontext->priv->focus_in = FALSE;
 320
 321   if (slave)
 322     gtk_im_context_focus_out (slave);
 323 }
 324
 325 static void
 326 gtk_im_multicontext_reset (GtkIMContext   *context)
 327 {
 328   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 329   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 330
 331   if (slave)
 332     gtk_im_context_reset (slave);
 333 }
 334
 335 static void
 336 gtk_im_multicontext_set_cursor_location (GtkIMContext   *context,
 337                                          GdkRectangle   *area)
 338 {
 339   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 340   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 341
 342   multicontext->priv->have_cursor_location = TRUE;
 343   multicontext->priv->cursor_location = *area;
 344
 345   if (slave)
 346     gtk_im_context_set_cursor_location (slave, area);
 347 }
 348
 349 static void
 350 gtk_im_multicontext_set_use_preedit (GtkIMContext   *context,
 351                                      gboolean       use_preedit)
 352 {
 353   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 354   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 355
 356   use_preedit = use_preedit != FALSE;
 357
 358   multicontext->priv->use_preedit = use_preedit;
 359
 360   if (slave)
 361     gtk_im_context_set_use_preedit (slave, use_preedit);
 362 }
 363
 364 static gboolean
 365 gtk_im_multicontext_get_surrounding (GtkIMContext  *context,
 366                                      gchar        **text,
 367                                      gint          *cursor_index)
 368 {
 369   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 370   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 371
 372   if (slave)
 373     return gtk_im_context_get_surrounding (slave, text, cursor_index);
 374   else
 375     {
 376       if (text)
 377         *text = NULL;
 378       if (cursor_index)
 379         *cursor_index = 0;
 380
 381       return FALSE;
 382     }
 383 }
 384
 385 static void
 386 gtk_im_multicontext_set_surrounding (GtkIMContext *context,
 387                                      const char   *text,
 388                                      gint          len,
 389                                      gint          cursor_index)
 390 {
 391   GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
 392   GtkIMContext *slave = gtk_im_multicontext_get_slave (multicontext);
 393
 394   if (slave)
 395     gtk_im_context_set_surrounding (slave, text, len, cursor_index);
 396 }
 397
 398 static void
 399 gtk_im_multicontext_preedit_start_cb   (GtkIMContext      *slave,
 400                                         GtkIMMulticontext *multicontext)
 401 {
 402   g_signal_emit_by_name (multicontext, "preedit_start");
 403 }
 404
 405 static void
 406 gtk_im_multicontext_preedit_end_cb (GtkIMContext      *slave,
 407                                     GtkIMMulticontext *multicontext)
 408 {
 409   g_signal_emit_by_name (multicontext, "preedit_end");
 410 }
 411
 412 static void
 413 gtk_im_multicontext_preedit_changed_cb (GtkIMContext      *slave,
 414                                         GtkIMMulticontext *multicontext)
 415 {
 416   g_signal_emit_by_name (multicontext, "preedit_changed");
 417 }
 418
 419 static void
 420 gtk_im_multicontext_commit_cb (GtkIMContext      *slave,
 421                                const gchar       *str,
 422                                GtkIMMulticontext *multicontext)
 423 {
 424   g_signal_emit_by_name (multicontext, "commit", str);;
 425 }
 426
 427 static gboolean
 428 gtk_im_multicontext_retrieve_surrounding_cb (GtkIMContext      *slave,
 429                                              GtkIMMulticontext *multicontext)
 430 {
 431   gboolean result;
 432
 433   g_signal_emit_by_name (multicontext, "retrieve_surrounding", &result);
 434
 435   return result;
 436 }
 437
 438 static gboolean
 439 gtk_im_multicontext_delete_surrounding_cb (GtkIMContext      *slave,
 440                                            gint               offset,
 441                                            gint               n_chars,
 442                                            GtkIMMulticontext *multicontext)
 443 {
 444   gboolean result;
 445
 446   g_signal_emit_by_name (multicontext, "delete_surrounding",
 447                          offset, n_chars, &result);
 448
 449   return result;
 450 }
 451
 452 static void
 453 activate_cb (GtkWidget         *menuitem,
 454              GtkIMMulticontext *context)
 455 {
 456   if (GTK_CHECK_MENU_ITEM (menuitem)->active)
 457     {
 458       const gchar *id = g_object_get_data (G_OBJECT (menuitem), "gtk-context-id");
 459
 460       gtk_im_context_reset (GTK_IM_CONTEXT (context));
 461
 462       global_context_id = id;
 463       gtk_im_multicontext_set_slave (context, NULL, FALSE);
 464     }
 465 }
 466
 467 static int
 468 pathnamecmp (const char *a,
 469              const char *b)
 470 {
 471 #ifndef G_OS_WIN32
 472   return strcmp (a, b);
 473 #else
 474   /* Ignore case insensitivity, probably not that relevant here. Just
 475    * make sure slash and backslash compare equal.
 476    */
 477   while (*a && *b)
 478     if ((G_IS_DIR_SEPARATOR (*a) && G_IS_DIR_SEPARATOR (*b)) ||
 479         *a == *b)
 480       a++, b++;
 481     else
 482       return (*a - *b);
 483   return (*a - *b);
 484 #endif
 485 }
 486
 487 /**
 488  * gtk_im_multicontext_append_menuitems:
 489  * @context: a #GtkIMMultiContext
 490  * @menushell: a #GtkMenuShell
 491  *
 492  * Add menuitems for various available input methods to a menu;
 493  * the menuitems, when selected, will switch the input method
 494  * for the context and the global default input method.
 495  **/
 496 void
 497 gtk_im_multicontext_append_menuitems (GtkIMMulticontext *context,
 498                                       GtkMenuShell      *menushell)
 499 {
 500   const GtkIMContextInfo **contexts;
 501   guint n_contexts, i;
 502   GSList *group = NULL;
 503
 504   _gtk_im_module_list (&contexts, &n_contexts);
 505
 506   for (i=0; i < n_contexts; i++)
 507     {
 508       GtkWidget *menuitem;
 509       const gchar *translated_name;
 510 #ifdef ENABLE_NLS
 511       if (contexts[i]->domain && contexts[i]->domain[0])
 512         {
 513           if (strcmp (contexts[i]->domain, GETTEXT_PACKAGE) == 0)
 514             {
 515               /* Same translation domain as GTK+ */
 516               if (!(contexts[i]->domain_dirname && contexts[i]->domain_dirname[0]) ||
 517                   pathnamecmp (contexts[i]->domain_dirname, GTK_LOCALEDIR) == 0)
 518                 {
 519                   /* Empty or NULL, domain directory, or same as
 520                    * GTK+. Input method may have a name in the GTK+
 521                    * message catalog.
 522                    */
 523                   translated_name = _(contexts[i]->context_name);
 524                 }
 525               else
 526                 {
 527                   /* Separate domain directory but the same
 528                    * translation domain as GTK+. We can't call
 529                    * bindtextdomain() as that would make GTK+ forget
 530                    * its own messages.
 531                    */
 532                   g_warning ("Input method %s should not use GTK's translation domain %s",
 533                              contexts[i]->context_id, GETTEXT_PACKAGE);
 534                   /* Try translating the name in GTK+'s domain */
 535                   translated_name = _(contexts[i]->context_name);
 536                 }
 537             }
 538           else if (contexts[i]->domain_dirname && contexts[i]->domain_dirname[0])
 539             /* Input method has own translation domain and message catalog */
 540             {
 541               bindtextdomain (contexts[i]->domain,
 542                               contexts[i]->domain_dirname);
 543 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
 544               bind_textdomain_codeset (contexts[i]->domain, "UTF-8");
 545 #endif
 546               translated_name = dgettext (contexts[i]->domain, contexts[i]->context_name);
 547             }
 548           else
 549             {
 550               /* Different translation domain, but no domain directory */
 551               translated_name = contexts[i]->context_name;
 552             }
 553         }
 554       else
 555         /* Empty or NULL domain. We assume that input method does not
 556          * want a translated name in this case.
 557          */
 558         translated_name = contexts[i]->context_name;
 559 #else
 560       translated_name = contexts[i]->context_name;
 561 #endif
 562       menuitem = gtk_radio_menu_item_new_with_label (group,
 563                                                      translated_name);
 564
 565       if ((global_context_id == NULL && group == NULL) ||
 566           (global_context_id &&
 567            strcmp (contexts[i]->context_id, global_context_id) == 0))
 568         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
 569                                         TRUE);
 570
 571       group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
 572
 573       g_object_set_data (G_OBJECT (menuitem), I_("gtk-context-id"),
 574                          (char *)contexts[i]->context_id);
 575       g_signal_connect (menuitem, "activate",
 576                         G_CALLBACK (activate_cb), context);
 577
 578       gtk_widget_show (menuitem);
 579       gtk_menu_shell_append (menushell, menuitem);
 580     }
 581
 582   g_free (contexts);
 583 }
 584
 585 #define __GTK_IM_MULTICONTEXT_C__
 586 #include "gtkaliasdef.c"