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

   1 /* gtktextdisplay.c - display layed-out text
   2  *
   3  * Copyright (c) 1992-1994 The Regents of the University of California.
   4  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
   5  * Copyright (c) 2000 Red Hat, Inc.
   6  * Tk->Gtk port by Havoc Pennington
   7  *
   8  * This file can be used under your choice of two licenses, the LGPL
   9  * and the original Tk license.
  10  *
  11  * LGPL:
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free
  25  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *
  27  * Original Tk license:
  28  *
  29  * This software is copyrighted by the Regents of the University of
  30  * California, Sun Microsystems, Inc., and other parties.  The
  31  * following terms apply to all files associated with the software
  32  * unless explicitly disclaimed in individual files.
  33  *
  34  * The authors hereby grant permission to use, copy, modify,
  35  * distribute, and license this software and its documentation for any
  36  * purpose, provided that existing copyright notices are retained in
  37  * all copies and that this notice is included verbatim in any
  38  * distributions. No written agreement, license, or royalty fee is
  39  * required for any of the authorized uses.  Modifications to this
  40  * software may be copyrighted by their authors and need not follow
  41  * the licensing terms described here, provided that the new terms are
  42  * clearly indicated on the first page of each file where they apply.
  43  *
  44  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
  45  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
  46  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
  47  * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
  48  * OF THE POSSIBILITY OF SUCH DAMAGE.
  49  *
  50  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
  51  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  52  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
  53  * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
  54  * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
  55  * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  56  *
  57  * GOVERNMENT USE: If you are acquiring this software on behalf of the
  58  * U.S. government, the Government shall have only "Restricted Rights"
  59  * in the software and related documentation as defined in the Federal
  60  * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
  61  * are acquiring the software on behalf of the Department of Defense,
  62  * the software shall be classified as "Commercial Computer Software"
  63  * and the Government shall have only "Restricted Rights" as defined
  64  * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the
  65  * foregoing, the authors grant the U.S. Government and others acting
  66  * in its behalf permission to use and distribute the software in
  67  * accordance with the terms specified in this license.
  68  *
  69  */
  70 /*
  71  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  72  * file for a list of people on the GTK+ Team.  See the ChangeLog
  73  * files for a list of changes.  These files are distributed with
  74  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  75  */
  76
  77 #define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
  78 #include "config.h"
  79 #include "gtktextdisplay.h"
  80 #include "gtkwidgetprivate.h"
  81 #include "gtkstylecontextprivate.h"
  82 #include "gtkintl.h"
  83
  84 /* DO NOT go putting private headers in here. This file should only
  85  * use the semi-public headers, as with gtktextview.c.
  86  */
  87
  88 #define GTK_TYPE_TEXT_RENDERER            (_gtk_text_renderer_get_type())
  89 #define GTK_TEXT_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_RENDERER, GtkTextRenderer))
  90 #define GTK_IS_TEXT_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_RENDERER))
  91 #define GTK_TEXT_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_RENDERER, GtkTextRendererClass))
  92 #define GTK_IS_TEXT_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_RENDERER))
  93 #define GTK_TEXT_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_RENDERER, GtkTextRendererClass))
  94
  95 typedef struct _GtkTextRenderer      GtkTextRenderer;
  96 typedef struct _GtkTextRendererClass GtkTextRendererClass;
  97
  98 enum {
  99   NORMAL,
 100   SELECTED,
 101   CURSOR
 102 };
 103
 104 struct _GtkTextRenderer
 105 {
 106   PangoRenderer parent_instance;
 107
 108   GtkWidget *widget;
 109   cairo_t *cr;
 110
 111   GdkRGBA *error_color; /* Error underline color for this widget */
 112   GList *widgets;       /* widgets encountered when drawing */
 113
 114   GdkRGBA rgba[4];
 115   guint8  rgba_set[4];
 116
 117   guint state : 2;
 118 };
 119
 120 struct _GtkTextRendererClass
 121 {
 122   PangoRendererClass parent_class;
 123 };
 124
 125 G_DEFINE_TYPE (GtkTextRenderer, _gtk_text_renderer, PANGO_TYPE_RENDERER)
 126
 127 static void
 128 text_renderer_set_rgba (GtkTextRenderer *text_renderer,
 129                         PangoRenderPart  part,
 130                         const GdkRGBA   *rgba)
 131 {
 132   PangoRenderer *renderer = PANGO_RENDERER (text_renderer);
 133   PangoColor     dummy = { 0, };
 134
 135   if (rgba)
 136     {
 137       text_renderer->rgba[part] = *rgba;
 138       pango_renderer_set_color (renderer, part, &dummy);
 139     }
 140   else
 141     pango_renderer_set_color (renderer, part, NULL);
 142
 143   text_renderer->rgba_set[part] = (rgba != NULL);
 144 }
 145
 146 static GtkTextAppearance *
 147 get_item_appearance (PangoItem *item)
 148 {
 149   GSList *tmp_list = item->analysis.extra_attrs;
 150
 151   while (tmp_list)
 152     {
 153       PangoAttribute *attr = tmp_list->data;
 154
 155       if (attr->klass->type == gtk_text_attr_appearance_type)
 156         return &((GtkTextAttrAppearance *)attr)->appearance;
 157
 158       tmp_list = tmp_list->next;
 159     }
 160
 161   return NULL;
 162 }
 163
 164 static void
 165 gtk_text_renderer_prepare_run (PangoRenderer  *renderer,
 166                                PangoLayoutRun *run)
 167 {
 168   GtkStyleContext *context;
 169   GtkStateFlags state;
 170   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 171   GdkRGBA *bg_rgba = NULL;
 172   GdkRGBA *fg_rgba = NULL;
 173   GtkTextAppearance *appearance;
 174
 175   PANGO_RENDERER_CLASS (_gtk_text_renderer_parent_class)->prepare_run (renderer, run);
 176
 177   appearance = get_item_appearance (run->item);
 178   g_assert (appearance != NULL);
 179
 180   context = gtk_widget_get_style_context (text_renderer->widget);
 181   state   = gtk_widget_get_state_flags (text_renderer->widget);
 182
 183   if (appearance->draw_bg && text_renderer->state == NORMAL)
 184     bg_rgba = appearance->rgba[0];
 185   else
 186     bg_rgba = NULL;
 187
 188   text_renderer_set_rgba (text_renderer, PANGO_RENDER_PART_BACKGROUND, bg_rgba);
 189
 190   if (text_renderer->state == SELECTED)
 191     {
 192       state |= GTK_STATE_FLAG_SELECTED;
 193
 194       gtk_style_context_get (context, state, "color", &fg_rgba, NULL);
 195     }
 196   else if (text_renderer->state == CURSOR && gtk_widget_has_focus (text_renderer->widget))
 197     {
 198       gtk_style_context_get (context, state,
 199                              "background-color", &fg_rgba,
 200                               NULL);
 201     }
 202   else
 203     fg_rgba = appearance->rgba[1];
 204
 205   text_renderer_set_rgba (text_renderer, PANGO_RENDER_PART_FOREGROUND, fg_rgba);
 206   text_renderer_set_rgba (text_renderer, PANGO_RENDER_PART_STRIKETHROUGH, fg_rgba);
 207
 208   if (appearance->underline == PANGO_UNDERLINE_ERROR)
 209     {
 210       if (!text_renderer->error_color)
 211         {
 212           GdkColor *color = NULL;
 213
 214           gtk_style_context_get_style (context,
 215                                        "error-underline-color", &color,
 216                                        NULL);
 217
 218           if (color)
 219             {
 220               GdkRGBA   rgba;
 221
 222               rgba.red = color->red / 65535.;
 223               rgba.green = color->green / 65535.;
 224               rgba.blue = color->blue / 65535.;
 225               rgba.alpha = 1;
 226               gdk_color_free (color);
 227
 228               text_renderer->error_color = gdk_rgba_copy (&rgba);
 229             }
 230           else
 231             {
 232               static const GdkRGBA red = { 1, 0, 0, 1 };
 233               text_renderer->error_color = gdk_rgba_copy (&red);
 234             }
 235         }
 236
 237       text_renderer_set_rgba (text_renderer, PANGO_RENDER_PART_UNDERLINE, text_renderer->error_color);
 238     }
 239   else
 240     text_renderer_set_rgba (text_renderer, PANGO_RENDER_PART_UNDERLINE, fg_rgba);
 241
 242   if (fg_rgba != appearance->rgba[1])
 243     gdk_rgba_free (fg_rgba);
 244 }
 245
 246 static void
 247 set_color (GtkTextRenderer *text_renderer,
 248            PangoRenderPart  part)
 249 {
 250   cairo_save (text_renderer->cr);
 251
 252   if (text_renderer->rgba_set[part])
 253     gdk_cairo_set_source_rgba (text_renderer->cr, &text_renderer->rgba[part]);
 254 }
 255
 256 static void
 257 unset_color (GtkTextRenderer *text_renderer)
 258 {
 259   cairo_restore (text_renderer->cr);
 260 }
 261
 262 static void
 263 gtk_text_renderer_draw_glyphs (PangoRenderer     *renderer,
 264                                PangoFont         *font,
 265                                PangoGlyphString  *glyphs,
 266                                int                x,
 267                                int                y)
 268 {
 269   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 270
 271   set_color (text_renderer, PANGO_RENDER_PART_FOREGROUND);
 272
 273   cairo_move_to (text_renderer->cr, (double)x / PANGO_SCALE, (double)y / PANGO_SCALE);
 274   pango_cairo_show_glyph_string (text_renderer->cr, font, glyphs);
 275
 276   unset_color (text_renderer);
 277 }
 278
 279 static void
 280 gtk_text_renderer_draw_glyph_item (PangoRenderer     *renderer,
 281                                    const char        *text,
 282                                    PangoGlyphItem    *glyph_item,
 283                                    int                x,
 284                                    int                y)
 285 {
 286   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 287
 288   set_color (text_renderer, PANGO_RENDER_PART_FOREGROUND);
 289
 290   cairo_move_to (text_renderer->cr, (double)x / PANGO_SCALE, (double)y / PANGO_SCALE);
 291   pango_cairo_show_glyph_item (text_renderer->cr, text, glyph_item);
 292
 293   unset_color (text_renderer);
 294 }
 295
 296 static void
 297 gtk_text_renderer_draw_rectangle (PangoRenderer     *renderer,
 298                                   PangoRenderPart    part,
 299                                   int                x,
 300                                   int                y,
 301                                   int                width,
 302                                   int                height)
 303 {
 304   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 305
 306   set_color (text_renderer, part);
 307
 308   cairo_rectangle (text_renderer->cr,
 309                    (double)x / PANGO_SCALE, (double)y / PANGO_SCALE,
 310                    (double)width / PANGO_SCALE, (double)height / PANGO_SCALE);
 311   cairo_fill (text_renderer->cr);
 312
 313   unset_color (text_renderer);
 314 }
 315
 316 static void
 317 gtk_text_renderer_draw_trapezoid (PangoRenderer     *renderer,
 318                                   PangoRenderPart    part,
 319                                   double             y1_,
 320                                   double             x11,
 321                                   double             x21,
 322                                   double             y2,
 323                                   double             x12,
 324                                   double             x22)
 325 {
 326   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 327   cairo_t *cr;
 328   cairo_matrix_t matrix;
 329
 330   set_color (text_renderer, part);
 331
 332   cr = text_renderer->cr;
 333
 334   cairo_get_matrix (cr, &matrix);
 335   matrix.xx = matrix.yy = 1.0;
 336   matrix.xy = matrix.yx = 0.0;
 337   cairo_set_matrix (cr, &matrix);
 338
 339   cairo_move_to (cr, x11, y1_);
 340   cairo_line_to (cr, x21, y1_);
 341   cairo_line_to (cr, x22, y2);
 342   cairo_line_to (cr, x12, y2);
 343   cairo_close_path (cr);
 344
 345   cairo_fill (cr);
 346
 347   unset_color (text_renderer);
 348 }
 349
 350 static void
 351 gtk_text_renderer_draw_error_underline (PangoRenderer *renderer,
 352                                         int            x,
 353                                         int            y,
 354                                         int            width,
 355                                         int            height)
 356 {
 357   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 358
 359   set_color (text_renderer, PANGO_RENDER_PART_UNDERLINE);
 360
 361   pango_cairo_show_error_underline (text_renderer->cr,
 362                                     (double)x / PANGO_SCALE, (double)y / PANGO_SCALE,
 363                                     (double)width / PANGO_SCALE, (double)height / PANGO_SCALE);
 364
 365   unset_color (text_renderer);
 366 }
 367
 368 static void
 369 gtk_text_renderer_draw_shape (PangoRenderer   *renderer,
 370                               PangoAttrShape  *attr,
 371                               int              x,
 372                               int              y)
 373 {
 374   GtkTextRenderer *text_renderer = GTK_TEXT_RENDERER (renderer);
 375
 376   if (attr->data == NULL)
 377     {
 378       /* This happens if we have an empty widget anchor. Draw
 379        * something empty-looking.
 380        */
 381       GdkRectangle shape_rect;
 382       cairo_t *cr;
 383
 384       shape_rect.x = PANGO_PIXELS (x);
 385       shape_rect.y = PANGO_PIXELS (y + attr->logical_rect.y);
 386       shape_rect.width = PANGO_PIXELS (x + attr->logical_rect.width) - shape_rect.x;
 387       shape_rect.height = PANGO_PIXELS (y + attr->logical_rect.y + attr->logical_rect.height) - shape_rect.y;
 388
 389       set_color (text_renderer, PANGO_RENDER_PART_FOREGROUND);
 390
 391       cr = text_renderer->cr;
 392
 393       cairo_set_line_width (cr, 1.0);
 394
 395       cairo_rectangle (cr,
 396                        shape_rect.x + 0.5, shape_rect.y + 0.5,
 397                        shape_rect.width - 1, shape_rect.height - 1);
 398       cairo_move_to (cr, shape_rect.x + 0.5, shape_rect.y + 0.5);
 399       cairo_line_to (cr,
 400                      shape_rect.x + shape_rect.width - 0.5,
 401                      shape_rect.y + shape_rect.height - 0.5);
 402       cairo_move_to (cr, shape_rect.x + 0.5,
 403                      shape_rect.y + shape_rect.height - 0.5);
 404       cairo_line_to (cr, shape_rect.x + shape_rect.width - 0.5,
 405                      shape_rect.y + 0.5);
 406
 407       cairo_stroke (cr);
 408
 409       unset_color (text_renderer);
 410     }
 411   else if (GDK_IS_PIXBUF (attr->data))
 412     {
 413       cairo_t *cr = text_renderer->cr;
 414       GdkPixbuf *pixbuf = GDK_PIXBUF (attr->data);
 415
 416       cairo_save (cr);
 417
 418       gdk_cairo_set_source_pixbuf (cr, pixbuf,
 419                                    PANGO_PIXELS (x),
 420                                    PANGO_PIXELS (y) -  gdk_pixbuf_get_height (pixbuf));
 421       cairo_paint (cr);
 422
 423       cairo_restore (cr);
 424     }
 425   else if (GTK_IS_WIDGET (attr->data))
 426     {
 427       GtkWidget *widget;
 428
 429       widget = GTK_WIDGET (attr->data);
 430
 431       text_renderer->widgets = g_list_prepend (text_renderer->widgets,
 432                                                g_object_ref (widget));
 433     }
 434   else
 435     g_assert_not_reached (); /* not a pixbuf or widget */
 436 }
 437
 438 static void
 439 gtk_text_renderer_finalize (GObject *object)
 440 {
 441   G_OBJECT_CLASS (_gtk_text_renderer_parent_class)->finalize (object);
 442 }
 443
 444 static void
 445 _gtk_text_renderer_init (GtkTextRenderer *renderer)
 446 {
 447 }
 448
 449 static void
 450 _gtk_text_renderer_class_init (GtkTextRendererClass *klass)
 451 {
 452   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 453
 454   PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
 455
 456   renderer_class->prepare_run = gtk_text_renderer_prepare_run;
 457   renderer_class->draw_glyphs = gtk_text_renderer_draw_glyphs;
 458   renderer_class->draw_glyph_item = gtk_text_renderer_draw_glyph_item;
 459   renderer_class->draw_rectangle = gtk_text_renderer_draw_rectangle;
 460   renderer_class->draw_trapezoid = gtk_text_renderer_draw_trapezoid;
 461   renderer_class->draw_error_underline = gtk_text_renderer_draw_error_underline;
 462   renderer_class->draw_shape = gtk_text_renderer_draw_shape;
 463
 464   object_class->finalize = gtk_text_renderer_finalize;
 465 }
 466
 467 static void
 468 text_renderer_set_state (GtkTextRenderer *text_renderer,
 469                          int              state)
 470 {
 471   text_renderer->state = state;
 472 }
 473
 474 static void
 475 text_renderer_begin (GtkTextRenderer *text_renderer,
 476                      GtkWidget       *widget,
 477                      cairo_t         *cr)
 478 {
 479   GtkStyleContext *context;
 480   GtkStateFlags state;
 481   GdkRGBA color;
 482
 483   text_renderer->widget = widget;
 484   text_renderer->cr = cr;
 485
 486   context = gtk_widget_get_style_context (widget);
 487
 488   gtk_style_context_save (context);
 489   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
 490
 491   state = gtk_widget_get_state_flags (widget);
 492   gtk_style_context_get_color (context, state, &color);
 493
 494   cairo_save (cr);
 495
 496   gdk_cairo_set_source_rgba (cr, &color);
 497 }
 498
 499 /* Returns a GSList of (referenced) widgets encountered while drawing.
 500  */
 501 static GList *
 502 text_renderer_end (GtkTextRenderer *text_renderer)
 503 {
 504   GtkStyleContext *context;
 505   GList *widgets = text_renderer->widgets;
 506
 507   cairo_restore (text_renderer->cr);
 508
 509   context = gtk_widget_get_style_context (text_renderer->widget);
 510
 511   gtk_style_context_restore (context);
 512
 513   text_renderer->widget = NULL;
 514   text_renderer->cr = NULL;
 515
 516   text_renderer->widgets = NULL;
 517
 518   if (text_renderer->error_color)
 519     {
 520       gdk_rgba_free (text_renderer->error_color);
 521       text_renderer->error_color = NULL;
 522     }
 523
 524   return widgets;
 525 }
 526
 527 static cairo_region_t *
 528 get_selected_clip (GtkTextRenderer    *text_renderer,
 529                    PangoLayout        *layout,
 530                    PangoLayoutLine    *line,
 531                    int                 x,
 532                    int                 y,
 533                    int                 height,
 534                    int                 start_index,
 535                    int                 end_index)
 536 {
 537   gint *ranges;
 538   gint n_ranges, i;
 539   cairo_region_t *clip_region = cairo_region_create ();
 540
 541   pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
 542
 543   for (i=0; i < n_ranges; i++)
 544     {
 545       GdkRectangle rect;
 546
 547       rect.x = x + PANGO_PIXELS (ranges[2*i]);
 548       rect.y = y;
 549       rect.width = PANGO_PIXELS (ranges[2*i + 1]) - PANGO_PIXELS (ranges[2*i]);
 550       rect.height = height;
 551
 552       cairo_region_union_rectangle (clip_region, &rect);
 553     }
 554
 555   g_free (ranges);
 556   return clip_region;
 557 }
 558
 559 static void
 560 render_para (GtkTextRenderer    *text_renderer,
 561              GtkTextLineDisplay *line_display,
 562              int                 selection_start_index,
 563              int                 selection_end_index)
 564 {
 565   GtkStyleContext *context;
 566   GtkStateFlags state;
 567   PangoLayout *layout = line_display->layout;
 568   int byte_offset = 0;
 569   PangoLayoutIter *iter;
 570   PangoRectangle layout_logical;
 571   int screen_width;
 572   GdkRGBA selection;
 573   gboolean first = TRUE;
 574
 575   iter = pango_layout_get_iter (layout);
 576
 577   pango_layout_iter_get_layout_extents (iter, NULL, &layout_logical);
 578
 579   /* Adjust for margins */
 580
 581   layout_logical.x += line_display->x_offset * PANGO_SCALE;
 582   layout_logical.y += line_display->top_margin * PANGO_SCALE;
 583
 584   screen_width = line_display->total_width;
 585
 586   context = gtk_widget_get_style_context (text_renderer->widget);
 587   state = gtk_widget_get_state_flags (text_renderer->widget);
 588
 589   state |= GTK_STATE_FLAG_SELECTED;
 590
 591   gtk_style_context_get_background_color (context, state, &selection);
 592
 593   do
 594     {
 595       PangoLayoutLine *line = pango_layout_iter_get_line_readonly (iter);
 596       int selection_y, selection_height;
 597       int first_y, last_y;
 598       PangoRectangle line_rect;
 599       int baseline;
 600       gboolean at_last_line;
 601
 602       pango_layout_iter_get_line_extents (iter, NULL, &line_rect);
 603       baseline = pango_layout_iter_get_baseline (iter);
 604       pango_layout_iter_get_line_yrange (iter, &first_y, &last_y);
 605
 606       /* Adjust for margins */
 607
 608       line_rect.x += line_display->x_offset * PANGO_SCALE;
 609       line_rect.y += line_display->top_margin * PANGO_SCALE;
 610       baseline += line_display->top_margin * PANGO_SCALE;
 611
 612       /* Selection is the height of the line, plus top/bottom
 613        * margin if we're the first/last line
 614        */
 615       selection_y = PANGO_PIXELS (first_y) + line_display->top_margin;
 616       selection_height = PANGO_PIXELS (last_y) - PANGO_PIXELS (first_y);
 617
 618       if (first)
 619         {
 620           selection_y -= line_display->top_margin;
 621           selection_height += line_display->top_margin;
 622         }
 623
 624       at_last_line = pango_layout_iter_at_last_line (iter);
 625       if (at_last_line)
 626         selection_height += line_display->bottom_margin;
 627
 628       first = FALSE;
 629
 630       if (selection_start_index < byte_offset &&
 631           selection_end_index > line->length + byte_offset) /* All selected */
 632         {
 633           cairo_t *cr = text_renderer->cr;
 634
 635           cairo_save (cr);
 636           gdk_cairo_set_source_rgba (cr, &selection);
 637           cairo_rectangle (cr,
 638                            line_display->left_margin, selection_y,
 639                            screen_width, selection_height);
 640           cairo_fill (cr);
 641           cairo_restore(cr);
 642
 643           text_renderer_set_state (text_renderer, SELECTED);
 644           pango_renderer_draw_layout_line (PANGO_RENDERER (text_renderer),
 645                                            line,
 646                                            line_rect.x,
 647                                            baseline);
 648         }
 649       else
 650         {
 651           if (line_display->pg_bg_rgba)
 652             {
 653               cairo_t *cr = text_renderer->cr;
 654
 655               cairo_save (cr);
 656
 657               gdk_cairo_set_source_rgba (text_renderer->cr, line_display->pg_bg_rgba);
 658               cairo_rectangle (cr,
 659                                line_display->left_margin, selection_y,
 660                                screen_width, selection_height);
 661               cairo_fill (cr);
 662
 663               cairo_restore (cr);
 664             }
 665
 666           text_renderer_set_state (text_renderer, NORMAL);
 667           pango_renderer_draw_layout_line (PANGO_RENDERER (text_renderer),
 668                                            line,
 669                                            line_rect.x,
 670                                            baseline);
 671
 672           /* Check if some part of the line is selected; the newline
 673            * that is after line->length for the last line of the
 674            * paragraph counts as part of the line for this
 675            */
 676           if ((selection_start_index < byte_offset + line->length ||
 677                (selection_start_index == byte_offset + line->length && pango_layout_iter_at_last_line (iter))) &&
 678               selection_end_index > byte_offset)
 679             {
 680               cairo_t *cr = text_renderer->cr;
 681               cairo_region_t *clip_region = get_selected_clip (text_renderer, layout, line,
 682                                                           line_display->x_offset,
 683                                                           selection_y,
 684                                                           selection_height,
 685                                                           selection_start_index, selection_end_index);
 686
 687               cairo_save (cr);
 688               gdk_cairo_region (cr, clip_region);
 689               cairo_clip (cr);
 690               cairo_region_destroy (clip_region);
 691
 692               gdk_cairo_set_source_rgba (cr, &selection);
 693               cairo_rectangle (cr,
 694                                PANGO_PIXELS (line_rect.x),
 695                                selection_y,
 696                                PANGO_PIXELS (line_rect.width),
 697                                selection_height);
 698               cairo_fill (cr);
 699
 700               text_renderer_set_state (text_renderer, SELECTED);
 701               pango_renderer_draw_layout_line (PANGO_RENDERER (text_renderer),
 702                                                line,
 703                                                line_rect.x,
 704                                                baseline);
 705
 706               cairo_restore (cr);
 707
 708               /* Paint in the ends of the line */
 709               if (line_rect.x > line_display->left_margin * PANGO_SCALE &&
 710                   ((line_display->direction == GTK_TEXT_DIR_LTR && selection_start_index < byte_offset) ||
 711                    (line_display->direction == GTK_TEXT_DIR_RTL && selection_end_index > byte_offset + line->length)))
 712                 {
 713                   cairo_save (cr);
 714
 715                   gdk_cairo_set_source_rgba (cr, &selection);
 716                   cairo_rectangle (cr,
 717                                    line_display->left_margin,
 718                                    selection_y,
 719                                    PANGO_PIXELS (line_rect.x) - line_display->left_margin,
 720                                    selection_height);
 721                   cairo_fill (cr);
 722
 723                   cairo_restore (cr);
 724                 }
 725
 726               if (line_rect.x + line_rect.width <
 727                   (screen_width + line_display->left_margin) * PANGO_SCALE &&
 728                   ((line_display->direction == GTK_TEXT_DIR_LTR && selection_end_index > byte_offset + line->length) ||
 729                    (line_display->direction == GTK_TEXT_DIR_RTL && selection_start_index < byte_offset)))
 730                 {
 731                   int nonlayout_width;
 732
 733                   nonlayout_width =
 734                     line_display->left_margin + screen_width -
 735                     PANGO_PIXELS (line_rect.x) - PANGO_PIXELS (line_rect.width);
 736
 737                   cairo_save (cr);
 738
 739                   gdk_cairo_set_source_rgba (cr, &selection);
 740                   cairo_rectangle (cr,
 741                                    PANGO_PIXELS (line_rect.x) + PANGO_PIXELS (line_rect.width),
 742                                    selection_y,
 743                                    nonlayout_width,
 744                                    selection_height);
 745                   cairo_fill (cr);
 746
 747                   cairo_restore (cr);
 748                 }
 749             }
 750           else if (line_display->has_block_cursor &&
 751                    gtk_widget_has_focus (text_renderer->widget) &&
 752                    byte_offset <= line_display->insert_index &&
 753                    (line_display->insert_index < byte_offset + line->length ||
 754                     (at_last_line && line_display->insert_index == byte_offset + line->length)))
 755             {
 756               GdkRectangle cursor_rect;
 757               GdkRGBA cursor_color;
 758               cairo_t *cr = text_renderer->cr;
 759
 760               /* we draw text using base color on filled cursor rectangle of cursor color
 761                * (normally white on black) */
 762               _gtk_style_context_get_cursor_color (context, &cursor_color, NULL);
 763
 764               cursor_rect.x = line_display->x_offset + line_display->block_cursor.x;
 765               cursor_rect.y = line_display->block_cursor.y + line_display->top_margin;
 766               cursor_rect.width = line_display->block_cursor.width;
 767               cursor_rect.height = line_display->block_cursor.height;
 768
 769               cairo_save (cr);
 770
 771               gdk_cairo_rectangle (cr, &cursor_rect);
 772               cairo_clip (cr);
 773
 774               gdk_cairo_set_source_rgba (cr, &cursor_color);
 775               cairo_paint (cr);
 776
 777               /* draw text under the cursor if any */
 778               if (!line_display->cursor_at_line_end)
 779                 {
 780                   GdkRGBA color;
 781
 782                   state = gtk_widget_get_state_flags (text_renderer->widget);
 783                   gtk_style_context_get_background_color (context, state, &color);
 784
 785                   gdk_cairo_set_source_rgba (cr, &color);
 786
 787                   text_renderer_set_state (text_renderer, CURSOR);
 788
 789                   pango_renderer_draw_layout_line (PANGO_RENDERER (text_renderer),
 790                                                    line,
 791                                                    line_rect.x,
 792                                                    baseline);
 793                 }
 794
 795               cairo_restore (cr);
 796             }
 797         }
 798
 799       byte_offset += line->length;
 800     }
 801   while (pango_layout_iter_next_line (iter));
 802
 803   pango_layout_iter_free (iter);
 804 }
 805
 806 static GtkTextRenderer *
 807 get_text_renderer (void)
 808 {
 809   static GtkTextRenderer *text_renderer = NULL;
 810
 811   if (!text_renderer)
 812     text_renderer = g_object_new (GTK_TYPE_TEXT_RENDERER, NULL);
 813
 814   return text_renderer;
 815 }
 816
 817 void
 818 gtk_text_layout_draw (GtkTextLayout *layout,
 819                       GtkWidget *widget,
 820                       cairo_t *cr,
 821                       GList **widgets)
 822 {
 823   GtkStyleContext *context;
 824   gint offset_y;
 825   GtkTextRenderer *text_renderer;
 826   GtkTextIter selection_start, selection_end;
 827   gboolean have_selection;
 828   GSList *line_list;
 829   GSList *tmp_list;
 830   GList *tmp_widgets;
 831   GdkRectangle clip;
 832
 833   g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
 834   g_return_if_fail (layout->default_style != NULL);
 835   g_return_if_fail (layout->buffer != NULL);
 836   g_return_if_fail (cr != NULL);
 837
 838   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
 839     return;
 840
 841   context = gtk_widget_get_style_context (widget);
 842
 843   line_list = gtk_text_layout_get_lines (layout, clip.y, clip.y + clip.height, &offset_y);
 844
 845   if (line_list == NULL)
 846     return; /* nothing on the screen */
 847
 848   text_renderer = get_text_renderer ();
 849   text_renderer_begin (text_renderer, widget, cr);
 850
 851   /* text_renderer_begin/end does cairo_save/restore */
 852   cairo_translate (cr, 0, offset_y);
 853
 854   gtk_text_layout_wrap_loop_start (layout);
 855
 856   have_selection = gtk_text_buffer_get_selection_bounds (layout->buffer,
 857                                                          &selection_start,
 858                                                          &selection_end);
 859
 860   tmp_list = line_list;
 861   while (tmp_list != NULL)
 862     {
 863       GtkTextLineDisplay *line_display;
 864       gint selection_start_index = -1;
 865       gint selection_end_index = -1;
 866
 867       GtkTextLine *line = tmp_list->data;
 868
 869       line_display = gtk_text_layout_get_line_display (layout, line, FALSE);
 870
 871       if (line_display->height > 0)
 872         {
 873           g_assert (line_display->layout != NULL);
 874
 875           if (have_selection)
 876             {
 877               GtkTextIter line_start, line_end;
 878               gint byte_count;
 879
 880               gtk_text_layout_get_iter_at_line (layout,
 881                                                 &line_start,
 882                                                 line, 0);
 883               line_end = line_start;
 884               if (!gtk_text_iter_ends_line (&line_end))
 885                 gtk_text_iter_forward_to_line_end (&line_end);
 886               byte_count = gtk_text_iter_get_visible_line_index (&line_end);
 887
 888               if (gtk_text_iter_compare (&selection_start, &line_end) <= 0 &&
 889                   gtk_text_iter_compare (&selection_end, &line_start) >= 0)
 890                 {
 891                   if (gtk_text_iter_compare (&selection_start, &line_start) >= 0)
 892                     selection_start_index = gtk_text_iter_get_visible_line_index (&selection_start);
 893                   else
 894                     selection_start_index = -1;
 895
 896                   if (gtk_text_iter_compare (&selection_end, &line_end) <= 0)
 897                     selection_end_index = gtk_text_iter_get_visible_line_index (&selection_end);
 898                   else
 899                     selection_end_index = byte_count + 1; /* + 1 to flag past-the-end */
 900                 }
 901             }
 902
 903           render_para (text_renderer, line_display,
 904                        selection_start_index, selection_end_index);
 905
 906           /* We paint the cursors last, because they overlap another chunk
 907            * and need to appear on top.
 908            */
 909           if (line_display->cursors != NULL)
 910             {
 911               int i;
 912
 913               for (i = 0; i < line_display->cursors->len; i++)
 914                 {
 915                   int index;
 916                   PangoDirection dir;
 917
 918                   index = g_array_index(line_display->cursors, int, i);
 919                   dir = (line_display->direction == GTK_TEXT_DIR_RTL) ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
 920                   gtk_render_insertion_cursor (context, cr,
 921                                                line_display->x_offset, line_display->top_margin,
 922                                                line_display->layout, index, dir);
 923                 }
 924             }
 925         } /* line_display->height > 0 */
 926
 927       cairo_translate (cr, 0, line_display->height);
 928       gtk_text_layout_free_line_display (layout, line_display);
 929
 930       tmp_list = g_slist_next (tmp_list);
 931     }
 932
 933   gtk_text_layout_wrap_loop_end (layout);
 934
 935   tmp_widgets = text_renderer_end (text_renderer);
 936   if (widgets)
 937     *widgets = tmp_widgets;
 938   else
 939     g_list_free_full (tmp_widgets, g_object_unref);
 940
 941   g_slist_free (line_list);
 942 }