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

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