Pileus Git - ~andy/gtk/blob - gtk/gtktextutil.c

   1 /* GTK - The GTK+ Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   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 /*
  21  * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gtktextview.h"
  30 #include "gtktextutil.h"
  31
  32 #define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
  33
  34 #include "gtktextdisplay.h"
  35 #include "gtktextbuffer.h"
  36 #include "gtkmenuitem.h"
  37 #include "gtkintl.h"
  38 #include "gtkalias.h"
  39
  40 #define DRAG_ICON_MAX_WIDTH 250
  41 #define DRAG_ICON_MAX_HEIGHT 250
  42 #define DRAG_ICON_LAYOUT_BORDER 5
  43 #define DRAG_ICON_MAX_LINES 7
  44 #define ELLIPSIS_CHARACTER "\xe2\x80\xa6"
  45
  46 typedef struct _GtkUnicodeMenuEntry GtkUnicodeMenuEntry;
  47 typedef struct _GtkTextUtilCallbackInfo GtkTextUtilCallbackInfo;
  48
  49 struct _GtkUnicodeMenuEntry {
  50   const char *label;
  51   gunichar ch;
  52 };
  53
  54 struct _GtkTextUtilCallbackInfo
  55 {
  56   GtkTextUtilCharChosenFunc func;
  57   gpointer data;
  58 };
  59
  60 static const GtkUnicodeMenuEntry bidi_menu_entries[] = {
  61   { N_("LRM _Left-to-right mark"), 0x200E },
  62   { N_("RLM _Right-to-left mark"), 0x200F },
  63   { N_("LRE Left-to-right _embedding"), 0x202A },
  64   { N_("RLE Right-to-left e_mbedding"), 0x202B },
  65   { N_("LRO Left-to-right _override"), 0x202D },
  66   { N_("RLO Right-to-left o_verride"), 0x202E },
  67   { N_("PDF _Pop directional formatting"), 0x202C },
  68   { N_("ZWS _Zero width space"), 0x200B },
  69   { N_("ZWJ Zero width _joiner"), 0x200D },
  70   { N_("ZWNJ Zero width _non-joiner"), 0x200C }
  71 };
  72
  73 static GtkTextUtilCallbackInfo *
  74 callback_info_new (GtkTextUtilCharChosenFunc  func,
  75                    gpointer                   data)
  76 {
  77   GtkTextUtilCallbackInfo *info;
  78
  79   info = g_slice_new (GtkTextUtilCallbackInfo);
  80
  81   info->func = func;
  82   info->data = data;
  83
  84   return info;
  85 }
  86
  87 static void
  88 callback_info_free (GtkTextUtilCallbackInfo *info)
  89 {
  90   g_slice_free (GtkTextUtilCallbackInfo, info);
  91 }
  92
  93 static void
  94 activate_cb (GtkWidget *menu_item,
  95              gpointer   data)
  96 {
  97   GtkUnicodeMenuEntry *entry;
  98   GtkTextUtilCallbackInfo *info = data;
  99   char buf[7];
 100
 101   entry = g_object_get_data (G_OBJECT (menu_item), "gtk-unicode-menu-entry");
 102
 103   buf[g_unichar_to_utf8 (entry->ch, buf)] = '\0';
 104
 105   (* info->func) (buf, info->data);
 106 }
 107
 108 /**
 109  * _gtk_text_util_append_special_char_menuitems
 110  * @menushell: a #GtkMenuShell
 111  * @callback:  call this when an item is chosen
 112  * @data: data for callback
 113  *
 114  * Add menuitems for various bidi control characters  to a menu;
 115  * the menuitems, when selected, will call the given function
 116  * with the chosen character.
 117  *
 118  * This function is private/internal in GTK 2.0, the functionality may
 119  * become public sometime, but it probably needs more thought first.
 120  * e.g. maybe there should be a way to just get the list of items,
 121  * instead of requiring the menu items to be created.
 122  **/
 123 void
 124 _gtk_text_util_append_special_char_menuitems (GtkMenuShell              *menushell,
 125                                               GtkTextUtilCharChosenFunc  func,
 126                                               gpointer                   data)
 127 {
 128   int i;
 129
 130   for (i = 0; i < G_N_ELEMENTS (bidi_menu_entries); i++)
 131     {
 132       GtkWidget *menuitem;
 133       GtkTextUtilCallbackInfo *info;
 134
 135       info = callback_info_new (func, data);
 136
 137       menuitem = gtk_menu_item_new_with_mnemonic (_(bidi_menu_entries[i].label));
 138       g_object_set_data (G_OBJECT (menuitem), I_("gtk-unicode-menu-entry"),
 139                          (gpointer)&bidi_menu_entries[i]);
 140
 141       g_signal_connect_data (menuitem, "activate",
 142                              G_CALLBACK (activate_cb),
 143                              info, (GClosureNotify) callback_info_free, 0);
 144
 145       gtk_widget_show (menuitem);
 146       gtk_menu_shell_append (menushell, menuitem);
 147     }
 148 }
 149
 150 static void
 151 append_n_lines (GString *str, const gchar *text, GSList *lines, gint n_lines)
 152 {
 153   PangoLayoutLine *line;
 154   gint i;
 155
 156   for (i = 0; i < n_lines; i++)
 157     {
 158       line = lines->data;
 159       g_string_append_len (str, &text[line->start_index], line->length);
 160       lines = lines->next;
 161     }
 162 }
 163
 164 static void
 165 limit_layout_lines (PangoLayout *layout)
 166 {
 167   const gchar *text;
 168   GString     *str;
 169   GSList      *lines, *elem;
 170   gint         n_lines;
 171
 172   n_lines = pango_layout_get_line_count (layout);
 173
 174   if (n_lines >= DRAG_ICON_MAX_LINES)
 175     {
 176       text  = pango_layout_get_text (layout);
 177       str   = g_string_new (NULL);
 178       lines = pango_layout_get_lines_readonly (layout);
 179
 180       /* get first lines */
 181       elem = lines;
 182       append_n_lines (str, text, elem,
 183                       DRAG_ICON_MAX_LINES / 2);
 184
 185       g_string_append (str, "\n" ELLIPSIS_CHARACTER "\n");
 186
 187       /* get last lines */
 188       elem = g_slist_nth (lines, n_lines - DRAG_ICON_MAX_LINES / 2);
 189       append_n_lines (str, text, elem,
 190                       DRAG_ICON_MAX_LINES / 2);
 191
 192       pango_layout_set_text (layout, str->str, -1);
 193       g_string_free (str, TRUE);
 194     }
 195 }
 196
 197 /**
 198  * _gtk_text_util_create_drag_icon
 199  * @widget: #GtkWidget to extract the pango context
 200  * @text: a #gchar to render the icon
 201  * @len: length of @text, or -1 for NUL-terminated text
 202  *
 203  * Creates a drag and drop icon from @text.
 204  **/
 205 GdkPixmap *
 206 _gtk_text_util_create_drag_icon (GtkWidget *widget,
 207                                  gchar     *text,
 208                                  gsize      len)
 209 {
 210   GdkDrawable  *drawable = NULL;
 211   PangoContext *context;
 212   PangoLayout  *layout;
 213   gint          pixmap_height, pixmap_width;
 214   gint          layout_width, layout_height;
 215
 216   g_return_val_if_fail (widget != NULL, NULL);
 217   g_return_val_if_fail (text != NULL, NULL);
 218
 219   context = gtk_widget_get_pango_context (widget);
 220   layout  = pango_layout_new (context);
 221
 222   pango_layout_set_text (layout, text, len);
 223   pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
 224   pango_layout_get_size (layout, &layout_width, &layout_height);
 225
 226   layout_width = MIN (layout_width, DRAG_ICON_MAX_WIDTH * PANGO_SCALE);
 227   pango_layout_set_width (layout, layout_width);
 228
 229   limit_layout_lines (layout);
 230
 231   /* get again layout extents, they may have changed */
 232   pango_layout_get_size (layout, &layout_width, &layout_height);
 233
 234   pixmap_width  = layout_width  / PANGO_SCALE + DRAG_ICON_LAYOUT_BORDER * 2;
 235   pixmap_height = layout_height / PANGO_SCALE + DRAG_ICON_LAYOUT_BORDER * 2;
 236
 237   drawable = gdk_pixmap_new (widget->window,
 238                              pixmap_width  + 2,
 239                              pixmap_height + 2,
 240                              -1);
 241
 242   gdk_draw_rectangle (drawable,
 243                       widget->style->base_gc [GTK_WIDGET_STATE (widget)],
 244                       TRUE,
 245                       0, 0,
 246                       pixmap_width + 1,
 247                       pixmap_height + 1);
 248
 249   gdk_draw_layout (drawable,
 250                    widget->style->text_gc [GTK_WIDGET_STATE (widget)],
 251                    1 + DRAG_ICON_LAYOUT_BORDER,
 252                    1 + DRAG_ICON_LAYOUT_BORDER,
 253                    layout);
 254
 255   gdk_draw_rectangle (drawable,
 256                       widget->style->black_gc,
 257                       FALSE,
 258                       0, 0,
 259                       pixmap_width + 1,
 260                       pixmap_height + 1);
 261
 262   g_object_unref (layout);
 263
 264   return drawable;
 265 }
 266
 267 static void
 268 gtk_text_view_set_attributes_from_style (GtkTextView        *text_view,
 269                                          GtkTextAttributes  *values,
 270                                          GtkStyle           *style)
 271 {
 272   values->appearance.bg_color = style->base[GTK_STATE_NORMAL];
 273   values->appearance.fg_color = style->text[GTK_STATE_NORMAL];
 274
 275   if (values->font)
 276     pango_font_description_free (values->font);
 277
 278   values->font = pango_font_description_copy (style->font_desc);
 279 }
 280
 281 GdkPixmap *
 282 _gtk_text_util_create_rich_drag_icon (GtkWidget     *widget,
 283                                       GtkTextBuffer *buffer,
 284                                       GtkTextIter   *start,
 285                                       GtkTextIter   *end)
 286 {
 287   GdkDrawable       *drawable = NULL;
 288   gint               pixmap_height, pixmap_width;
 289   gint               layout_width, layout_height;
 290   GtkTextBuffer     *new_buffer;
 291   GtkTextLayout     *layout;
 292   GtkTextAttributes *style;
 293   PangoContext      *ltr_context, *rtl_context;
 294   GtkTextIter        iter;
 295
 296    g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
 297    g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
 298    g_return_val_if_fail (start != NULL, NULL);
 299    g_return_val_if_fail (end != NULL, NULL);
 300
 301    new_buffer = gtk_text_buffer_new (gtk_text_buffer_get_tag_table (buffer));
 302    gtk_text_buffer_get_start_iter (new_buffer, &iter);
 303
 304    gtk_text_buffer_insert_range (new_buffer, &iter, start, end);
 305
 306    gtk_text_buffer_get_start_iter (new_buffer, &iter);
 307
 308    layout = gtk_text_layout_new ();
 309
 310    ltr_context = gtk_widget_create_pango_context (widget);
 311    pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
 312    rtl_context = gtk_widget_create_pango_context (widget);
 313    pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
 314
 315    gtk_text_layout_set_contexts (layout, ltr_context, rtl_context);
 316
 317    g_object_unref (ltr_context);
 318    g_object_unref (rtl_context);
 319
 320    style = gtk_text_attributes_new ();
 321
 322    layout_width = widget->allocation.width;
 323
 324    if (GTK_IS_TEXT_VIEW (widget))
 325      {
 326        gtk_widget_ensure_style (widget);
 327        gtk_text_view_set_attributes_from_style (GTK_TEXT_VIEW (widget),
 328                                                 style, widget->style);
 329
 330        layout_width = layout_width
 331          - gtk_text_view_get_border_window_size (GTK_TEXT_VIEW (widget), GTK_TEXT_WINDOW_LEFT)
 332          - gtk_text_view_get_border_window_size (GTK_TEXT_VIEW (widget), GTK_TEXT_WINDOW_RIGHT);
 333      }
 334
 335    style->direction = gtk_widget_get_direction (widget);
 336    style->wrap_mode = PANGO_WRAP_WORD_CHAR;
 337
 338    gtk_text_layout_set_default_style (layout, style);
 339    gtk_text_attributes_unref (style);
 340
 341    gtk_text_layout_set_buffer (layout, new_buffer);
 342    gtk_text_layout_set_cursor_visible (layout, FALSE);
 343    gtk_text_layout_set_screen_width (layout, layout_width);
 344
 345    gtk_text_layout_validate (layout, DRAG_ICON_MAX_HEIGHT);
 346    gtk_text_layout_get_size (layout, &layout_width, &layout_height);
 347
 348    layout_width = MIN (layout_width, DRAG_ICON_MAX_WIDTH);
 349    layout_height = MIN (layout_height, DRAG_ICON_MAX_HEIGHT);
 350
 351    pixmap_width  = layout_width + DRAG_ICON_LAYOUT_BORDER * 2;
 352    pixmap_height = layout_height + DRAG_ICON_LAYOUT_BORDER * 2;
 353
 354    drawable = gdk_pixmap_new (widget->window,
 355                               pixmap_width  + 2, pixmap_height + 2, -1);
 356
 357    gdk_draw_rectangle (drawable,
 358                        widget->style->base_gc [GTK_WIDGET_STATE (widget)],
 359                        TRUE,
 360                        0, 0,
 361                        pixmap_width + 1,
 362                        pixmap_height + 1);
 363
 364    gtk_text_layout_draw (layout, widget, drawable,
 365                          widget->style->text_gc [GTK_WIDGET_STATE (widget)],
 366                          - (1 + DRAG_ICON_LAYOUT_BORDER),
 367                          - (1 + DRAG_ICON_LAYOUT_BORDER),
 368                          0, 0,
 369                          pixmap_width, pixmap_height, NULL);
 370
 371    gdk_draw_rectangle (drawable,
 372                        widget->style->black_gc,
 373                        FALSE,
 374                        0, 0,
 375                        pixmap_width + 1,
 376                        pixmap_height + 1);
 377
 378    g_object_unref (layout);
 379    g_object_unref (new_buffer);
 380
 381    return drawable;
 382 }
 383
 384
 385 static gint
 386 layout_get_char_width (PangoLayout *layout)
 387 {
 388   gint width;
 389   PangoFontMetrics *metrics;
 390   const PangoFontDescription *font_desc;
 391   PangoContext *context = pango_layout_get_context (layout);
 392
 393   font_desc = pango_layout_get_font_description (layout);
 394   if (!font_desc)
 395     font_desc = pango_context_get_font_description (context);
 396
 397   metrics = pango_context_get_metrics (context, font_desc, NULL);
 398   width = pango_font_metrics_get_approximate_char_width (metrics);
 399   pango_font_metrics_unref (metrics);
 400
 401   return width;
 402 }
 403
 404 /**
 405  * _gtk_text_util_get_block_cursor_location
 406  * @layout: a #PangoLayout
 407  * @index: index at which cursor is located
 408  * @pos: cursor location
 409  * @at_line_end: whether cursor i sdrawn at line end, not over some
 410  * character
 411  *
 412  * Returns: whether cursor should actually be drawn as a rectangle.
 413  * It may not be the case if character at index is invisible.
 414  **/
 415 gboolean
 416 _gtk_text_util_get_block_cursor_location (PangoLayout    *layout,
 417                                           gint            index,
 418                                           PangoRectangle *pos,
 419                                           gboolean       *at_line_end)
 420 {
 421   PangoRectangle strong_pos, weak_pos;
 422   PangoLayoutLine *layout_line;
 423   gboolean rtl;
 424   gint line_no;
 425   const gchar *text;
 426
 427   g_return_val_if_fail (layout != NULL, FALSE);
 428   g_return_val_if_fail (index >= 0, FALSE);
 429   g_return_val_if_fail (pos != NULL, FALSE);
 430
 431   pango_layout_index_to_pos (layout, index, pos);
 432
 433   if (pos->width != 0)
 434     {
 435       /* cursor is at some visible character, good */
 436       if (at_line_end)
 437         *at_line_end = FALSE;
 438       if (pos->width < 0)
 439         {
 440           pos->x += pos->width;
 441           pos->width = -pos->width;
 442         }
 443       return TRUE;
 444     }
 445
 446   pango_layout_index_to_line_x (layout, index, FALSE, &line_no, NULL);
 447   layout_line = pango_layout_get_line_readonly (layout, line_no);
 448   g_return_val_if_fail (layout_line != NULL, FALSE);
 449
 450   text = pango_layout_get_text (layout);
 451
 452   if (index < layout_line->start_index + layout_line->length)
 453     {
 454       /* this may be a zero-width character in the middle of the line,
 455        * or it could be a character where line is wrapped, we do want
 456        * block cursor in latter case */
 457       if (g_utf8_next_char (text + index) - text !=
 458           layout_line->start_index + layout_line->length)
 459         {
 460           /* zero-width character in the middle of the line, do not
 461            * bother with block cursor */
 462           return FALSE;
 463         }
 464     }
 465
 466   /* Cursor is at the line end. It may be an empty line, or it could
 467    * be on the left or on the right depending on text direction, or it
 468    * even could be in the middle of visual layout in bidi text. */
 469
 470   pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
 471
 472   if (strong_pos.x != weak_pos.x)
 473     {
 474       /* do not show block cursor in this case, since the character typed
 475        * in may or may not appear at the cursor position */
 476       return FALSE;
 477     }
 478
 479   /* In case when index points to the end of line, pos->x is always most right
 480    * pixel of the layout line, so we need to correct it for RTL text. */
 481   if (layout_line->length)
 482     {
 483       if (layout_line->resolved_dir == PANGO_DIRECTION_RTL)
 484         {
 485           PangoLayoutIter *iter;
 486           PangoRectangle line_rect;
 487           gint i;
 488           gint left, right;
 489           const gchar *p;
 490
 491           p = g_utf8_prev_char (text + index);
 492
 493           pango_layout_line_index_to_x (layout_line, p - text, FALSE, &left);
 494           pango_layout_line_index_to_x (layout_line, p - text, TRUE, &right);
 495           pos->x = MIN (left, right);
 496
 497           iter = pango_layout_get_iter (layout);
 498           for (i = 0; i < line_no; i++)
 499             pango_layout_iter_next_line (iter);
 500           pango_layout_iter_get_line_extents (iter, NULL, &line_rect);
 501           pango_layout_iter_free (iter);
 502
 503           rtl = TRUE;
 504           pos->x += line_rect.x;
 505         }
 506       else
 507         rtl = FALSE;
 508     }
 509   else
 510     {
 511       PangoContext *context = pango_layout_get_context (layout);
 512       rtl = pango_context_get_base_dir (context) == PANGO_DIRECTION_RTL;
 513     }
 514
 515   pos->width = layout_get_char_width (layout);
 516
 517   if (rtl)
 518     pos->x -= pos->width - 1;
 519
 520   if (at_line_end)
 521     *at_line_end = TRUE;
 522
 523   return pos->width != 0;
 524 }