Pileus Git - ~andy/gtk/blob - gtk/gtkimcontextsimple.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 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include <gdk/gdkkeysyms.h>
  25 #include "gtkaccelgroup.h"
  26 #include "gtkimcontextsimple.h"
  27 #include "gtksettings.h"
  28 #include "gtkwidget.h"
  29 #include "gtkintl.h"
  30 #include "gtkalias.h"
  31
  32 typedef struct _GtkComposeTable GtkComposeTable;
  33 typedef struct _GtkComposeTableCompact GtkComposeTableCompact;
  34
  35 struct _GtkComposeTable
  36 {
  37   const guint16 *data;
  38   gint max_seq_len;
  39   gint n_seqs;
  40 };
  41
  42 struct _GtkComposeTableCompact
  43 {
  44   const guint16 *data;
  45   gint max_seq_len;
  46   gint n_index_size;
  47   gint n_index_stride;
  48 };
  49
  50 /* This file contains the table of the compose sequences,
  51  * static const guint16 gtk_compose_seqs_compact[] = {}
  52  * IT is generated from the compose-parse.py script.
  53  */
  54 #include "gtkimcontextsimpleseqs.h"
  55
  56 /* From the values below, the value 23 means the number of different first keysyms
  57  * that exist in the Compose file (from Xorg). When running compose-parse.py without
  58  * parameters, you get the count that you can put here. Needed when updating the
  59  * gtkimcontextsimpleseqs.h header file (contains the compose sequences).
  60  */
  61 static const GtkComposeTableCompact gtk_compose_table_compact = {
  62   gtk_compose_seqs_compact,
  63   5,
  64   23,
  65   6
  66 };
  67
  68 static const guint16 gtk_compose_ignore[] = {
  69   GDK_Shift_L,
  70   GDK_Shift_R,
  71   GDK_Control_L,
  72   GDK_Control_R,
  73   GDK_Caps_Lock,
  74   GDK_Shift_Lock,
  75   GDK_Meta_L,
  76   GDK_Meta_R,
  77   GDK_Alt_L,
  78   GDK_Alt_R,
  79   GDK_Super_L,
  80   GDK_Super_R,
  81   GDK_Hyper_L,
  82   GDK_Hyper_R,
  83   GDK_Mode_switch,
  84   GDK_ISO_Level3_Shift
  85 };
  86
  87 static void     gtk_im_context_simple_finalize           (GObject                  *obj);
  88 static gboolean gtk_im_context_simple_filter_keypress    (GtkIMContext             *context,
  89                                                           GdkEventKey              *key);
  90 static void     gtk_im_context_simple_reset              (GtkIMContext             *context);
  91 static void     gtk_im_context_simple_get_preedit_string (GtkIMContext             *context,
  92                                                           gchar                   **str,
  93                                                           PangoAttrList           **attrs,
  94                                                           gint                     *cursor_pos);
  95
  96 G_DEFINE_TYPE (GtkIMContextSimple, gtk_im_context_simple, GTK_TYPE_IM_CONTEXT)
  97
  98 static void
  99 gtk_im_context_simple_class_init (GtkIMContextSimpleClass *class)
 100 {
 101   GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (class);
 102   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 103
 104   im_context_class->filter_keypress = gtk_im_context_simple_filter_keypress;
 105   im_context_class->reset = gtk_im_context_simple_reset;
 106   im_context_class->get_preedit_string = gtk_im_context_simple_get_preedit_string;
 107   gobject_class->finalize = gtk_im_context_simple_finalize;
 108 }
 109
 110 static void
 111 gtk_im_context_simple_init (GtkIMContextSimple *im_context_simple)
 112 {
 113 }
 114
 115 static void
 116 gtk_im_context_simple_finalize (GObject *obj)
 117 {
 118   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (obj);
 119
 120   if (context_simple->tables)
 121     {
 122       g_slist_foreach (context_simple->tables, (GFunc)g_free, NULL);
 123       g_slist_free (context_simple->tables);
 124
 125       context_simple->tables = NULL;
 126     }
 127
 128   G_OBJECT_CLASS (gtk_im_context_simple_parent_class)->finalize (obj);
 129 }
 130
 131 /**
 132  * gtk_im_context_simple_new:
 133  *
 134  * Creates a new #GtkIMContextSimple.
 135  *
 136  * Returns: a new #GtkIMContextSimple.
 137  **/
 138 GtkIMContext *
 139 gtk_im_context_simple_new (void)
 140 {
 141   return g_object_new (GTK_TYPE_IM_CONTEXT_SIMPLE, NULL);
 142 }
 143
 144 static void
 145 gtk_im_context_simple_commit_char (GtkIMContext *context,
 146                                    gunichar ch)
 147 {
 148   gchar buf[10];
 149   gint len;
 150
 151   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
 152
 153   g_return_if_fail (g_unichar_validate (ch));
 154
 155   len = g_unichar_to_utf8 (ch, buf);
 156   buf[len] = '\0';
 157
 158   if (context_simple->tentative_match || context_simple->in_hex_sequence)
 159     {
 160       context_simple->in_hex_sequence = FALSE;
 161       context_simple->tentative_match = 0;
 162       context_simple->tentative_match_len = 0;
 163       g_signal_emit_by_name (context_simple, "preedit-changed");
 164       g_signal_emit_by_name (context_simple, "preedit-end");
 165     }
 166
 167   g_signal_emit_by_name (context, "commit", &buf);
 168 }
 169
 170 static int
 171 compare_seq_index (const void *key, const void *value)
 172 {
 173   const guint *keysyms = key;
 174   const guint16 *seq = value;
 175
 176   if (keysyms[0] < seq[0])
 177     return -1;
 178   else if (keysyms[0] > seq[0])
 179     return 1;
 180
 181   return 0;
 182 }
 183
 184 static int
 185 compare_seq (const void *key, const void *value)
 186 {
 187   int i = 0;
 188   const guint *keysyms = key;
 189   const guint16 *seq = value;
 190
 191   while (keysyms[i])
 192     {
 193       if (keysyms[i] < seq[i])
 194         return -1;
 195       else if (keysyms[i] > seq[i])
 196         return 1;
 197
 198       i++;
 199     }
 200
 201   return 0;
 202 }
 203
 204 static gboolean
 205 check_table (GtkIMContextSimple    *context_simple,
 206              const GtkComposeTable *table,
 207              gint                   n_compose)
 208 {
 209   gint row_stride = table->max_seq_len + 2;
 210   guint16 *seq;
 211
 212   /* Will never match, if the sequence in the compose buffer is longer
 213    * than the sequences in the table.  Further, compare_seq (key, val)
 214    * will overrun val if key is longer than val. */
 215   if (n_compose > table->max_seq_len)
 216     return FALSE;
 217
 218   seq = bsearch (context_simple->compose_buffer,
 219                  table->data, table->n_seqs,
 220                  sizeof (guint16) *  row_stride,
 221                  compare_seq);
 222
 223   if (seq)
 224     {
 225       guint16 *prev_seq;
 226
 227       /* Back up to the first sequence that matches to make sure
 228        * we find the exact match if their is one.
 229        */
 230       while (seq > table->data)
 231         {
 232           prev_seq = seq - row_stride;
 233           if (compare_seq (context_simple->compose_buffer, prev_seq) != 0)
 234             break;
 235           seq = prev_seq;
 236         }
 237
 238       if (n_compose == table->max_seq_len ||
 239           seq[n_compose] == 0) /* complete sequence */
 240         {
 241           guint16 *next_seq;
 242           gunichar value =
 243             0x10000 * seq[table->max_seq_len] + seq[table->max_seq_len + 1];
 244
 245
 246           /* We found a tentative match. See if there are any longer
 247            * sequences containing this subsequence
 248            */
 249           next_seq = seq + row_stride;
 250           if (next_seq < table->data + row_stride * table->n_seqs)
 251             {
 252               if (compare_seq (context_simple->compose_buffer, next_seq) == 0)
 253                 {
 254                   context_simple->tentative_match = value;
 255                   context_simple->tentative_match_len = n_compose;
 256
 257                   g_signal_emit_by_name (context_simple, "preedit-changed");
 258
 259                   return TRUE;
 260                 }
 261             }
 262
 263           gtk_im_context_simple_commit_char (GTK_IM_CONTEXT (context_simple), value);
 264           context_simple->compose_buffer[0] = 0;
 265         }
 266
 267       return TRUE;
 268     }
 269
 270   return FALSE;
 271 }
 272
 273 static gboolean
 274 check_compact_table (GtkIMContextSimple    *context_simple,
 275              const GtkComposeTableCompact *table,
 276              gint                   n_compose)
 277 {
 278   gint row_stride;
 279   guint16 *seq_index;
 280   guint16 *seq;
 281   gint i;
 282
 283   /* Will never match, if the sequence in the compose buffer is longer
 284    * than the sequences in the table.  Further, compare_seq (key, val)
 285    * will overrun val if key is longer than val. */
 286   if (n_compose > table->max_seq_len)
 287     return FALSE;
 288
 289   seq_index = bsearch (context_simple->compose_buffer,
 290                  table->data, table->n_index_size,
 291                  sizeof (guint16) *  table->n_index_stride,
 292                  compare_seq_index);
 293
 294   if (!seq_index)
 295     return FALSE;
 296
 297   if (seq_index && n_compose == 1)
 298     return TRUE;
 299
 300   seq = NULL;
 301
 302   for (i = n_compose-1; i < table->max_seq_len; i++)
 303     {
 304       row_stride = i + 1;
 305
 306       if (seq_index[i+1] - seq_index[i] > 0)
 307         {
 308           seq = bsearch (context_simple->compose_buffer + 1,
 309                  table->data + seq_index[i], (seq_index[i+1] - seq_index[i]) / row_stride,
 310                  sizeof (guint16) *  row_stride,
 311                  compare_seq);
 312
 313           if (seq)
 314             {
 315               if (i == n_compose - 1)
 316                 break;
 317               else
 318                 {
 319                   g_signal_emit_by_name (context_simple, "preedit-changed");
 320                   return TRUE;
 321                 }
 322              }
 323         }
 324     }
 325
 326   if (!seq)
 327     return FALSE;
 328   else
 329     {
 330       gunichar value;
 331
 332       value = seq[row_stride - 1];
 333
 334       gtk_im_context_simple_commit_char (GTK_IM_CONTEXT (context_simple), value);
 335       context_simple->compose_buffer[0] = 0;
 336
 337       return TRUE;
 338     }
 339
 340   return FALSE;
 341 }
 342
 343 /* This function receives a sequence of Unicode characters and tries to
 344  * normalize it (NFC). We check for the case the the resulting string
 345  * has length 1 (single character).
 346  * NFC normalisation normally rearranges diacritic marks, unless these
 347  * belong to the same Canonical Combining Class.
 348  * If they belong to the same canonical combining class, we produce all
 349  * permutations of the diacritic marks, then attempt to normalize.
 350  */
 351 static gboolean
 352 check_normalize_nfc (gunichar* combination_buffer, gint n_compose)
 353 {
 354   gunichar combination_buffer_temp[GTK_MAX_COMPOSE_LEN];
 355   gchar *combination_utf8_temp = NULL;
 356   gchar *nfc_temp = NULL;
 357   gint n_combinations;
 358   gunichar temp_swap;
 359   gint i;
 360
 361   n_combinations = 1;
 362
 363   for (i = 1; i < n_compose; i++ )
 364      n_combinations *= i;
 365
 366   /* Xorg reuses dead_tilde for the perispomeni diacritic mark.
 367    * We check if base character belongs to Greek Unicode block,
 368    * and if so, we replace tilde with perispomeni. */
 369   if (combination_buffer[0] >= 0x390 && combination_buffer[0] <= 0x3FF)
 370     {
 371       for (i = 1; i < n_compose; i++ )
 372         if (combination_buffer[i] == 0x303)
 373           combination_buffer[i] = 0x342;
 374     }
 375
 376   memcpy (combination_buffer_temp, combination_buffer, GTK_MAX_COMPOSE_LEN * sizeof (gunichar) );
 377
 378   for (i = 0; i < n_combinations; i++ )
 379     {
 380       g_unicode_canonical_ordering (combination_buffer_temp, n_compose);
 381       combination_utf8_temp = g_ucs4_to_utf8 (combination_buffer_temp, -1, NULL, NULL, NULL);
 382       nfc_temp = g_utf8_normalize (combination_utf8_temp, -1, G_NORMALIZE_NFC);
 383
 384       if (g_utf8_strlen (nfc_temp, -1) == 1)
 385         {
 386           memcpy (combination_buffer, combination_buffer_temp, GTK_MAX_COMPOSE_LEN * sizeof (gunichar) );
 387
 388           g_free (combination_utf8_temp);
 389           g_free (nfc_temp);
 390
 391           return TRUE;
 392         }
 393
 394       g_free (combination_utf8_temp);
 395       g_free (nfc_temp);
 396
 397       if (n_compose > 2)
 398         {
 399           temp_swap = combination_buffer_temp[i % (n_compose - 1) + 1];
 400           combination_buffer_temp[i % (n_compose - 1) + 1] = combination_buffer_temp[(i+1) % (n_compose - 1) + 1];
 401           combination_buffer_temp[(i+1) % (n_compose - 1) + 1] = temp_swap;
 402         }
 403       else
 404         break;
 405     }
 406
 407   return FALSE;
 408 }
 409
 410 /* Checks if a keysym is a dead key. Dead key keysym values are defined in
 411  * ../gdk/gdkkeysyms.h and the first is GDK_dead_grave. As X.Org is updated,
 412  * more dead keys are added and we need to update the upper limit.
 413  * Currently, the upper limit is GDK_dead_dasia+1. The +1 has to do with
 414  * a temporary issue in the X.Org header files.
 415  * In future versions it will be just the keysym (no +1).
 416  */
 417 #define IS_DEAD_KEY(k) \
 418     ((k) >= GDK_dead_grave && (k) <= (GDK_dead_dasia+1))
 419
 420 static gboolean
 421 check_algorithmically (GtkIMContextSimple    *context_simple,
 422                        gint                   n_compose)
 423
 424 {
 425   gint i;
 426   gunichar combination_buffer[GTK_MAX_COMPOSE_LEN];
 427   gchar *combination_utf8, *nfc;
 428
 429   if (n_compose >= GTK_MAX_COMPOSE_LEN)
 430     return FALSE;
 431
 432   for (i = 0; i < n_compose && IS_DEAD_KEY (context_simple->compose_buffer[i]); i++)
 433     ;
 434   if (i == n_compose)
 435     return TRUE;
 436
 437   if (i > 0 && i == n_compose - 1)
 438     {
 439       combination_buffer[0] = gdk_keyval_to_unicode (context_simple->compose_buffer[i]);
 440       combination_buffer[n_compose] = 0;
 441       i--;
 442       while (i >= 0)
 443         {
 444           switch (context_simple->compose_buffer[i])
 445             {
 446 #define CASE(keysym, unicode) \
 447             case GDK_dead_##keysym: combination_buffer[i+1] = unicode; break
 448
 449             CASE (grave, 0x0300);
 450             CASE (acute, 0x0301);
 451             CASE (circumflex, 0x0302);
 452             CASE (tilde, 0x0303);       /* Also used with perispomeni, 0x342. */
 453             CASE (macron, 0x0304);
 454             CASE (breve, 0x0306);
 455             CASE (abovedot, 0x0307);
 456             CASE (diaeresis, 0x0308);
 457             CASE (hook, 0x0309);
 458             CASE (abovering, 0x030A);
 459             CASE (doubleacute, 0x030B);
 460             CASE (caron, 0x030C);
 461             CASE (abovecomma, 0x0313);         /* Equivalent to psili */
 462             CASE (abovereversedcomma, 0x0314); /* Equivalent to dasia */
 463             CASE (horn, 0x031B);        /* Legacy use for psili, 0x313 (or 0x343). */
 464             CASE (belowdot, 0x0323);
 465             CASE (cedilla, 0x0327);
 466             CASE (ogonek, 0x0328);      /* Legacy use for dasia, 0x314.*/
 467             CASE (iota, 0x0345);
 468             CASE (voiced_sound, 0x3099);        /* Per Markus Kuhn keysyms.txt file. */
 469             CASE (semivoiced_sound, 0x309A);    /* Per Markus Kuhn keysyms.txt file. */
 470
 471             /* The following cases are to be removed once xkeyboard-config,
 472              * xorg are fully updated.
 473              */
 474             /* Workaround for typo in 1.4.x xserver-xorg */
 475             case 0xfe66: combination_buffer[i+1] = 0x314; break;
 476             /* CASE (dasia, 0x314); */
 477             /* CASE (perispomeni, 0x342); */
 478             /* CASE (psili, 0x343); */
 479 #undef CASE
 480             default:
 481               combination_buffer[i+1] = gdk_keyval_to_unicode (context_simple->compose_buffer[i]);
 482             }
 483           i--;
 484         }
 485
 486       /* If the buffer normalizes to a single character,
 487        * then modify the order of combination_buffer accordingly, if necessary,
 488        * and return TRUE.
 489        */
 490       if (check_normalize_nfc (combination_buffer, n_compose))
 491         {
 492           gunichar value;
 493           combination_utf8 = g_ucs4_to_utf8 (combination_buffer, -1, NULL, NULL, NULL);
 494           nfc = g_utf8_normalize (combination_utf8, -1, G_NORMALIZE_NFC);
 495
 496           value = g_utf8_get_char (nfc);
 497           gtk_im_context_simple_commit_char (GTK_IM_CONTEXT (context_simple), value);
 498           context_simple->compose_buffer[0] = 0;
 499
 500           g_free (combination_utf8);
 501           g_free (nfc);
 502
 503           return TRUE;
 504         }
 505     }
 506
 507   return FALSE;
 508 }
 509
 510 /* In addition to the table-driven sequences, we allow Unicode hex
 511  * codes to be entered. The method chosen here is similar to the
 512  * one recommended in ISO 14755, but not exactly the same, since we
 513  * don't want to steal 16 valuable key combinations.
 514  *
 515  * A hex Unicode sequence must be started with Ctrl-Shift-U, followed
 516  * by a sequence of hex digits entered with Ctrl-Shift still held.
 517  * Releasing one of the modifiers or pressing space while the modifiers
 518  * are still held commits the character. It is possible to erase
 519  * digits using backspace.
 520  *
 521  * As an extension to the above, we also allow to start the sequence
 522  * with Ctrl-Shift-U, then release the modifiers before typing any
 523  * digits, and enter the digits without modifiers.
 524  */
 525 #define HEX_MOD_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK)
 526
 527 static gboolean
 528 check_hex (GtkIMContextSimple *context_simple,
 529            gint                n_compose)
 530 {
 531   /* See if this is a hex sequence, return TRUE if so */
 532   gint i;
 533   GString *str;
 534   gulong n;
 535   gchar *nptr = NULL;
 536   gchar buf[7];
 537
 538   context_simple->tentative_match = 0;
 539   context_simple->tentative_match_len = 0;
 540
 541   str = g_string_new (NULL);
 542
 543   i = 0;
 544   while (i < n_compose)
 545     {
 546       gunichar ch;
 547
 548       ch = gdk_keyval_to_unicode (context_simple->compose_buffer[i]);
 549
 550       if (ch == 0)
 551         return FALSE;
 552
 553       if (!g_unichar_isxdigit (ch))
 554         return FALSE;
 555
 556       buf[g_unichar_to_utf8 (ch, buf)] = '\0';
 557
 558       g_string_append (str, buf);
 559
 560       ++i;
 561     }
 562
 563   n = strtoul (str->str, &nptr, 16);
 564
 565   /* if strtoul fails it probably means non-latin digits were used;
 566    * we should in principle handle that, but we probably don't.
 567    */
 568   if (nptr - str->str < str->len)
 569     {
 570       g_string_free (str, TRUE);
 571       return FALSE;
 572     }
 573   else
 574     g_string_free (str, TRUE);
 575
 576   if (g_unichar_validate (n))
 577     {
 578       context_simple->tentative_match = n;
 579       context_simple->tentative_match_len = n_compose;
 580     }
 581
 582   return TRUE;
 583 }
 584
 585 static void
 586 beep_window (GdkWindow *window)
 587 {
 588   GtkWidget *widget;
 589
 590   gdk_window_get_user_data (window, (gpointer) &widget);
 591
 592   if (GTK_IS_WIDGET (widget))
 593     {
 594       gtk_widget_error_bell (widget);
 595     }
 596   else
 597     {
 598       GdkScreen *screen = gdk_drawable_get_screen (GDK_DRAWABLE (window));
 599       gboolean   beep;
 600
 601       g_object_get (gtk_settings_get_for_screen (screen),
 602                     "gtk-error-bell", &beep,
 603                     NULL);
 604
 605       if (beep)
 606         gdk_window_beep (window);
 607     }
 608 }
 609
 610 static gboolean
 611 no_sequence_matches (GtkIMContextSimple *context_simple,
 612                      gint                n_compose,
 613                      GdkEventKey        *event)
 614 {
 615   GtkIMContext *context;
 616   gunichar ch;
 617
 618   context = GTK_IM_CONTEXT (context_simple);
 619
 620   /* No compose sequences found, check first if we have a partial
 621    * match pending.
 622    */
 623   if (context_simple->tentative_match)
 624     {
 625       gint len = context_simple->tentative_match_len;
 626       int i;
 627
 628       gtk_im_context_simple_commit_char (context, context_simple->tentative_match);
 629       context_simple->compose_buffer[0] = 0;
 630
 631       for (i=0; i < n_compose - len - 1; i++)
 632         {
 633           GdkEvent *tmp_event = gdk_event_copy ((GdkEvent *)event);
 634           tmp_event->key.keyval = context_simple->compose_buffer[len + i];
 635
 636           gtk_im_context_filter_keypress (context, (GdkEventKey *)tmp_event);
 637           gdk_event_free (tmp_event);
 638         }
 639
 640       return gtk_im_context_filter_keypress (context, event);
 641     }
 642   else
 643     {
 644       context_simple->compose_buffer[0] = 0;
 645       if (n_compose > 1)                /* Invalid sequence */
 646         {
 647           beep_window (event->window);
 648           return TRUE;
 649         }
 650
 651       ch = gdk_keyval_to_unicode (event->keyval);
 652       if (ch != 0)
 653         {
 654           gtk_im_context_simple_commit_char (context, ch);
 655           return TRUE;
 656         }
 657       else
 658         return FALSE;
 659     }
 660 }
 661
 662 static gboolean
 663 is_hex_keyval (guint keyval)
 664 {
 665   gunichar ch = gdk_keyval_to_unicode (keyval);
 666
 667   return g_unichar_isxdigit (ch);
 668 }
 669
 670 static guint
 671 canonical_hex_keyval (GdkEventKey *event)
 672 {
 673   GdkKeymap *keymap = gdk_keymap_get_for_display (gdk_drawable_get_display (event->window));
 674   guint keyval;
 675   guint *keyvals = NULL;
 676   gint n_vals = 0;
 677   gint i;
 678
 679   /* See if the keyval is already a hex digit */
 680   if (is_hex_keyval (event->keyval))
 681     return event->keyval;
 682
 683   /* See if this key would have generated a hex keyval in
 684    * any other state, and return that hex keyval if so
 685    */
 686   gdk_keymap_get_entries_for_keycode (keymap,
 687                                       event->hardware_keycode,
 688                                       NULL,
 689                                       &keyvals, &n_vals);
 690
 691   keyval = 0;
 692   i = 0;
 693   while (i < n_vals)
 694     {
 695       if (is_hex_keyval (keyvals[i]))
 696         {
 697           keyval = keyvals[i];
 698           break;
 699         }
 700
 701       ++i;
 702     }
 703
 704   g_free (keyvals);
 705
 706   if (keyval)
 707     return keyval;
 708   else
 709     /* No way to make it a hex digit
 710      */
 711     return 0;
 712 }
 713
 714 static gboolean
 715 gtk_im_context_simple_filter_keypress (GtkIMContext *context,
 716                                        GdkEventKey  *event)
 717 {
 718   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
 719   GSList *tmp_list;
 720   int n_compose = 0;
 721   gboolean have_hex_mods;
 722   gboolean is_hex_start;
 723   gboolean is_hex_end;
 724   gboolean is_backspace;
 725   gboolean is_escape;
 726   guint hex_keyval;
 727   int i;
 728
 729   while (context_simple->compose_buffer[n_compose] != 0)
 730     n_compose++;
 731
 732   if (event->type == GDK_KEY_RELEASE)
 733     {
 734       if (context_simple->in_hex_sequence &&
 735           (event->keyval == GDK_Control_L || event->keyval == GDK_Control_R ||
 736            event->keyval == GDK_Shift_L || event->keyval == GDK_Shift_R))
 737         {
 738           if (context_simple->tentative_match &&
 739               g_unichar_validate (context_simple->tentative_match))
 740             {
 741               gtk_im_context_simple_commit_char (context, context_simple->tentative_match);
 742               context_simple->compose_buffer[0] = 0;
 743
 744             }
 745           else if (n_compose == 0)
 746             {
 747               context_simple->modifiers_dropped = TRUE;
 748             }
 749           else
 750             {
 751               /* invalid hex sequence */
 752               beep_window (event->window);
 753
 754               context_simple->tentative_match = 0;
 755               context_simple->in_hex_sequence = FALSE;
 756               context_simple->compose_buffer[0] = 0;
 757
 758               g_signal_emit_by_name (context_simple, "preedit-changed");
 759               g_signal_emit_by_name (context_simple, "preedit-end");
 760             }
 761
 762           return TRUE;
 763         }
 764       else
 765         return FALSE;
 766     }
 767
 768   /* Ignore modifier key presses */
 769   for (i = 0; i < G_N_ELEMENTS (gtk_compose_ignore); i++)
 770     if (event->keyval == gtk_compose_ignore[i])
 771       return FALSE;
 772
 773   if (context_simple->in_hex_sequence && context_simple->modifiers_dropped)
 774     have_hex_mods = TRUE;
 775   else
 776     have_hex_mods = (event->state & (HEX_MOD_MASK)) == HEX_MOD_MASK;
 777   is_hex_start = event->keyval == GDK_U;
 778   is_hex_end = (event->keyval == GDK_space ||
 779                 event->keyval == GDK_KP_Space ||
 780                 event->keyval == GDK_Return ||
 781                 event->keyval == GDK_ISO_Enter ||
 782                 event->keyval == GDK_KP_Enter);
 783   is_backspace = event->keyval == GDK_BackSpace;
 784   is_escape = event->keyval == GDK_Escape;
 785   hex_keyval = canonical_hex_keyval (event);
 786
 787   /* If we are already in a non-hex sequence, or
 788    * this keystroke is not hex modifiers + hex digit, don't filter
 789    * key events with accelerator modifiers held down.
 790    */
 791   if (!have_hex_mods ||
 792       (n_compose > 0 && !context_simple->in_hex_sequence) ||
 793       (n_compose == 0 && !context_simple->in_hex_sequence && !is_hex_start) ||
 794       (context_simple->in_hex_sequence && !hex_keyval &&
 795        !is_hex_start && !is_hex_end && !is_escape && !is_backspace))
 796     {
 797       if (event->state & (gtk_accelerator_get_default_mod_mask () & ~GDK_SHIFT_MASK) ||
 798           (context_simple->in_hex_sequence && context_simple->modifiers_dropped &&
 799            (event->keyval == GDK_Return ||
 800             event->keyval == GDK_ISO_Enter ||
 801             event->keyval == GDK_KP_Enter)))
 802         {
 803           return FALSE;
 804         }
 805     }
 806
 807   /* Handle backspace */
 808   if (context_simple->in_hex_sequence && have_hex_mods && is_backspace)
 809     {
 810       if (n_compose > 0)
 811         {
 812           n_compose--;
 813           context_simple->compose_buffer[n_compose] = 0;
 814           check_hex (context_simple, n_compose);
 815         }
 816       else
 817         {
 818           context_simple->in_hex_sequence = FALSE;
 819         }
 820
 821       g_signal_emit_by_name (context_simple, "preedit-changed");
 822
 823       if (!context_simple->in_hex_sequence)
 824         g_signal_emit_by_name (context_simple, "preedit-end");
 825
 826       return TRUE;
 827     }
 828
 829   /* Check for hex sequence restart */
 830   if (context_simple->in_hex_sequence && have_hex_mods && is_hex_start)
 831     {
 832       if (context_simple->tentative_match &&
 833           g_unichar_validate (context_simple->tentative_match))
 834         {
 835           gtk_im_context_simple_commit_char (context, context_simple->tentative_match);
 836           context_simple->compose_buffer[0] = 0;
 837         }
 838       else
 839         {
 840           /* invalid hex sequence */
 841           if (n_compose > 0)
 842             beep_window (event->window);
 843
 844           context_simple->tentative_match = 0;
 845           context_simple->in_hex_sequence = FALSE;
 846           context_simple->compose_buffer[0] = 0;
 847         }
 848     }
 849
 850   /* Check for hex sequence start */
 851   if (!context_simple->in_hex_sequence && have_hex_mods && is_hex_start)
 852     {
 853       context_simple->compose_buffer[0] = 0;
 854       context_simple->in_hex_sequence = TRUE;
 855       context_simple->modifiers_dropped = FALSE;
 856       context_simple->tentative_match = 0;
 857
 858       g_signal_emit_by_name (context_simple, "preedit-start");
 859       g_signal_emit_by_name (context_simple, "preedit-changed");
 860
 861       return TRUE;
 862     }
 863
 864   /* Then, check for compose sequences */
 865   if (context_simple->in_hex_sequence)
 866     {
 867       if (hex_keyval)
 868         context_simple->compose_buffer[n_compose++] = hex_keyval;
 869       else if (is_escape)
 870         {
 871           gtk_im_context_simple_reset (context);
 872
 873           return TRUE;
 874         }
 875       else if (!is_hex_end)
 876         {
 877           /* non-hex character in hex sequence */
 878           beep_window (event->window);
 879
 880           return TRUE;
 881         }
 882     }
 883   else
 884     context_simple->compose_buffer[n_compose++] = event->keyval;
 885
 886   context_simple->compose_buffer[n_compose] = 0;
 887
 888   if (context_simple->in_hex_sequence)
 889     {
 890       /* If the modifiers are still held down, consider the sequence again */
 891       if (have_hex_mods)
 892         {
 893           /* space or return ends the sequence, and we eat the key */
 894           if (n_compose > 0 && is_hex_end)
 895             {
 896               if (context_simple->tentative_match &&
 897                   g_unichar_validate (context_simple->tentative_match))
 898                 {
 899                   gtk_im_context_simple_commit_char (context, context_simple->tentative_match);
 900                   context_simple->compose_buffer[0] = 0;
 901                 }
 902               else
 903                 {
 904                   /* invalid hex sequence */
 905                   beep_window (event->window);
 906
 907                   context_simple->tentative_match = 0;
 908                   context_simple->in_hex_sequence = FALSE;
 909                   context_simple->compose_buffer[0] = 0;
 910                 }
 911             }
 912           else if (!check_hex (context_simple, n_compose))
 913             beep_window (event->window);
 914
 915           g_signal_emit_by_name (context_simple, "preedit-changed");
 916
 917           if (!context_simple->in_hex_sequence)
 918             g_signal_emit_by_name (context_simple, "preedit-end");
 919
 920           return TRUE;
 921         }
 922     }
 923   else
 924     {
 925       tmp_list = context_simple->tables;
 926       while (tmp_list)
 927         {
 928           if (check_table (context_simple, tmp_list->data, n_compose))
 929             return TRUE;
 930           tmp_list = tmp_list->next;
 931         }
 932
 933       if (check_compact_table (context_simple, &gtk_compose_table_compact, n_compose))
 934         return TRUE;
 935
 936       if (check_algorithmically (context_simple, n_compose))
 937         return TRUE;
 938     }
 939
 940   /* The current compose_buffer doesn't match anything */
 941   return no_sequence_matches (context_simple, n_compose, event);
 942 }
 943
 944 static void
 945 gtk_im_context_simple_reset (GtkIMContext *context)
 946 {
 947   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
 948
 949   context_simple->compose_buffer[0] = 0;
 950
 951   if (context_simple->tentative_match || context_simple->in_hex_sequence)
 952     {
 953       context_simple->in_hex_sequence = FALSE;
 954       context_simple->tentative_match = 0;
 955       context_simple->tentative_match_len = 0;
 956       g_signal_emit_by_name (context_simple, "preedit-changed");
 957       g_signal_emit_by_name (context_simple, "preedit-end");
 958     }
 959 }
 960
 961 static void
 962 gtk_im_context_simple_get_preedit_string (GtkIMContext   *context,
 963                                           gchar         **str,
 964                                           PangoAttrList **attrs,
 965                                           gint           *cursor_pos)
 966 {
 967   char outbuf[37]; /* up to 6 hex digits */
 968   int len = 0;
 969
 970   GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
 971
 972   if (context_simple->in_hex_sequence)
 973     {
 974       int hexchars = 0;
 975
 976       outbuf[0] = 'u';
 977       len = 1;
 978
 979       while (context_simple->compose_buffer[hexchars] != 0)
 980         {
 981           len += g_unichar_to_utf8 (gdk_keyval_to_unicode (context_simple->compose_buffer[hexchars]),
 982                                     outbuf + len);
 983           ++hexchars;
 984         }
 985
 986       g_assert (len < 25);
 987     }
 988   else if (context_simple->tentative_match)
 989     len = g_unichar_to_utf8 (context_simple->tentative_match, outbuf);
 990
 991   outbuf[len] = '\0';
 992
 993   if (str)
 994     *str = g_strdup (outbuf);
 995
 996   if (attrs)
 997     {
 998       *attrs = pango_attr_list_new ();
 999
1000       if (len)
1001         {
1002           PangoAttribute *attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
1003           attr->start_index = 0;
1004           attr->end_index = len;
1005           pango_attr_list_insert (*attrs, attr);
1006         }
1007     }
1008
1009   if (cursor_pos)
1010     *cursor_pos = len;
1011 }
1012
1013 /**
1014  * gtk_im_context_simple_add_table:
1015  * @context_simple: A #GtkIMContextSimple
1016  * @data: the table
1017  * @max_seq_len: Maximum length of a sequence in the table
1018  *               (cannot be greater than #GTK_MAX_COMPOSE_LEN)
1019  * @n_seqs: number of sequences in the table
1020  *
1021  * Adds an additional table to search to the input context.
1022  * Each row of the table consists of @max_seq_len key symbols
1023  * followed by two #guint16 interpreted as the high and low
1024  * words of a #gunicode value. Tables are searched starting
1025  * from the last added.
1026  *
1027  * The table must be sorted in dictionary order on the
1028  * numeric value of the key symbol fields. (Values beyond
1029  * the length of the sequence should be zero.)
1030  **/
1031 void
1032 gtk_im_context_simple_add_table (GtkIMContextSimple *context_simple,
1033                                  guint16            *data,
1034                                  gint                max_seq_len,
1035                                  gint                n_seqs)
1036 {
1037   GtkComposeTable *table;
1038
1039   g_return_if_fail (GTK_IS_IM_CONTEXT_SIMPLE (context_simple));
1040   g_return_if_fail (data != NULL);
1041   g_return_if_fail (max_seq_len <= GTK_MAX_COMPOSE_LEN);
1042
1043   table = g_new (GtkComposeTable, 1);
1044   table->data = data;
1045   table->max_seq_len = max_seq_len;
1046   table->n_seqs = n_seqs;
1047
1048   context_simple->tables = g_slist_prepend (context_simple->tables, table);
1049 }
1050
1051 #define __GTK_IM_CONTEXT_SIMPLE_C__
1052 #include "gtkaliasdef.c"