← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pspp/karmic-proposed

« back to all changes in this revision

Viewing changes to lib/gtksheet/gtkitementry.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Starr-Bochicchio
  • Date: 2009-11-05 22:46:52 UTC
  • Revision ID: james.westby@ubuntu.com-20091105224652-d7gr6v3ut7gejksw
Tags: 0.6.1-4ubuntu0.1
https://launchpad.net/bugs/423495
* /lib/gtksheet/gtkitementry.c: Backport patch from upstream 0.6.2
  release. Makes GtkItemEntry compatible with GTK+ 2.17.4 and later. 
  (LP: #423495)
 - Upstream commit: http://git.savannah.gnu.org/cgit/pspp.git/commit/?h=stable&id=f5d9f9911bd04682a7edfb48521a12202e561e0a

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gtksheet/gtkitementry.c
34
34
#include <gtk/gtk.h>
35
35
#include "gtkitementry.h"
36
36
 
 
37
#if GTK_CHECK_VERSION (2,17,4)
 
38
#define HAVE_GTKENTRYBUFFER 1
 
39
#endif
 
40
 
 
41
#if !GTK_CHECK_VERSION (2,14,0)
 
42
static guint16
 
43
gtk_entry_get_text_length (GtkEntry *entry)
 
44
{
 
45
  return entry->text_length;
 
46
}
 
47
#endif
 
48
 
37
49
#define MIN_ENTRY_WIDTH  150
38
50
#define DRAW_TIMEOUT     20
39
51
#define INNER_BORDER     0
586
598
                       gint         new_text_length,
587
599
                       gint        *position)
588
600
{
 
601
#if HAVE_GTKENTRYBUFFER
 
602
  g_object_ref (editable);
 
603
 
 
604
  /*
 
605
   * The incoming text may a password or other secret. We make sure
 
606
   * not to copy it into temporary buffers.
 
607
   */
 
608
 
 
609
  g_signal_emit_by_name (editable, "insert-text", new_text, new_text_length, position);
 
610
 
 
611
  g_object_unref (editable);
 
612
#else  /* !HAVE_GTKENTRYBUFFER */
589
613
  GtkEntry *entry = GTK_ENTRY (editable);
590
614
  gchar buf[64];
591
615
  gchar *text;
609
633
    g_free (text);
610
634
 
611
635
  g_object_unref (G_OBJECT (editable));
 
636
#endif  /* !HAVE_GTKENTRYBUFFER */
612
637
}
613
638
 
614
639
static void
616
641
                       gint         start_pos,
617
642
                       gint         end_pos)
618
643
{
 
644
#if HAVE_GTKENTRYBUFFER
 
645
  g_object_ref (editable);
 
646
 
 
647
  g_signal_emit_by_name (editable, "delete-text", start_pos, end_pos);
 
648
 
 
649
  g_object_unref (editable);
 
650
#else  /* !HAVE_GTKENTRYBUFFER */
619
651
  GtkEntry *entry = GTK_ENTRY (editable);
620
652
 
621
653
  if (end_pos < 0 || end_pos > entry->text_length)
630
662
  g_signal_emit_by_name (editable, "delete_text", start_pos, end_pos);
631
663
 
632
664
  g_object_unref (G_OBJECT (editable));
 
665
#endif  /* !HAVE_GTKENTRYBUFFER */
633
666
}
634
667
 
635
668
static void
652
685
                             gint         position)
653
686
{
654
687
  GtkEntry *entry = GTK_ENTRY (editable);
 
688
  guint length;
655
689
 
656
 
  if (position < 0 || position > entry->text_length)
657
 
    position = entry->text_length;
 
690
  length = gtk_entry_get_text_length (entry);
 
691
  if (position < 0 || position > length)
 
692
    position = length;
658
693
 
659
694
  if (position != entry->current_pos ||
660
695
      position != entry->selection_bound)
679
714
                            gint         new_text_length,
680
715
                            gint        *position)
681
716
{
 
717
#if HAVE_GTKENTRYBUFFER
 
718
  GtkEntry *entry = GTK_ENTRY (editable);
 
719
  GtkEntryBuffer *buffer = gtk_entry_get_buffer (entry);
 
720
 
 
721
  guint n_inserted;
 
722
  gint n_chars;
 
723
 
 
724
  n_chars = g_utf8_strlen (new_text, new_text_length);
 
725
 
 
726
  /*
 
727
   * The actual insertion into the buffer. This will end up firing the
 
728
   * following signal handlers: buffer_inserted_text(), buffer_notify_display_text(),
 
729
   * buffer_notify_text(), buffer_notify_length()
 
730
   */
 
731
  n_inserted = gtk_entry_buffer_insert_text (buffer, *position, new_text, n_chars);
 
732
 
 
733
  if (n_inserted != n_chars)
 
734
      gtk_widget_error_bell (GTK_WIDGET (editable));
 
735
 
 
736
  *position += n_inserted;
 
737
#else  /* !HAVE_GTKENTRYBUFFER */
682
738
  gint index;
683
739
  gint n_chars;
684
740
 
746
802
 
747
803
  g_signal_emit_by_name (editable, "changed");
748
804
  g_object_notify (G_OBJECT (editable), "text");
 
805
#endif  /* !HAVE_GTKENTRYBUFFER */
749
806
}
750
807
 
751
808
static void
753
810
                            gint         start_pos,
754
811
                            gint         end_pos)
755
812
{
 
813
#ifdef HAVE_GTKENTRYBUFFER
 
814
  GtkEntry *entry = GTK_ENTRY (editable);
 
815
  GtkEntryBuffer *buffer = gtk_entry_get_buffer (entry);
 
816
  /*
 
817
   * The actual deletion from the buffer. This will end up firing the
 
818
   * following signal handlers: buffer_deleted_text(), buffer_notify_display_text(),
 
819
   * buffer_notify_text(), buffer_notify_length()
 
820
   */
 
821
 
 
822
  gtk_entry_buffer_delete_text (buffer, start_pos, end_pos - start_pos);
 
823
#else  /* !HAVE_GTKENTRYBUFFER */
756
824
  GtkEntry *entry = GTK_ENTRY (editable);
757
825
 
758
826
  if (start_pos < 0)
783
851
      g_signal_emit_by_name (editable, "changed");
784
852
      g_object_notify (G_OBJECT (editable), "text");
785
853
    }
 
854
#endif  /* !HAVE_GTKENTRYBUFFER */
786
855
}
787
856
 
788
857
/* Compute the X position for an offset that corresponds to the "more important
801
870
  gboolean split_cursor;
802
871
 
803
872
  PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
804
 
  gint index = g_utf8_offset_to_pointer (entry->text, offset) - entry->text;
 
873
  const char *text = gtk_entry_get_text (entry);
 
874
  gint index = g_utf8_offset_to_pointer (text, offset) - text;
805
875
 
806
876
  PangoRectangle strong_pos, weak_pos;
807
877
 
856
926
        case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
857
927
        case GTK_MOVEMENT_PARAGRAPH_ENDS:
858
928
        case GTK_MOVEMENT_BUFFER_ENDS:
859
 
          new_pos = count < 0 ? 0 : entry->text_length;
 
929
          new_pos = count < 0 ? 0 : gtk_entry_get_text_length (entry);
860
930
          break;
861
931
        case GTK_MOVEMENT_DISPLAY_LINES:
862
932
        case GTK_MOVEMENT_PARAGRAPHS:
891
961
        case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
892
962
        case GTK_MOVEMENT_PARAGRAPH_ENDS:
893
963
        case GTK_MOVEMENT_BUFFER_ENDS:
894
 
          new_pos = count < 0 ? 0 : entry->text_length;
 
964
          new_pos = count < 0 ? 0 : gtk_entry_get_text_length (entry);
895
965
          break;
896
966
        case GTK_MOVEMENT_DISPLAY_LINES:
897
967
        case GTK_MOVEMENT_PARAGRAPHS:
1032
1102
gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,
1033
1103
                               GtkEntry     *entry)
1034
1104
{
 
1105
  const char *text = gtk_entry_get_text (entry);
 
1106
  size_t n_bytes = strlen (text);
 
1107
 
1035
1108
  gtk_im_context_set_surrounding (context,
1036
 
                                  entry->text,
1037
 
                                  entry->n_bytes,
1038
 
                                  g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text);
 
1109
                                  text,
 
1110
                                  n_bytes,
 
1111
                                  g_utf8_offset_to_pointer (text, entry->current_pos) - text);
1039
1112
 
1040
1113
  return TRUE;
1041
1114
}
1218
1291
  gint preedit_length = 0;
1219
1292
  PangoAttrList *preedit_attrs = NULL;
1220
1293
 
 
1294
  const char *text = gtk_entry_get_text (entry);
 
1295
  size_t n_bytes = strlen (text);
 
1296
 
1221
1297
  pango_layout_set_single_paragraph_mode (layout, TRUE);
1222
1298
 
1223
1299
  if (include_preedit)
1231
1307
    {
1232
1308
      GString *tmp_string = g_string_new (NULL);
1233
1309
 
1234
 
      gint cursor_index = g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text;
 
1310
      gint cursor_index = g_utf8_offset_to_pointer (text, entry->current_pos) - text;
1235
1311
 
1236
1312
      if (entry->visible)
1237
1313
        {
1238
 
          g_string_prepend_len (tmp_string, entry->text, entry->n_bytes);
 
1314
          g_string_prepend_len (tmp_string, text, n_bytes);
1239
1315
          g_string_insert (tmp_string, cursor_index, preedit_string);
1240
1316
        }
1241
1317
      else
1244
1320
          gint preedit_len_chars;
1245
1321
          gunichar invisible_char;
1246
1322
 
1247
 
          ch_len = g_utf8_strlen (entry->text, entry->n_bytes);
 
1323
          ch_len = g_utf8_strlen (text, n_bytes);
1248
1324
          preedit_len_chars = g_utf8_strlen (preedit_string, -1);
1249
1325
          ch_len += preedit_len_chars;
1250
1326
 
1278
1354
    {
1279
1355
      if (entry->visible)
1280
1356
        {
1281
 
          pango_layout_set_text (layout, entry->text, entry->n_bytes);
 
1357
          pango_layout_set_text (layout, text, n_bytes);
1282
1358
        }
1283
1359
      else
1284
1360
        {
1290
1366
          else
1291
1367
            invisible_char = ' '; /* just pick a char */
1292
1368
 
1293
 
          append_char (str, invisible_char, entry->text_length);
 
1369
          append_char (str, invisible_char, gtk_entry_get_text_length (entry));
1294
1370
          pango_layout_set_text (layout, str->str, str->len);
1295
1371
          g_string_free (str, TRUE);
1296
1372
        }
1728
1804
    }
1729
1805
  else /* type == CURSOR_DND */
1730
1806
    {
1731
 
      index = g_utf8_offset_to_pointer (entry->text, entry->dnd_position) - entry->text;
 
1807
      const char *text = gtk_entry_get_text (entry);
 
1808
      index = g_utf8_offset_to_pointer (text, entry->dnd_position) - text;
1732
1809
      if (entry->dnd_position > entry->current_pos)
1733
1810
        index += entry->preedit_length;
1734
1811
    }
1803
1880
        case GTK_JUSTIFY_RIGHT:
1804
1881
 
1805
1882
    /* RIGHT JUSTIFICATION FOR NUMBERS */
1806
 
          if(entry->text){
 
1883
          if(gtk_entry_get_text (entry)){
1807
1884
 
1808
1885
            entry->scroll_offset=  -(text_area_width - text_width) + 1;
1809
1886
            if(entry->scroll_offset > 0){
1829
1906
          break;
1830
1907
        case GTK_JUSTIFY_CENTER:
1831
1908
 
1832
 
          if(entry->text){
 
1909
          if(gtk_entry_get_text (entry)){
1833
1910
 
1834
1911
            entry->scroll_offset=  -(text_area_width - text_width)/2;
1835
1912
            if(entry->scroll_offset > 0){
1882
1959
 
1883
1960
  while (count != 0)
1884
1961
    {
 
1962
      const char *text = gtk_entry_get_text (entry);
1885
1963
      int new_index, new_trailing;
1886
1964
      gboolean split_cursor;
1887
1965
      gboolean strong;
1918
1996
      index = new_index;
1919
1997
 
1920
1998
      while (new_trailing--)
1921
 
        index = g_utf8_next_char (entry->text + new_index) - entry->text;
 
1999
        index = g_utf8_next_char (text + new_index) - text;
1922
2000
    }
1923
2001
 
1924
2002
  return g_utf8_pointer_to_offset (text, text + index);
1929
2007
                          gint      start,
1930
2008
                          gint      count)
1931
2009
{
 
2010
  const char *text = gtk_entry_get_text (entry);
 
2011
  guint16 text_length = gtk_entry_get_text_length (entry);
1932
2012
  gint new_pos = start;
1933
2013
 
1934
2014
  /* Prevent any leak of information */
1935
2015
  if (!entry->visible)
1936
2016
    {
1937
 
      new_pos = CLAMP (start + count, 0, entry->text_length);
 
2017
      new_pos = CLAMP (start + count, 0, text_length);
1938
2018
    }
1939
 
  else if (entry->text)
 
2019
  else if (text)
1940
2020
    {
1941
2021
      PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
1942
2022
      PangoLogAttr *log_attrs;
1944
2024
 
1945
2025
      pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
1946
2026
 
1947
 
      while (count > 0 && new_pos < entry->text_length)
 
2027
      while (count > 0 && new_pos < text_length)
1948
2028
        {
1949
2029
          do
1950
2030
            new_pos++;
1951
 
          while (new_pos < entry->text_length && !log_attrs[new_pos].is_cursor_position);
 
2031
          while (new_pos < text_length && !log_attrs[new_pos].is_cursor_position);
1952
2032
 
1953
2033
          count--;
1954
2034
        }
1971
2051
gtk_entry_move_forward_word (GtkEntry *entry,
1972
2052
                             gint      start)
1973
2053
{
 
2054
  const char *text = gtk_entry_get_text (entry);
 
2055
  guint16 text_length = gtk_entry_get_text_length (entry);
1974
2056
  gint new_pos = start;
1975
2057
 
1976
2058
  /* Prevent any leak of information */
1977
2059
  if (!entry->visible)
1978
2060
    {
1979
 
      new_pos = entry->text_length;
 
2061
      new_pos = text_length;
1980
2062
    }
1981
 
  else if (entry->text && (new_pos < entry->text_length))
 
2063
  else if (text && (new_pos < text_length))
1982
2064
    {
1983
2065
      PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
1984
2066
      PangoLogAttr *log_attrs;
2009
2091
    {
2010
2092
      new_pos = 0;
2011
2093
    }
2012
 
  else if (entry->text && start > 0)
 
2094
  else if (gtk_entry_get_text (entry) && start > 0)
2013
2095
    {
2014
2096
      PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
2015
2097
      PangoLogAttr *log_attrs;
2064
2146
                            gint      end)
2065
2147
{
2066
2148
  if (end < 0)
2067
 
    end = entry->text_length;
 
2149
    end = gtk_entry_get_text_length (entry);
2068
2150
 
2069
2151
  if (entry->visible)
2070
2152
    return gtk_editable_get_chars (GTK_EDITABLE (entry), start, end);
2174
2256
  /* Actually setting the text will affect the cursor and selection;
2175
2257
   * if the contents don't actually change, this will look odd to the user.
2176
2258
   */
2177
 
  if (strcmp (GTK_ENTRY(entry)->text, text) == 0)
 
2259
  if (strcmp (gtk_entry_get_text (GTK_ENTRY(entry)), text) == 0)
2178
2260
    return;
2179
2261
 
2180
2262
  if (GTK_ENTRY(entry)->recompute_idle){