462
+ − 1 /* X output and frame manipulation routines.
+ − 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
+ − 3 Copyright (C) 1994 Lucid, Inc.
+ − 4 Copyright (C) 1995 Sun Microsystems, Inc.
+ − 5
+ − 6 This file is part of XEmacs.
+ − 7
+ − 8 XEmacs is free software; you can redistribute it and/or modify it
+ − 9 under the terms of the GNU General Public License as published by the
+ − 10 Free Software Foundation; either version 2, or (at your option) any
+ − 11 later version.
+ − 12
+ − 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ − 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ − 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ − 16 for more details.
+ − 17
+ − 18 You should have received a copy of the GNU General Public License
+ − 19 along with XEmacs; see the file COPYING. If not, write to
+ − 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ − 21 Boston, MA 02111-1307, USA. */
+ − 22
+ − 23 /* Synched up with: Not in FSF. */
+ − 24
+ − 25 /* Author: Chuck Thompson */
+ − 26 /* Gtk flavor by William Perry */
+ − 27
+ − 28 /* Lots of work done by Ben Wing for Mule */
+ − 29
+ − 30 #include <config.h>
+ − 31 #include "lisp.h"
+ − 32
+ − 33 #include "console-gtk.h"
+ − 34 #include "gccache-gtk.h"
+ − 35 #include "glyphs-gtk.h"
+ − 36 #include "objects-gtk.h"
+ − 37
+ − 38 #include "buffer.h"
+ − 39 #include "debug.h"
+ − 40 #include "faces.h"
+ − 41 #include "frame.h"
+ − 42 #include "gutter.h"
+ − 43 #include "redisplay.h"
+ − 44 #include "sysdep.h"
+ − 45 #include "window.h"
+ − 46
+ − 47 #include "sysproc.h" /* for select() */
+ − 48
+ − 49 #ifdef MULE
+ − 50 #include "mule-ccl.h"
+ − 51 #include "file-coding.h" /* for CCL conversion */
+ − 52 #endif
+ − 53
+ − 54 #define CONST const
+ − 55
+ − 56 #define EOL_CURSOR_WIDTH 5
+ − 57
+ − 58 static void gtk_output_pixmap (struct window *w, struct display_line *dl,
+ − 59 Lisp_Object image_instance, int xpos,
+ − 60 int xoffset,
+ − 61 int start_pixpos, int width, face_index findex,
+ − 62 int cursor_start, int cursor_width,
+ − 63 int cursor_height);
+ − 64 static void gtk_output_vertical_divider (struct window *w, int clear);
+ − 65 static void gtk_output_blank (struct window *w, struct display_line *dl,
+ − 66 struct rune *rb, int start_pixpos,
+ − 67 int cursor_start, int cursor_width);
+ − 68 static void gtk_output_hline (struct window *w, struct display_line *dl,
+ − 69 struct rune *rb);
+ − 70 static void gtk_redraw_exposed_window (struct window *w, int x, int y,
+ − 71 int width, int height);
+ − 72 static void gtk_redraw_exposed_windows (Lisp_Object window, int x, int y,
+ − 73 int width, int height);
+ − 74 static void gtk_clear_region (Lisp_Object locale, struct device* d, struct frame* f,
+ − 75 face_index findex, int x, int y,
+ − 76 int width, int height, Lisp_Object fcolor, Lisp_Object bcolor,
+ − 77 Lisp_Object background_pixmap);
+ − 78 static void gtk_output_eol_cursor (struct window *w, struct display_line *dl,
+ − 79 int xpos, face_index findex);
+ − 80 static void gtk_clear_frame (struct frame *f);
+ − 81 static void gtk_clear_frame_windows (Lisp_Object window);
+ − 82 static void gtk_bevel_modeline (struct window *w, struct display_line *dl);
+ − 83
+ − 84 #if 0
+ − 85 static void __describe_gc (GdkGC *);
+ − 86 #endif
+ − 87
+ − 88 struct textual_run
+ − 89 {
+ − 90 Lisp_Object charset;
+ − 91 unsigned char *ptr;
+ − 92 int len;
+ − 93 int dimension;
+ − 94 };
+ − 95
+ − 96 /* Separate out the text in DYN into a series of textual runs of a
+ − 97 particular charset. Also convert the characters as necessary into
+ − 98 the format needed by XDrawImageString(), XDrawImageString16(), et
+ − 99 al. (This means converting to one or two byte format, possibly
+ − 100 tweaking the high bits, and possibly running a CCL program.) You
+ − 101 must pre-allocate the space used and pass it in. (This is done so
+ − 102 you can alloca() the space.) You need to allocate (2 * len) bytes
+ − 103 of TEXT_STORAGE and (len * sizeof (struct textual_run)) bytes of
+ − 104 RUN_STORAGE, where LEN is the length of the dynarr.
+ − 105
+ − 106 Returns the number of runs actually used. */
+ − 107
+ − 108 static int
+ − 109 separate_textual_runs (unsigned char *text_storage,
+ − 110 struct textual_run *run_storage,
+ − 111 CONST Emchar *str, Charcount len)
+ − 112 {
+ − 113 Lisp_Object prev_charset = Qunbound; /* not Qnil because that is a
+ − 114 possible valid charset when
+ − 115 MULE is not defined */
+ − 116 int runs_so_far = 0;
+ − 117 int i;
+ − 118 #ifdef MULE
+ − 119 struct ccl_program char_converter;
+ − 120 int need_ccl_conversion = 0;
+ − 121 #endif
+ − 122
+ − 123 for (i = 0; i < len; i++)
+ − 124 {
+ − 125 Emchar ch = str[i];
+ − 126 Lisp_Object charset;
+ − 127 int byte1, byte2;
+ − 128 int dimension;
+ − 129 int graphic;
+ − 130
+ − 131 BREAKUP_CHAR (ch, charset, byte1, byte2);
+ − 132 dimension = XCHARSET_DIMENSION (charset);
+ − 133 graphic = XCHARSET_GRAPHIC (charset);
+ − 134
+ − 135 if (!EQ (charset, prev_charset))
+ − 136 {
+ − 137 run_storage[runs_so_far].ptr = text_storage;
+ − 138 run_storage[runs_so_far].charset = charset;
+ − 139 run_storage[runs_so_far].dimension = dimension;
+ − 140
+ − 141 if (runs_so_far)
+ − 142 {
+ − 143 run_storage[runs_so_far - 1].len =
+ − 144 text_storage - run_storage[runs_so_far - 1].ptr;
+ − 145 if (run_storage[runs_so_far - 1].dimension == 2)
+ − 146 run_storage[runs_so_far - 1].len >>= 1;
+ − 147 }
+ − 148 runs_so_far++;
+ − 149 prev_charset = charset;
+ − 150 #ifdef MULE
+ − 151 {
+ − 152 Lisp_Object ccl_prog = XCHARSET_CCL_PROGRAM (charset);
+ − 153 need_ccl_conversion = !NILP (ccl_prog);
+ − 154 if (need_ccl_conversion)
+ − 155 setup_ccl_program (&char_converter, ccl_prog);
+ − 156 }
+ − 157 #endif
+ − 158 }
+ − 159
+ − 160 if (graphic == 0)
+ − 161 {
+ − 162 byte1 &= 0x7F;
+ − 163 byte2 &= 0x7F;
+ − 164 }
+ − 165 else if (graphic == 1)
+ − 166 {
+ − 167 byte1 |= 0x80;
+ − 168 byte2 |= 0x80;
+ − 169 }
+ − 170 #ifdef MULE
+ − 171 if (need_ccl_conversion)
+ − 172 {
+ − 173 char_converter.reg[0] = XCHARSET_ID (charset);
+ − 174 char_converter.reg[1] = byte1;
+ − 175 char_converter.reg[2] = byte2;
+ − 176 ccl_driver (&char_converter, 0, 0, 0, 0, CCL_MODE_ENCODING);
+ − 177 byte1 = char_converter.reg[1];
+ − 178 byte2 = char_converter.reg[2];
+ − 179 }
+ − 180 #endif
+ − 181 *text_storage++ = (unsigned char) byte1;
+ − 182 if (dimension == 2)
+ − 183 *text_storage++ = (unsigned char) byte2;
+ − 184 }
+ − 185
+ − 186 if (runs_so_far)
+ − 187 {
+ − 188 run_storage[runs_so_far - 1].len =
+ − 189 text_storage - run_storage[runs_so_far - 1].ptr;
+ − 190 if (run_storage[runs_so_far - 1].dimension == 2)
+ − 191 run_storage[runs_so_far - 1].len >>= 1;
+ − 192 }
+ − 193
+ − 194 return runs_so_far;
+ − 195 }
+ − 196
+ − 197 /****************************************************************************/
+ − 198 /* */
+ − 199 /* Gtk output routines */
+ − 200 /* */
+ − 201 /****************************************************************************/
+ − 202
+ − 203 static int
+ − 204 gtk_text_width_single_run (struct face_cachel *cachel, struct textual_run *run)
+ − 205 {
+ − 206 Lisp_Object font_inst = FACE_CACHEL_FONT (cachel, run->charset);
+ − 207 struct Lisp_Font_Instance *fi = XFONT_INSTANCE (font_inst);
+ − 208
+ − 209 if (!fi->proportional_p)
+ − 210 {
+ − 211 return fi->width * run->len;
+ − 212 }
+ − 213 else
+ − 214 {
+ − 215 if (run->dimension == 2)
+ − 216 {
+ − 217 stderr_out ("Measuring wide characters\n");
+ − 218 return gdk_text_width_wc (FONT_INSTANCE_GTK_FONT (fi),
+ − 219 (GdkWChar *) run->ptr, run->len);
+ − 220 }
+ − 221 else
+ − 222 {
+ − 223 return gdk_text_width (FONT_INSTANCE_GTK_FONT (fi),
+ − 224 (char *) run->ptr, run->len);
+ − 225 }
+ − 226 }
+ − 227 }
+ − 228
+ − 229 /*
+ − 230 gtk_text_width
+ − 231
+ − 232 Given a string and a face, return the string's length in pixels when
+ − 233 displayed in the font associated with the face.
+ − 234 */
+ − 235
+ − 236 static int
+ − 237 gtk_text_width (struct frame *f, struct face_cachel *cachel, CONST Emchar *str,
+ − 238 Charcount len)
+ − 239 {
+ − 240 int width_so_far = 0;
+ − 241 unsigned char *text_storage = (unsigned char *) alloca (2 * len);
+ − 242 struct textual_run *runs = alloca_array (struct textual_run, len);
+ − 243 int nruns;
+ − 244 int i;
+ − 245
+ − 246 nruns = separate_textual_runs (text_storage, runs, str, len);
+ − 247
+ − 248 for (i = 0; i < nruns; i++)
+ − 249 width_so_far += gtk_text_width_single_run (cachel, runs + i);
+ − 250
+ − 251 return width_so_far;
+ − 252 }
+ − 253
+ − 254 /*****************************************************************************
+ − 255 gtk_divider_height
+ − 256
+ − 257 Return the height of the horizontal divider. This is a function because
+ − 258 divider_height is a device method.
+ − 259
+ − 260 #### If we add etched horizontal divider lines this will have to get
+ − 261 smarter.
+ − 262 ****************************************************************************/
+ − 263 static int
+ − 264 gtk_divider_height (void)
+ − 265 {
+ − 266 return 2;
+ − 267 }
+ − 268
+ − 269 /*****************************************************************************
+ − 270 gtk_eol_cursor_width
+ − 271
+ − 272 Return the width of the end-of-line cursor. This is a function
+ − 273 because eol_cursor_width is a device method.
+ − 274 ****************************************************************************/
+ − 275 static int
+ − 276 gtk_eol_cursor_width (void)
+ − 277 {
+ − 278 return EOL_CURSOR_WIDTH;
+ − 279 }
+ − 280
+ − 281 /*****************************************************************************
+ − 282 gtk_output_display_block
+ − 283
+ − 284 Given a display line, a block number for that start line, output all
+ − 285 runes between start and end in the specified display block.
+ − 286 ****************************************************************************/
+ − 287 static void
+ − 288 gtk_output_display_block (struct window *w, struct display_line *dl, int block,
+ − 289 int start, int end, int start_pixpos, int cursor_start,
+ − 290 int cursor_width, int cursor_height)
+ − 291 {
+ − 292 struct frame *f = XFRAME (w->frame);
+ − 293 Emchar_dynarr *buf = Dynarr_new (Emchar);
+ − 294 Lisp_Object window;
+ − 295
+ − 296 struct display_block *db = Dynarr_atp (dl->display_blocks, block);
+ − 297 rune_dynarr *rba = db->runes;
+ − 298 struct rune *rb;
+ − 299
+ − 300 int elt = start;
+ − 301 face_index findex;
+ − 302 int xpos, width;
+ − 303 Lisp_Object charset = Qunbound; /* Qnil is a valid charset when
+ − 304 MULE is not defined */
+ − 305
+ − 306 XSETWINDOW (window, w);
+ − 307 rb = Dynarr_atp (rba, start);
+ − 308
+ − 309 if (!rb)
+ − 310 {
+ − 311 /* Nothing to do so don't do anything. */
+ − 312 return;
+ − 313 }
+ − 314 else
+ − 315 {
+ − 316 findex = rb->findex;
+ − 317 xpos = rb->xpos;
+ − 318 width = 0;
+ − 319 if (rb->type == RUNE_CHAR)
+ − 320 charset = CHAR_CHARSET (rb->object.chr.ch);
+ − 321 }
+ − 322
+ − 323 if (end < 0)
+ − 324 end = Dynarr_length (rba);
+ − 325 Dynarr_reset (buf);
+ − 326
+ − 327 while (elt < end)
+ − 328 {
+ − 329 rb = Dynarr_atp (rba, elt);
+ − 330
+ − 331 if (rb->findex == findex && rb->type == RUNE_CHAR
+ − 332 && rb->object.chr.ch != '\n' && rb->cursor_type != CURSOR_ON
+ − 333 && EQ (charset, CHAR_CHARSET (rb->object.chr.ch)))
+ − 334 {
+ − 335 Dynarr_add (buf, rb->object.chr.ch);
+ − 336 width += rb->width;
+ − 337 elt++;
+ − 338 }
+ − 339 else
+ − 340 {
+ − 341 if (Dynarr_length (buf))
+ − 342 {
+ − 343 gtk_output_string (w, dl, buf, xpos, 0, start_pixpos, width,
+ − 344 findex, 0, cursor_start, cursor_width,
+ − 345 cursor_height);
+ − 346 xpos = rb->xpos;
+ − 347 width = 0;
+ − 348 }
+ − 349 Dynarr_reset (buf);
+ − 350 width = 0;
+ − 351
+ − 352 if (rb->type == RUNE_CHAR)
+ − 353 {
+ − 354 findex = rb->findex;
+ − 355 xpos = rb->xpos;
+ − 356 charset = CHAR_CHARSET (rb->object.chr.ch);
+ − 357
+ − 358 if (rb->cursor_type == CURSOR_ON)
+ − 359 {
+ − 360 if (rb->object.chr.ch == '\n')
+ − 361 {
+ − 362 gtk_output_eol_cursor (w, dl, xpos, findex);
+ − 363 }
+ − 364 else
+ − 365 {
+ − 366 Dynarr_add (buf, rb->object.chr.ch);
+ − 367 gtk_output_string (w, dl, buf, xpos, 0, start_pixpos,
+ − 368 rb->width, findex, 1,
+ − 369 cursor_start, cursor_width,
+ − 370 cursor_height);
+ − 371 Dynarr_reset (buf);
+ − 372 }
+ − 373
+ − 374 xpos += rb->width;
+ − 375 elt++;
+ − 376 }
+ − 377 else if (rb->object.chr.ch == '\n')
+ − 378 {
+ − 379 /* Clear in case a cursor was formerly here. */
+ − 380 int height = dl->ascent + dl->descent - dl->clip;
+ − 381
+ − 382 redisplay_clear_region (window, findex, xpos, dl->ypos - dl->ascent,
+ − 383 rb->width, height);
+ − 384 elt++;
+ − 385 }
+ − 386 }
+ − 387 else if (rb->type == RUNE_BLANK || rb->type == RUNE_HLINE)
+ − 388 {
+ − 389 if (rb->type == RUNE_BLANK)
+ − 390 gtk_output_blank (w, dl, rb, start_pixpos, cursor_start,
+ − 391 cursor_width);
+ − 392 else
+ − 393 {
+ − 394 /* #### Our flagging of when we need to redraw the
+ − 395 modeline shadows sucks. Since RUNE_HLINE is only used
+ − 396 by the modeline at the moment it is a good bet
+ − 397 that if it gets redrawn then we should also
+ − 398 redraw the shadows. This won't be true forever.
+ − 399 We borrow the shadow_thickness_changed flag for
+ − 400 now. */
+ − 401 w->shadow_thickness_changed = 1;
+ − 402 gtk_output_hline (w, dl, rb);
+ − 403 }
+ − 404
+ − 405 elt++;
+ − 406 if (elt < end)
+ − 407 {
+ − 408 rb = Dynarr_atp (rba, elt);
+ − 409
+ − 410 findex = rb->findex;
+ − 411 xpos = rb->xpos;
+ − 412 }
+ − 413 }
+ − 414 else if (rb->type == RUNE_DGLYPH)
+ − 415 {
+ − 416 Lisp_Object instance;
+ − 417 struct display_box dbox;
+ − 418 struct display_glyph_area dga;
+ − 419 redisplay_calculate_display_boxes (dl, rb->xpos, rb->object.dglyph.xoffset,
+ − 420 start_pixpos, rb->width,
+ − 421 &dbox, &dga);
+ − 422
+ − 423 XSETWINDOW (window, w);
+ − 424 instance = glyph_image_instance (rb->object.dglyph.glyph,
+ − 425 window, ERROR_ME_NOT, 1);
+ − 426 findex = rb->findex;
+ − 427
+ − 428 if (IMAGE_INSTANCEP (instance))
+ − 429 switch (XIMAGE_INSTANCE_TYPE (instance))
+ − 430 {
+ − 431 case IMAGE_TEXT:
+ − 432 {
+ − 433 /* #### This is way losing. See the comment in
+ − 434 add_glyph_rune(). */
+ − 435 Lisp_Object string =
+ − 436 XIMAGE_INSTANCE_TEXT_STRING (instance);
+ − 437 convert_bufbyte_string_into_emchar_dynarr
+ − 438 (XSTRING_DATA (string), XSTRING_LENGTH (string), buf);
+ − 439
+ − 440 gtk_output_string (w, dl, buf, xpos,
+ − 441 rb->object.dglyph.xoffset,
+ − 442 start_pixpos, -1, findex,
+ − 443 (rb->cursor_type == CURSOR_ON),
+ − 444 cursor_start, cursor_width,
+ − 445 cursor_height);
+ − 446 Dynarr_reset (buf);
+ − 447 }
+ − 448 break;
+ − 449
+ − 450 case IMAGE_MONO_PIXMAP:
+ − 451 case IMAGE_COLOR_PIXMAP:
+ − 452 gtk_output_pixmap (w, dl, instance, xpos,
+ − 453 rb->object.dglyph.xoffset, start_pixpos,
+ − 454 rb->width, findex, cursor_start,
+ − 455 cursor_width, cursor_height);
+ − 456 break;
+ − 457
+ − 458 case IMAGE_POINTER:
+ − 459 abort ();
+ − 460
+ − 461 case IMAGE_WIDGET:
+ − 462 if (EQ (XIMAGE_INSTANCE_WIDGET_TYPE (instance),
+ − 463 Qlayout))
+ − 464 {
+ − 465 redisplay_output_layout (window, instance, &dbox,
+ − 466 &dga, findex,
+ − 467 cursor_start, cursor_width,
+ − 468 cursor_height);
+ − 469 break;
+ − 470 }
+ − 471
+ − 472 case IMAGE_SUBWINDOW:
+ − 473 redisplay_output_subwindow (w, instance, &dbox, &dga,
+ − 474 findex, cursor_start,
+ − 475 cursor_width, cursor_height);
+ − 476 break;
+ − 477
+ − 478 case IMAGE_NOTHING:
+ − 479 /* nothing is as nothing does */
+ − 480 break;
+ − 481
+ − 482 default:
+ − 483 abort ();
+ − 484 }
+ − 485
+ − 486 xpos += rb->width;
+ − 487 elt++;
+ − 488 }
+ − 489 else
+ − 490 abort ();
+ − 491 }
+ − 492 }
+ − 493
+ − 494 if (Dynarr_length (buf))
+ − 495 gtk_output_string (w, dl, buf, xpos, 0, start_pixpos, width, findex,
+ − 496 0, cursor_start, cursor_width, cursor_height);
+ − 497
+ − 498 /* #### This is really conditionalized well for optimized
+ − 499 performance. */
+ − 500 if (dl->modeline
+ − 501 && !EQ (Qzero, w->modeline_shadow_thickness)
+ − 502 && (f->clear
+ − 503 || f->windows_structure_changed
+ − 504 || w->shadow_thickness_changed))
+ − 505 gtk_bevel_modeline (w, dl);
+ − 506
+ − 507 Dynarr_free (buf);
+ − 508 }
+ − 509
+ − 510 /*****************************************************************************
+ − 511 gtk_bevel_modeline
+ − 512
+ − 513 Draw a 3d border around the modeline on window W.
+ − 514 ****************************************************************************/
+ − 515 static void
+ − 516 gtk_bevel_modeline (struct window *w, struct display_line *dl)
+ − 517 {
+ − 518 struct frame *f = XFRAME (w->frame);
+ − 519 int shadow_thickness = MODELINE_SHADOW_THICKNESS (w);
+ − 520 int x,y, width, height;
+ − 521
+ − 522 x = WINDOW_MODELINE_LEFT (w);
+ − 523 width = WINDOW_MODELINE_RIGHT (w) - x;
+ − 524 y = dl->ypos - dl->ascent - shadow_thickness;
+ − 525 height = dl->ascent + dl->descent + 2 * shadow_thickness;
+ − 526
+ − 527 gtk_output_shadows (f, x, y, width, height, shadow_thickness);
+ − 528 }
+ − 529
+ − 530 /*****************************************************************************
+ − 531 gtk_get_gc
+ − 532
+ − 533 Given a number of parameters return a GC with those properties.
+ − 534 ****************************************************************************/
+ − 535 GdkGC *
+ − 536 gtk_get_gc (struct device *d, Lisp_Object font, Lisp_Object fg, Lisp_Object bg,
+ − 537 Lisp_Object bg_pmap, Lisp_Object lwidth)
+ − 538 {
+ − 539 GdkGCValues gcv;
+ − 540 unsigned long mask;
+ − 541
+ − 542 memset (&gcv, ~0, sizeof (gcv));
+ − 543 gcv.graphics_exposures = FALSE;
+ − 544 /* Make absolutely sure that we don't pick up a clipping region in
+ − 545 the GC returned by this function. */
+ − 546 gcv.clip_mask = 0;
+ − 547 gcv.clip_x_origin = 0;
+ − 548 gcv.clip_y_origin = 0;
+ − 549 gcv.fill = GDK_SOLID;
+ − 550 mask = GDK_GC_EXPOSURES | GDK_GC_CLIP_MASK | GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN;
+ − 551 mask |= GDK_GC_FILL;
+ − 552
+ − 553 if (!NILP (font))
+ − 554 {
+ − 555 gcv.font = FONT_INSTANCE_GTK_FONT (XFONT_INSTANCE (font));
+ − 556 mask |= GDK_GC_FONT;
+ − 557 }
+ − 558
+ − 559 /* evil kludge! */
+ − 560 if (!NILP (fg) && !COLOR_INSTANCEP (fg) && !INTP (fg))
+ − 561 {
+ − 562 /* #### I fixed once case where this was getting it. It was a
+ − 563 bad macro expansion (compiler bug). */
+ − 564 fprintf (stderr, "Help! gtk_get_gc got a bogus fg value! fg = ");
+ − 565 debug_print (fg);
+ − 566 fg = Qnil;
+ − 567 }
+ − 568
+ − 569 if (!NILP (fg))
+ − 570 {
+ − 571 if (COLOR_INSTANCEP (fg))
+ − 572 gcv.foreground = * COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (fg));
+ − 573 else
+ − 574 gcv.foreground.pixel = XINT (fg);
+ − 575 mask |= GDK_GC_FOREGROUND;
+ − 576 }
+ − 577
+ − 578 if (!NILP (bg))
+ − 579 {
+ − 580 if (COLOR_INSTANCEP (bg))
+ − 581 gcv.background = * COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (bg));
+ − 582 else
+ − 583 gcv.background.pixel = XINT (fg);
+ − 584 mask |= GDK_GC_BACKGROUND;
+ − 585 }
+ − 586
+ − 587 if (IMAGE_INSTANCEP (bg_pmap)
+ − 588 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
+ − 589 {
+ − 590 if (XIMAGE_INSTANCE_PIXMAP_DEPTH (bg_pmap) == 0)
+ − 591 {
+ − 592 gcv.fill = GDK_OPAQUE_STIPPLED;
+ − 593 gcv.stipple = XIMAGE_INSTANCE_GTK_PIXMAP (bg_pmap);
+ − 594 mask |= (GDK_GC_STIPPLE | GDK_GC_FILL);
+ − 595 }
+ − 596 else
+ − 597 {
+ − 598 gcv.fill = GDK_TILED;
+ − 599 gcv.tile = XIMAGE_INSTANCE_GTK_PIXMAP (bg_pmap);
+ − 600 mask |= (GDK_GC_TILE | GDK_GC_FILL);
+ − 601 }
+ − 602 }
+ − 603
+ − 604 if (!NILP (lwidth))
+ − 605 {
+ − 606 gcv.line_width = XINT (lwidth);
+ − 607 mask |= GDK_GC_LINE_WIDTH;
+ − 608 }
+ − 609
+ − 610 return gc_cache_lookup (DEVICE_GTK_GC_CACHE (d), &gcv, mask);
+ − 611 }
+ − 612
+ − 613 /*****************************************************************************
+ − 614 gtk_output_string
+ − 615
+ − 616 Given a string and a starting position, output that string in the
+ − 617 given face. If cursor is true, draw a cursor around the string.
+ − 618 Correctly handles multiple charsets in the string.
+ − 619
+ − 620 The meaning of the parameters is something like this:
+ − 621
+ − 622 W Window that the text is to be displayed in.
+ − 623 DL Display line that this text is on. The values in the
+ − 624 structure are used to determine the vertical position and
+ − 625 clipping range of the text.
+ − 626 BUF Dynamic array of Emchars specifying what is actually to be
+ − 627 drawn.
+ − 628 XPOS X position in pixels where the text should start being drawn.
+ − 629 XOFFSET Number of pixels to be chopped off the left side of the
+ − 630 text. The effect is as if the text were shifted to the
+ − 631 left this many pixels and clipped at XPOS.
+ − 632 CLIP_START Clip everything left of this X position.
+ − 633 WIDTH Clip everything right of XPOS + WIDTH.
+ − 634 FINDEX Index for the face cache element describing how to display
+ − 635 the text.
+ − 636 CURSOR #### I don't understand this. There's something
+ − 637 strange and overcomplexified with this variable.
+ − 638 Chuck, explain please?
+ − 639 CURSOR_START Starting X position of cursor.
+ − 640 CURSOR_WIDTH Width of cursor in pixels.
+ − 641 CURSOR_HEIGHT Height of cursor in pixels.
+ − 642
+ − 643 Starting Y position of cursor is the top of the text line.
+ − 644 The cursor is drawn sometimes whether or not CURSOR is set. ???
+ − 645 ****************************************************************************/
+ − 646 void
+ − 647 gdk_draw_text_image (GdkDrawable *drawable,
+ − 648 GdkFont *font,
+ − 649 GdkGC *gc,
+ − 650 gint x,
+ − 651 gint y,
+ − 652 const gchar *text,
+ − 653 gint text_length);
+ − 654
+ − 655 void
+ − 656 gtk_output_string (struct window *w, struct display_line *dl,
+ − 657 Emchar_dynarr *buf, int xpos, int xoffset, int clip_start,
+ − 658 int width, face_index findex, int cursor,
+ − 659 int cursor_start, int cursor_width, int cursor_height)
+ − 660 {
+ − 661 /* General variables */
+ − 662 struct frame *f = XFRAME (w->frame);
+ − 663 struct device *d = XDEVICE (f->device);
+ − 664 Lisp_Object device;
+ − 665 Lisp_Object window;
+ − 666 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 667
+ − 668 int clip_end;
+ − 669
+ − 670 /* Cursor-related variables */
+ − 671 int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d));
+ − 672 int cursor_clip;
+ − 673 Lisp_Object bar_cursor_value = symbol_value_in_buffer (Qbar_cursor,
+ − 674 WINDOW_BUFFER (w));
+ − 675 struct face_cachel *cursor_cachel = 0;
+ − 676
+ − 677 /* Text-related variables */
+ − 678 Lisp_Object bg_pmap;
+ − 679 GdkGC *bgc, *gc;
+ − 680 int height;
+ − 681 int len = Dynarr_length (buf);
+ − 682 unsigned char *text_storage = (unsigned char *) alloca (2 * len);
+ − 683 struct textual_run *runs = alloca_array (struct textual_run, len);
+ − 684 int nruns;
+ − 685 int i;
+ − 686 struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, findex);
+ − 687
+ − 688 XSETDEVICE (device, d);
+ − 689 XSETWINDOW (window, w);
+ − 690
+ − 691 if (width < 0)
+ − 692 width = gtk_text_width (f, cachel, Dynarr_atp (buf, 0), Dynarr_length (buf));
+ − 693 height = dl->ascent + dl->descent - dl->clip;
+ − 694
+ − 695 /* Regularize the variables passed in. */
+ − 696
+ − 697 if (clip_start < xpos)
+ − 698 clip_start = xpos;
+ − 699 clip_end = xpos + width;
+ − 700 if (clip_start >= clip_end)
+ − 701 /* It's all clipped out. */
+ − 702 return;
+ − 703
+ − 704 xpos -= xoffset;
+ − 705
+ − 706 nruns = separate_textual_runs (text_storage, runs, Dynarr_atp (buf, 0),
+ − 707 Dynarr_length (buf));
+ − 708
+ − 709 cursor_clip = (cursor_start >= clip_start &&
+ − 710 cursor_start < clip_end);
+ − 711
+ − 712 /* This cursor code is really a mess. */
+ − 713 if (!NILP (w->text_cursor_visible_p)
+ − 714 && (cursor
+ − 715 || cursor_clip
+ − 716 || (cursor_width
+ − 717 && (cursor_start + cursor_width >= clip_start)
+ − 718 && !NILP (bar_cursor_value))))
+ − 719 {
+ − 720 /* These have to be in separate statements in order to avoid a
+ − 721 compiler bug. */
+ − 722 face_index sucks = get_builtin_face_cache_index (w, Vtext_cursor_face);
+ − 723 cursor_cachel = WINDOW_FACE_CACHEL (w, sucks);
+ − 724
+ − 725 /* We have to reset this since any call to WINDOW_FACE_CACHEL
+ − 726 may cause the cache to resize and any pointers to it to
+ − 727 become invalid. */
+ − 728 cachel = WINDOW_FACE_CACHEL (w, findex);
+ − 729 }
+ − 730
+ − 731 bg_pmap = cachel->background_pixmap;
+ − 732 if (!IMAGE_INSTANCEP (bg_pmap)
+ − 733 || !IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
+ − 734 bg_pmap = Qnil;
+ − 735
+ − 736 if ((cursor && focus && NILP (bar_cursor_value)
+ − 737 && !NILP (w->text_cursor_visible_p)) || NILP (bg_pmap))
+ − 738 bgc = 0;
+ − 739 else
+ − 740 bgc = gtk_get_gc (d, Qnil, cachel->foreground, cachel->background,
+ − 741 bg_pmap, Qnil);
+ − 742
+ − 743 if (bgc)
+ − 744 gdk_draw_rectangle (GDK_DRAWABLE (x_win), bgc, TRUE, clip_start,
+ − 745 dl->ypos - dl->ascent, clip_end - clip_start,
+ − 746 height);
+ − 747
+ − 748 for (i = 0; i < nruns; i++)
+ − 749 {
+ − 750 Lisp_Object font = FACE_CACHEL_FONT (cachel, runs[i].charset);
+ − 751 struct Lisp_Font_Instance *fi = XFONT_INSTANCE (font);
+ − 752 GdkFont *gdk_font = FONT_INSTANCE_GTK_FONT (fi);
+ − 753 int this_width;
+ − 754 int need_clipping;
+ − 755
+ − 756 if (EQ (font, Vthe_null_font_instance))
+ − 757 continue;
+ − 758
+ − 759 this_width = gtk_text_width_single_run (cachel, runs + i);
+ − 760 need_clipping = (dl->clip || clip_start > xpos ||
+ − 761 clip_end < xpos + this_width);
+ − 762
+ − 763 /* XDrawImageString only clears the area equal to the height of
+ − 764 the given font. It is possible that a font is being displayed
+ − 765 on a line taller than it is, so this would cause us to fail to
+ − 766 clear some areas. */
+ − 767 if ((int) fi->height < (int) (height + dl->clip))
+ − 768 {
+ − 769 int clear_start = max (xpos, clip_start);
+ − 770 int clear_end = min (xpos + this_width, clip_end);
+ − 771
+ − 772 if (cursor)
+ − 773 {
+ − 774 int ypos1_line, ypos1_string, ypos2_line, ypos2_string;
+ − 775
+ − 776 ypos1_string = dl->ypos - fi->ascent;
+ − 777 ypos2_string = dl->ypos + fi->descent;
+ − 778 ypos1_line = dl->ypos - dl->ascent;
+ − 779 ypos2_line = dl->ypos + dl->descent - dl->clip;
+ − 780
+ − 781 /* Make sure we don't clear below the real bottom of the
+ − 782 line. */
+ − 783 if (ypos1_string > ypos2_line)
+ − 784 ypos1_string = ypos2_line;
+ − 785 if (ypos2_string > ypos2_line)
+ − 786 ypos2_string = ypos2_line;
+ − 787
+ − 788 if (ypos1_line < ypos1_string)
+ − 789 {
+ − 790 redisplay_clear_region (window, findex, clear_start, ypos1_line,
+ − 791 clear_end - clear_start,
+ − 792 ypos1_string - ypos1_line);
+ − 793 }
+ − 794
+ − 795 if (ypos2_line > ypos2_string)
+ − 796 {
+ − 797 redisplay_clear_region (window, findex, clear_start, ypos2_string,
+ − 798 clear_end - clear_start,
+ − 799 ypos2_line - ypos2_string);
+ − 800 }
+ − 801 }
+ − 802 else
+ − 803 {
+ − 804 redisplay_clear_region (window, findex, clear_start,
+ − 805 dl->ypos - dl->ascent, clear_end - clear_start,
+ − 806 height);
+ − 807 }
+ − 808 }
+ − 809
+ − 810 if (cursor && cursor_cachel && focus && NILP (bar_cursor_value))
+ − 811 {
+ − 812 gc = gtk_get_gc (d, font, cursor_cachel->foreground,
+ − 813 cursor_cachel->background, Qnil, Qnil);
+ − 814 }
+ − 815 else
+ − 816 {
+ − 817 gc = gtk_get_gc (d, font, cachel->foreground, cachel->background,
+ − 818 Qnil, Qnil);
+ − 819 }
+ − 820
+ − 821 if (need_clipping)
+ − 822 {
+ − 823 GdkRectangle clip_box;
+ − 824
+ − 825 clip_box.x = 0;
+ − 826 clip_box.y = 0;
+ − 827 clip_box.width = clip_end - clip_start;
+ − 828 clip_box.height = height;
+ − 829
+ − 830 gdk_gc_set_clip_rectangle (gc, &clip_box);
+ − 831 gdk_gc_set_clip_origin (gc, clip_start, dl->ypos - dl->ascent);
+ − 832 }
+ − 833
+ − 834 /* The X specific called different functions (XDraw*String
+ − 835 vs. XDraw*String16), but apparently gdk_draw_text takes care
+ − 836 of that for us.
+ − 837
+ − 838 BUT, gdk_draw_text also does too much, by dividing the length
+ − 839 by 2. So we fake them out my multiplying the length by the
+ − 840 dimension of the text. This will do the right thing for
+ − 841 single-dimension runs as well of course.
+ − 842 */
+ − 843 (bgc ? gdk_draw_text : gdk_draw_text_image) (GDK_DRAWABLE (x_win), gdk_font, gc, xpos,
+ − 844 dl->ypos, (char *) runs[i].ptr,
+ − 845 runs[i].len * runs[i].dimension);
+ − 846
+ − 847 /* We draw underlines in the same color as the text. */
+ − 848 if (cachel->underline)
+ − 849 {
+ − 850 unsigned long upos, uthick;
+ − 851
+ − 852 /* Cannot get at font properties in Gtk, so we resort to
+ − 853 guessing */
+ − 854 upos = dl->descent / 2;
+ − 855 uthick = 1;
+ − 856
+ − 857 if (dl->ypos + upos < dl->ypos + dl->descent - dl->clip)
+ − 858 {
+ − 859 if (dl->ypos + upos + uthick > dl->ypos + dl->descent - dl->clip)
+ − 860 uthick = dl->descent - dl->clip - upos;
+ − 861
+ − 862 if (uthick == 1)
+ − 863 {
+ − 864 gdk_draw_line (GDK_DRAWABLE (x_win), gc, xpos, dl->ypos + upos,
+ − 865 xpos + this_width, dl->ypos + upos);
+ − 866 }
+ − 867 else if (uthick > 1)
+ − 868 {
+ − 869 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, xpos,
+ − 870 dl->ypos + upos, this_width, uthick);
+ − 871 }
+ − 872 }
+ − 873 }
+ − 874
+ − 875 if (cachel->strikethru) {
+ − 876 unsigned long ascent,descent,upos, uthick;
+ − 877 GdkFont *gfont = FONT_INSTANCE_GTK_FONT (XFONT_INSTANCE (font));
+ − 878
+ − 879 /* Cannot get at font properties in Gtk, so we resort to
+ − 880 guessing */
+ − 881
+ − 882 ascent = gfont->ascent;
+ − 883 descent = gfont->descent;
+ − 884 uthick = 1;
+ − 885
+ − 886 upos = ascent - ((ascent + descent) / 2) + 1;
+ − 887
+ − 888 /* Generally, upos will be positive (above the baseline),so subtract */
+ − 889 if (dl->ypos - upos < dl->ypos + dl->descent - dl->clip)
+ − 890 {
+ − 891 if (dl->ypos - upos + uthick > dl->ypos + dl->descent - dl->clip)
+ − 892 uthick = dl->descent - dl->clip + upos;
+ − 893
+ − 894 if (uthick == 1)
+ − 895 {
+ − 896 gdk_draw_line (GDK_DRAWABLE (x_win), gc, xpos, dl->ypos - upos,
+ − 897 xpos + this_width, dl->ypos - upos);
+ − 898 }
+ − 899 else if (uthick > 1)
+ − 900 {
+ − 901 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, xpos, dl->ypos + upos,
+ − 902 this_width, uthick);
+ − 903 }
+ − 904 }
+ − 905 }
+ − 906
+ − 907 /* Restore the GC */
+ − 908 if (need_clipping)
+ − 909 {
+ − 910 gdk_gc_set_clip_rectangle (gc, NULL);
+ − 911 gdk_gc_set_clip_origin (gc, 0, 0);
+ − 912 }
+ − 913
+ − 914 /* If we are actually superimposing the cursor then redraw with just
+ − 915 the appropriate section highlighted. */
+ − 916 if (cursor_clip && !cursor && focus && cursor_cachel)
+ − 917 {
+ − 918 GdkGC *cgc;
+ − 919 GdkRectangle clip_box;
+ − 920
+ − 921 cgc = gtk_get_gc (d, font, cursor_cachel->foreground,
+ − 922 cursor_cachel->background, Qnil, Qnil);
+ − 923
+ − 924 clip_box.x = 0;
+ − 925 clip_box.y = 0;
+ − 926 clip_box.width = cursor_width;
+ − 927 clip_box.height = height;
+ − 928
+ − 929 gdk_gc_set_clip_rectangle (cgc, &clip_box);
+ − 930 gdk_gc_set_clip_origin (cgc, cursor_start, dl->ypos - dl->ascent);
+ − 931
+ − 932 /* The X specific called different functions (XDraw*String
+ − 933 vs. XDraw*String16), but apparently gdk_draw_text takes care
+ − 934 of that for us.
+ − 935
+ − 936 BUT, gdk_draw_text also does too much, by dividing the
+ − 937 length by 2. So we fake them out my multiplying the
+ − 938 length by the dimension of the text. This will do the
+ − 939 right thing for single-dimension runs as well of course.
+ − 940 */
+ − 941 gdk_draw_text_image (GDK_DRAWABLE (x_win), gdk_font, cgc, xpos,
+ − 942 dl->ypos, (char *) runs[i].ptr,
+ − 943 runs[i].len * runs[i].dimension);
+ − 944
+ − 945 gdk_gc_set_clip_rectangle (cgc, NULL);
+ − 946 gdk_gc_set_clip_origin (cgc, 0, 0);
+ − 947 }
+ − 948
+ − 949 xpos += this_width;
+ − 950 }
+ − 951
+ − 952 /* Draw the non-focus box or bar-cursor as needed. */
+ − 953 /* Can't this logic be simplified? */
+ − 954 if (cursor_cachel
+ − 955 && ((cursor && !focus && NILP (bar_cursor_value))
+ − 956 || (cursor_width
+ − 957 && (cursor_start + cursor_width >= clip_start)
+ − 958 && !NILP (bar_cursor_value))))
+ − 959 {
+ − 960 int tmp_height, tmp_y;
+ − 961 int bar_width = EQ (bar_cursor_value, Qt) ? 1 : 2;
+ − 962 int need_clipping = (cursor_start < clip_start
+ − 963 || clip_end < cursor_start + cursor_width);
+ − 964
+ − 965 /* #### This value is correct (as far as I know) because
+ − 966 all of the times we need to draw this cursor, we will
+ − 967 be called with exactly one character, so we know we
+ − 968 can always use runs[0].
+ − 969
+ − 970 This is bogus as all hell, however. The cursor handling in
+ − 971 this function is way bogus and desperately needs to be
+ − 972 cleaned up. (In particular, the drawing of the cursor should
+ − 973 really really be separated out of this function. This may be
+ − 974 a bit tricky now because this function itself does way too
+ − 975 much stuff, a lot of which needs to be moved into
+ − 976 redisplay.c) This is the only way to be able to easily add
+ − 977 new cursor types or (e.g.) make the bar cursor be able to
+ − 978 span two characters instead of overlaying just one. */
+ − 979 int bogusly_obtained_ascent_value =
+ − 980 XFONT_INSTANCE (FACE_CACHEL_FONT (cachel, runs[0].charset))->ascent;
+ − 981
+ − 982 if (!NILP (bar_cursor_value))
+ − 983 {
+ − 984 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil,
+ − 985 make_int (bar_width));
+ − 986 }
+ − 987 else
+ − 988 {
+ − 989 gc = gtk_get_gc (d, Qnil, cursor_cachel->background,
+ − 990 Qnil, Qnil, Qnil);
+ − 991 }
+ − 992
+ − 993 tmp_y = dl->ypos - bogusly_obtained_ascent_value;
+ − 994 tmp_height = cursor_height;
+ − 995 if (tmp_y + tmp_height > (int) (dl->ypos - dl->ascent + height))
+ − 996 {
+ − 997 tmp_y = dl->ypos - dl->ascent + height - tmp_height;
+ − 998 if (tmp_y < (int) (dl->ypos - dl->ascent))
+ − 999 tmp_y = dl->ypos - dl->ascent;
+ − 1000 tmp_height = dl->ypos - dl->ascent + height - tmp_y;
+ − 1001 }
+ − 1002
+ − 1003 if (need_clipping)
+ − 1004 {
+ − 1005 GdkRectangle clip_box;
+ − 1006 clip_box.x = 0;
+ − 1007 clip_box.y = 0;
+ − 1008 clip_box.width = clip_end - clip_start;
+ − 1009 clip_box.height = tmp_height;
+ − 1010
+ − 1011 gdk_gc_set_clip_rectangle (gc, &clip_box);
+ − 1012 gdk_gc_set_clip_origin (gc, clip_start, tmp_y);
+ − 1013 }
+ − 1014
+ − 1015 if (!focus && NILP (bar_cursor_value))
+ − 1016 {
+ − 1017 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, FALSE,
+ − 1018 cursor_start, tmp_y,
+ − 1019 cursor_width - 1, tmp_height - 1);
+ − 1020 }
+ − 1021 else if (focus && !NILP (bar_cursor_value))
+ − 1022 {
+ − 1023 gdk_draw_line (GDK_DRAWABLE (x_win), gc,
+ − 1024 cursor_start + bar_width - 1, tmp_y,
+ − 1025 cursor_start + bar_width - 1, tmp_y + tmp_height - 1);
+ − 1026 }
+ − 1027
+ − 1028 /* Restore the GC */
+ − 1029 if (need_clipping)
+ − 1030 {
+ − 1031 gdk_gc_set_clip_rectangle (gc, NULL);
+ − 1032 gdk_gc_set_clip_origin (gc, 0, 0);
+ − 1033 }
+ − 1034 }
+ − 1035 }
+ − 1036
+ − 1037 static void
+ − 1038 our_draw_bitmap (GdkDrawable *drawable,
+ − 1039 GdkGC *gc,
+ − 1040 GdkPixmap *src,
+ − 1041 gint xsrc,
+ − 1042 gint ysrc,
+ − 1043 gint xdest,
+ − 1044 gint ydest,
+ − 1045 gint width,
+ − 1046 gint height);
+ − 1047
+ − 1048 void
+ − 1049 gtk_output_gdk_pixmap (struct frame *f, struct Lisp_Image_Instance *p, int x,
+ − 1050 int y, int clip_x, int clip_y, int clip_width,
+ − 1051 int clip_height, int width, int height, int pixmap_offset,
+ − 1052 GdkColor *fg, GdkColor *bg, GdkGC *override_gc)
+ − 1053 {
+ − 1054 struct device *d = XDEVICE (f->device);
+ − 1055 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1056
+ − 1057 GdkGC *gc;
+ − 1058 GdkGCValues gcv;
+ − 1059 unsigned long pixmap_mask;
+ − 1060 int need_clipping = (clip_x || clip_y);
+ − 1061
+ − 1062 if (!override_gc)
+ − 1063 {
+ − 1064 memset (&gcv, ~0, sizeof (gcv));
+ − 1065 gcv.graphics_exposures = FALSE;
+ − 1066 gcv.foreground = *fg;
+ − 1067 gcv.background = *bg;
+ − 1068 pixmap_mask = GDK_GC_FOREGROUND | GDK_GC_BACKGROUND | GDK_GC_EXPOSURES;
+ − 1069
+ − 1070 if (IMAGE_INSTANCE_GTK_MASK (p))
+ − 1071 {
+ − 1072 gcv.function = GDK_COPY;
+ − 1073 gcv.clip_mask = IMAGE_INSTANCE_GTK_MASK (p);
+ − 1074 gcv.clip_x_origin = x;
+ − 1075 gcv.clip_y_origin = y - pixmap_offset;
+ − 1076 pixmap_mask |= (GDK_GC_FUNCTION | GDK_GC_CLIP_MASK | GDK_GC_CLIP_X_ORIGIN |
+ − 1077 GDK_GC_CLIP_Y_ORIGIN);
+ − 1078 /* Can't set a clip rectangle below because we already have a mask.
+ − 1079 We could conceivably create a new clipmask by zeroing out
+ − 1080 everything outside the clip region. Is it worth it?
+ − 1081 Is it possible to get an equivalent effect by changing the
+ − 1082 args to XCopyArea below rather than messing with a clip box?
+ − 1083 - dkindred@cs.cmu.edu */
+ − 1084 need_clipping = 0;
+ − 1085 }
+ − 1086
+ − 1087 gc = gc_cache_lookup (DEVICE_GTK_GC_CACHE (d), &gcv, pixmap_mask);
+ − 1088 }
+ − 1089 else
+ − 1090 {
+ − 1091 gc = override_gc;
+ − 1092 /* override_gc might have a mask already--we don't want to nuke it.
+ − 1093 Maybe we can insist that override_gc have no mask, or use
+ − 1094 one of the suggestions above. */
+ − 1095 need_clipping = 0;
+ − 1096 }
+ − 1097
+ − 1098 if (need_clipping)
+ − 1099 {
+ − 1100 GdkRectangle clip_box;
+ − 1101
+ − 1102 clip_box.x = clip_x;
+ − 1103 clip_box.y = clip_y;
+ − 1104 clip_box.width = clip_width;
+ − 1105 clip_box.height = clip_height;
+ − 1106
+ − 1107 gdk_gc_set_clip_rectangle (gc, &clip_box);
+ − 1108 gdk_gc_set_clip_origin (gc, x, y);
+ − 1109 }
+ − 1110
+ − 1111 if (IMAGE_INSTANCE_PIXMAP_DEPTH (p) > 0)
+ − 1112 {
+ − 1113 gdk_draw_pixmap (GDK_DRAWABLE (x_win), gc,
+ − 1114 IMAGE_INSTANCE_GTK_PIXMAP (p),
+ − 1115 0, pixmap_offset, x, y, width, height);
+ − 1116 }
+ − 1117 else
+ − 1118 {
+ − 1119 our_draw_bitmap (GDK_DRAWABLE (x_win), gc,
+ − 1120 IMAGE_INSTANCE_GTK_PIXMAP (p),
+ − 1121 0, pixmap_offset, x, y, width, height);
+ − 1122 }
+ − 1123
+ − 1124 if (need_clipping)
+ − 1125 {
+ − 1126 gdk_gc_set_clip_rectangle (gc, NULL);
+ − 1127 gdk_gc_set_clip_origin (gc, 0, 0);
+ − 1128 }
+ − 1129 }
+ − 1130
+ − 1131 static void
+ − 1132 gtk_output_pixmap (struct window *w, struct display_line *dl,
+ − 1133 Lisp_Object image_instance, int xpos, int xoffset,
+ − 1134 int start_pixpos, int width, face_index findex,
+ − 1135 int cursor_start, int cursor_width, int cursor_height)
+ − 1136 {
+ − 1137 struct frame *f = XFRAME (w->frame);
+ − 1138 struct device *d = XDEVICE (f->device);
+ − 1139 struct Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
+ − 1140 Lisp_Object window;
+ − 1141
+ − 1142 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1143 int lheight = dl->ascent + dl->descent - dl->clip;
+ − 1144 int pheight = ((int) IMAGE_INSTANCE_PIXMAP_HEIGHT (p) > lheight ? lheight :
+ − 1145 IMAGE_INSTANCE_PIXMAP_HEIGHT (p));
+ − 1146 int pwidth = min (width + xoffset, (int) IMAGE_INSTANCE_PIXMAP_WIDTH (p));
+ − 1147 int clip_x, clip_y, clip_width, clip_height;
+ − 1148
+ − 1149 /* The pixmap_offset is used to center the pixmap on lines which are
+ − 1150 shorter than it is. This results in odd effects when scrolling
+ − 1151 pixmaps off of the bottom. Let's try not using it. */
+ − 1152 #if 0
+ − 1153 int pixmap_offset = (int) (IMAGE_INSTANCE_PIXMAP_HEIGHT (p) - lheight) / 2;
+ − 1154 #else
+ − 1155 int pixmap_offset = 0;
+ − 1156 #endif
+ − 1157
+ − 1158 XSETWINDOW (window, w);
+ − 1159
+ − 1160 if ((start_pixpos >= 0 && start_pixpos > xpos) || xoffset)
+ − 1161 {
+ − 1162 if (start_pixpos > xpos && start_pixpos > xpos + width)
+ − 1163 return;
+ − 1164
+ − 1165 clip_x = xoffset;
+ − 1166 clip_width = width;
+ − 1167 if (start_pixpos > xpos)
+ − 1168 {
+ − 1169 clip_x += (start_pixpos - xpos);
+ − 1170 clip_width -= (start_pixpos - xpos);
+ − 1171 }
+ − 1172 }
+ − 1173 else
+ − 1174 {
+ − 1175 clip_x = 0;
+ − 1176 clip_width = 0;
+ − 1177 }
+ − 1178
+ − 1179 /* Place markers for possible future functionality (clipping the top
+ − 1180 half instead of the bottom half; think pixel scrolling). */
+ − 1181 clip_y = 0;
+ − 1182 clip_height = pheight;
+ − 1183
+ − 1184 /* Clear the area the pixmap is going into. The pixmap itself will
+ − 1185 always take care of the full width. We don't want to clear where
+ − 1186 it is going to go in order to avoid flicker. So, all we have to
+ − 1187 take care of is any area above or below the pixmap. */
+ − 1188 /* #### We take a shortcut for now. We know that since we have
+ − 1189 pixmap_offset hardwired to 0 that the pixmap is against the top
+ − 1190 edge so all we have to worry about is below it. */
+ − 1191 /* #### Unless the pixmap has a mask in which case we have to clear
+ − 1192 the whole damn thing since we can't yet clear just the area not
+ − 1193 included in the mask. */
+ − 1194 if (((int) (dl->ypos - dl->ascent + pheight) <
+ − 1195 (int) (dl->ypos + dl->descent - dl->clip))
+ − 1196 || IMAGE_INSTANCE_GTK_MASK (p))
+ − 1197 {
+ − 1198 int clear_x, clear_y, clear_width, clear_height;
+ − 1199
+ − 1200 if (IMAGE_INSTANCE_GTK_MASK (p))
+ − 1201 {
+ − 1202 clear_y = dl->ypos - dl->ascent;
+ − 1203 clear_height = lheight;
+ − 1204 }
+ − 1205 else
+ − 1206 {
+ − 1207 clear_y = dl->ypos - dl->ascent + pheight;
+ − 1208 clear_height = lheight - pheight;
+ − 1209 }
+ − 1210
+ − 1211 if (start_pixpos >= 0 && start_pixpos > xpos)
+ − 1212 {
+ − 1213 clear_x = start_pixpos;
+ − 1214 clear_width = xpos + width - start_pixpos;
+ − 1215 }
+ − 1216 else
+ − 1217 {
+ − 1218 clear_x = xpos;
+ − 1219 clear_width = width;
+ − 1220 }
+ − 1221
+ − 1222 redisplay_clear_region (window, findex, clear_x, clear_y,
+ − 1223 clear_width, clear_height);
+ − 1224 }
+ − 1225
+ − 1226 /* Output the pixmap. */
+ − 1227 {
+ − 1228 Lisp_Object tmp_pixel;
+ − 1229 GdkColor *tmp_bcolor, *tmp_fcolor;
+ − 1230
+ − 1231 tmp_pixel = WINDOW_FACE_CACHEL_FOREGROUND (w, findex);
+ − 1232 tmp_fcolor = COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (tmp_pixel));
+ − 1233 tmp_pixel = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
+ − 1234 tmp_bcolor = COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (tmp_pixel));
+ − 1235
+ − 1236 gtk_output_gdk_pixmap (f, p, xpos - xoffset, dl->ypos - dl->ascent, clip_x,
+ − 1237 clip_y, clip_width, clip_height,
+ − 1238 pwidth, pheight, pixmap_offset,
+ − 1239 tmp_fcolor, tmp_bcolor, 0);
+ − 1240 }
+ − 1241
+ − 1242 /* Draw a cursor over top of the pixmap. */
+ − 1243 if (cursor_width && cursor_height && (cursor_start >= xpos)
+ − 1244 && !NILP (w->text_cursor_visible_p)
+ − 1245 && (cursor_start < xpos + pwidth))
+ − 1246 {
+ − 1247 GdkGC *gc;
+ − 1248 int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d));
+ − 1249 int y = dl->ypos - dl->ascent;
+ − 1250 struct face_cachel *cursor_cachel =
+ − 1251 WINDOW_FACE_CACHEL (w,
+ − 1252 get_builtin_face_cache_index
+ − 1253 (w, Vtext_cursor_face));
+ − 1254
+ − 1255 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil);
+ − 1256
+ − 1257 if (cursor_width > xpos + pwidth - cursor_start)
+ − 1258 cursor_width = xpos + pwidth - cursor_start;
+ − 1259
+ − 1260 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, focus ? TRUE : FALSE,
+ − 1261 cursor_start, y, cursor_width,
+ − 1262 cursor_height);
+ − 1263 }
+ − 1264 }
+ − 1265
+ − 1266 /*****************************************************************************
+ − 1267 gtk_output_vertical_divider
+ − 1268
+ − 1269 Draw a vertical divider down the right side of the given window.
+ − 1270 ****************************************************************************/
+ − 1271 static void
+ − 1272 gtk_output_vertical_divider (struct window *w, int clear)
+ − 1273 {
+ − 1274 struct frame *f = XFRAME (w->frame);
+ − 1275 struct device *d = XDEVICE (f->device);
+ − 1276 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1277 GdkGC *background_gc;
+ − 1278 Lisp_Object tmp_pixel;
+ − 1279 GdkGCValues gcv;
+ − 1280 unsigned long mask;
+ − 1281 int x, y1, y2, width, shadow_thickness, spacing, line_width;
+ − 1282 face_index div_face = get_builtin_face_cache_index (w, Vvertical_divider_face);
+ − 1283
+ − 1284 width = window_divider_width (w);
+ − 1285 shadow_thickness = XINT (w->vertical_divider_shadow_thickness);
+ − 1286 spacing = XINT (w->vertical_divider_spacing);
+ − 1287 line_width = XINT (w->vertical_divider_line_width);
+ − 1288 x = WINDOW_RIGHT (w) - width;
+ − 1289 y1 = WINDOW_TOP (w);
+ − 1290 y2 = WINDOW_BOTTOM (w);
+ − 1291
+ − 1292 memset (&gcv, ~0, sizeof (gcv));
+ − 1293
+ − 1294 tmp_pixel = WINDOW_FACE_CACHEL_BACKGROUND (w, div_face);
+ − 1295
+ − 1296 gcv.background = * COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (tmp_pixel));
+ − 1297 gcv.foreground = gcv.background;
+ − 1298 gcv.graphics_exposures = FALSE;
+ − 1299 mask = GDK_GC_FOREGROUND | GDK_GC_BACKGROUND | GDK_GC_EXPOSURES;
+ − 1300
+ − 1301 background_gc = gc_cache_lookup (DEVICE_GTK_GC_CACHE (d), &gcv, mask);
+ − 1302
+ − 1303 /* Clear the divider area first. This needs to be done when a
+ − 1304 window split occurs. */
+ − 1305 /* if (clear) */
+ − 1306 gdk_draw_rectangle (GDK_DRAWABLE (x_win), background_gc, TRUE,
+ − 1307 x, y1, width, y2 - y1);
+ − 1308
+ − 1309 #if 0
+ − 1310 /* Draw the divider line. */
+ − 1311 gdk_draw_rectangle (GDK_DRAWABLE (x_win), background_gc, TRUE,
+ − 1312 x + spacing + shadow_thickness, y1,
+ − 1313 line_width, y2 - y1);
+ − 1314 #endif
+ − 1315
+ − 1316 /* Draw the shadows around the divider line */
+ − 1317 gtk_output_shadows (f, x + spacing, y1,
+ − 1318 width - 2 * spacing, y2 - y1,
+ − 1319 shadow_thickness);
+ − 1320 }
+ − 1321
+ − 1322 /*****************************************************************************
+ − 1323 gtk_output_blank
+ − 1324
+ − 1325 Output a blank by clearing the area it covers in the foreground color
+ − 1326 of its face.
+ − 1327 ****************************************************************************/
+ − 1328 static void
+ − 1329 gtk_output_blank (struct window *w, struct display_line *dl, struct rune *rb,
+ − 1330 int start_pixpos, int cursor_start, int cursor_width)
+ − 1331 {
+ − 1332 struct frame *f = XFRAME (w->frame);
+ − 1333 struct device *d = XDEVICE (f->device);
+ − 1334
+ − 1335 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1336 GdkGC *gc;
+ − 1337 struct face_cachel *cursor_cachel =
+ − 1338 WINDOW_FACE_CACHEL (w,
+ − 1339 get_builtin_face_cache_index
+ − 1340 (w, Vtext_cursor_face));
+ − 1341 Lisp_Object bg_pmap;
+ − 1342 Lisp_Object buffer = WINDOW_BUFFER (w);
+ − 1343 Lisp_Object bar_cursor_value = symbol_value_in_buffer (Qbar_cursor,
+ − 1344 buffer);
+ − 1345
+ − 1346 int x = rb->xpos;
+ − 1347 int y = dl->ypos - dl->ascent;
+ − 1348 int width = rb->width;
+ − 1349 int height = dl->ascent + dl->descent - dl->clip;
+ − 1350
+ − 1351 if (start_pixpos > x)
+ − 1352 {
+ − 1353 if (start_pixpos >= (x + width))
+ − 1354 return;
+ − 1355 else
+ − 1356 {
+ − 1357 width -= (start_pixpos - x);
+ − 1358 x = start_pixpos;
+ − 1359 }
+ − 1360 }
+ − 1361
+ − 1362 bg_pmap = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, rb->findex);
+ − 1363 if (!IMAGE_INSTANCEP (bg_pmap)
+ − 1364 || !IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
+ − 1365 bg_pmap = Qnil;
+ − 1366
+ − 1367 if (NILP (bg_pmap))
+ − 1368 gc = gtk_get_gc (d, Qnil, WINDOW_FACE_CACHEL_BACKGROUND (w, rb->findex),
+ − 1369 Qnil, Qnil, Qnil);
+ − 1370 else
+ − 1371 gc = gtk_get_gc (d, Qnil, WINDOW_FACE_CACHEL_FOREGROUND (w, rb->findex),
+ − 1372 WINDOW_FACE_CACHEL_BACKGROUND (w, rb->findex), bg_pmap,
+ − 1373 Qnil);
+ − 1374
+ − 1375 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, x, y, width, height);
+ − 1376
+ − 1377 /* If this rune is marked as having the cursor, then it is actually
+ − 1378 representing a tab. */
+ − 1379 if (!NILP (w->text_cursor_visible_p)
+ − 1380 && (rb->cursor_type == CURSOR_ON
+ − 1381 || (cursor_width
+ − 1382 && (cursor_start + cursor_width > x)
+ − 1383 && cursor_start < (x + width))))
+ − 1384 {
+ − 1385 int cursor_height, cursor_y;
+ − 1386 int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d));
+ − 1387 struct Lisp_Font_Instance *fi;
+ − 1388
+ − 1389 fi = XFONT_INSTANCE (FACE_CACHEL_FONT
+ − 1390 (WINDOW_FACE_CACHEL (w, rb->findex),
+ − 1391 Vcharset_ascii));
+ − 1392
+ − 1393 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil);
+ − 1394
+ − 1395 cursor_y = dl->ypos - fi->ascent;
+ − 1396 cursor_height = fi->height;
+ − 1397 if (cursor_y + cursor_height > y + height)
+ − 1398 cursor_height = y + height - cursor_y;
+ − 1399
+ − 1400 if (focus)
+ − 1401 {
+ − 1402 if (NILP (bar_cursor_value))
+ − 1403 {
+ − 1404 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE,
+ − 1405 cursor_start, cursor_y,
+ − 1406 fi->width, cursor_height);
+ − 1407 }
+ − 1408 else
+ − 1409 {
+ − 1410 int bar_width = EQ (bar_cursor_value, Qt) ? 1 : 2;
+ − 1411
+ − 1412 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil,
+ − 1413 make_int (bar_width));
+ − 1414 gdk_draw_line (GDK_DRAWABLE (x_win), gc, cursor_start + bar_width - 1,
+ − 1415 cursor_y, cursor_start + bar_width - 1,
+ − 1416 cursor_y + cursor_height - 1);
+ − 1417 }
+ − 1418 }
+ − 1419 else if (NILP (bar_cursor_value))
+ − 1420 {
+ − 1421 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, FALSE,
+ − 1422 cursor_start, cursor_y,
+ − 1423 fi->width - 1, cursor_height - 1);
+ − 1424 }
+ − 1425 }
+ − 1426 }
+ − 1427
+ − 1428 /*****************************************************************************
+ − 1429 gtk_output_hline
+ − 1430
+ − 1431 Output a horizontal line in the foreground of its face.
+ − 1432 ****************************************************************************/
+ − 1433 static void
+ − 1434 gtk_output_hline (struct window *w, struct display_line *dl, struct rune *rb)
+ − 1435 {
+ − 1436 struct frame *f = XFRAME (w->frame);
+ − 1437 struct device *d = XDEVICE (f->device);
+ − 1438 GtkStyle *style = FRAME_GTK_TEXT_WIDGET (f)->style;
+ − 1439
+ − 1440 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1441 GdkGC *gc;
+ − 1442
+ − 1443 int x = rb->xpos;
+ − 1444 int width = rb->width;
+ − 1445 int height = dl->ascent + dl->descent - dl->clip;
+ − 1446
+ − 1447 int ypos1, ypos2, ypos3, ypos4;
+ − 1448
+ − 1449 ypos1 = dl->ypos - dl->ascent;
+ − 1450 ypos2 = ypos1 + rb->object.hline.yoffset;
+ − 1451 ypos3 = ypos2 + rb->object.hline.thickness;
+ − 1452 ypos4 = dl->ypos + dl->descent - dl->clip;
+ − 1453
+ − 1454 /* First clear the area not covered by the line. */
+ − 1455 if (height - rb->object.hline.thickness > 0)
+ − 1456 {
+ − 1457 gc = gtk_get_gc (d, Qnil, WINDOW_FACE_CACHEL_FOREGROUND (w, rb->findex),
+ − 1458 Qnil, Qnil, Qnil);
+ − 1459
+ − 1460 if (ypos2 - ypos1 > 0)
+ − 1461 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, x, ypos1, width, ypos2 - ypos1);
+ − 1462 if (ypos4 - ypos3 > 0)
+ − 1463 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, x, ypos1, width, ypos2 - ypos1);
+ − 1464 }
+ − 1465
+ − 1466 gtk_paint_hline (style, x_win, GTK_STATE_NORMAL, NULL, FRAME_GTK_TEXT_WIDGET (f),
+ − 1467 "hline", x, x + width, ypos2);
+ − 1468 #if 0
+ − 1469 /* Now draw the line. */
+ − 1470 gc = gtk_get_gc (d, Qnil, WINDOW_FACE_CACHEL_BACKGROUND (w, rb->findex),
+ − 1471 Qnil, Qnil, Qnil);
+ − 1472
+ − 1473 if (ypos2 < ypos1)
+ − 1474 ypos2 = ypos1;
+ − 1475 if (ypos3 > ypos4)
+ − 1476 ypos3 = ypos4;
+ − 1477
+ − 1478 if (ypos3 - ypos2 > 0)
+ − 1479 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, x, ypos2, width, ypos3 - ypos2);
+ − 1480 #endif
+ − 1481 }
+ − 1482
+ − 1483 /*****************************************************************************
+ − 1484 gtk_output_shadows
+ − 1485
+ − 1486 Draw a shadow around the given area using the standard theme engine routines.
+ − 1487 ****************************************************************************/
+ − 1488 void
+ − 1489 gtk_output_shadows (struct frame *f, int x, int y, int width, int height,
+ − 1490 int shadow_thickness)
+ − 1491 {
+ − 1492 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1493 GtkStyle *style = FRAME_GTK_TEXT_WIDGET (f)->style;
+ − 1494 GtkShadowType stype = GTK_SHADOW_OUT;
+ − 1495
+ − 1496 if (shadow_thickness < 0)
+ − 1497 {
+ − 1498 stype = GTK_SHADOW_IN;
+ − 1499 }
+ − 1500 else if (shadow_thickness == 0)
+ − 1501 {
+ − 1502 stype = GTK_SHADOW_NONE;
+ − 1503 }
+ − 1504
+ − 1505 /* Do we want to have some magic constants to set
+ − 1506 GTK_SHADOW_ETCHED_IN or GTK_SHADOW_ETCHED_OUT? */
+ − 1507
+ − 1508 gtk_paint_shadow (style, x_win, GTK_STATE_NORMAL, stype, NULL,
+ − 1509 FRAME_GTK_TEXT_WIDGET (f), "modeline",
+ − 1510 x, y, width, height);
+ − 1511 }
+ − 1512
+ − 1513 /*****************************************************************************
+ − 1514 gtk_clear_to_window_end
+ − 1515
+ − 1516 Clear the area between ypos1 and ypos2. Each margin area and the
+ − 1517 text area is handled separately since they may each have their own
+ − 1518 background color.
+ − 1519 ****************************************************************************/
+ − 1520 static void
+ − 1521 gtk_clear_to_window_end (struct window *w, int ypos1, int ypos2)
+ − 1522 {
+ − 1523 int height = ypos2 - ypos1;
+ − 1524
+ − 1525 if (height)
+ − 1526 {
+ − 1527 struct frame *f = XFRAME (w->frame);
+ − 1528 Lisp_Object window;
+ − 1529 int bflag = (window_needs_vertical_divider (w) ? 0 : 1);
+ − 1530 layout_bounds bounds;
+ − 1531
+ − 1532 bounds = calculate_display_line_boundaries (w, bflag);
+ − 1533 XSETWINDOW (window, w);
+ − 1534
+ − 1535 if (window_is_leftmost (w))
+ − 1536 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
+ − 1537 ypos1, FRAME_BORDER_WIDTH (f), height);
+ − 1538
+ − 1539 if (bounds.left_in - bounds.left_out > 0)
+ − 1540 redisplay_clear_region (window,
+ − 1541 get_builtin_face_cache_index (w, Vleft_margin_face),
+ − 1542 bounds.left_out, ypos1,
+ − 1543 bounds.left_in - bounds.left_out, height);
+ − 1544
+ − 1545 if (bounds.right_in - bounds.left_in > 0)
+ − 1546 redisplay_clear_region (window, DEFAULT_INDEX, bounds.left_in, ypos1,
+ − 1547 bounds.right_in - bounds.left_in, height);
+ − 1548
+ − 1549 if (bounds.right_out - bounds.right_in > 0)
+ − 1550 redisplay_clear_region (window,
+ − 1551 get_builtin_face_cache_index (w, Vright_margin_face),
+ − 1552 bounds.right_in, ypos1,
+ − 1553 bounds.right_out - bounds.right_in, height);
+ − 1554
+ − 1555 if (window_is_rightmost (w))
+ − 1556 redisplay_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
+ − 1557 ypos1, FRAME_BORDER_WIDTH (f), height);
+ − 1558 }
+ − 1559 }
+ − 1560
+ − 1561 /*****************************************************************************
+ − 1562 gtk_redraw_exposed_window
+ − 1563
+ − 1564 Given a bounding box for an area that needs to be redrawn, determine
+ − 1565 what parts of what lines are contained within and re-output their
+ − 1566 contents.
+ − 1567 ****************************************************************************/
+ − 1568 static void
+ − 1569 gtk_redraw_exposed_window (struct window *w, int x, int y, int width, int height)
+ − 1570 {
+ − 1571 struct frame *f = XFRAME (w->frame);
+ − 1572 int line;
+ − 1573 int start_x, start_y, end_x, end_y;
+ − 1574 int orig_windows_structure_changed;
+ − 1575
+ − 1576 display_line_dynarr *cdla = window_display_lines (w, CURRENT_DISP);
+ − 1577
+ − 1578 if (!NILP (w->vchild))
+ − 1579 {
+ − 1580 gtk_redraw_exposed_windows (w->vchild, x, y, width, height);
+ − 1581 return;
+ − 1582 }
+ − 1583 else if (!NILP (w->hchild))
+ − 1584 {
+ − 1585 gtk_redraw_exposed_windows (w->hchild, x, y, width, height);
+ − 1586 return;
+ − 1587 }
+ − 1588
+ − 1589 /* If the window doesn't intersect the exposed region, we're done here. */
+ − 1590 if (x >= WINDOW_RIGHT (w) || (x + width) <= WINDOW_LEFT (w)
+ − 1591 || y >= WINDOW_BOTTOM (w) || (y + height) <= WINDOW_TOP (w))
+ − 1592 {
+ − 1593 return;
+ − 1594 }
+ − 1595 else
+ − 1596 {
+ − 1597 start_x = max (WINDOW_LEFT (w), x);
+ − 1598 end_x = min (WINDOW_RIGHT (w), (x + width));
+ − 1599 start_y = max (WINDOW_TOP (w), y);
+ − 1600 end_y = min (WINDOW_BOTTOM (w), y + height);
+ − 1601
+ − 1602 /* We do this to make sure that the 3D modelines get redrawn if
+ − 1603 they are in the exposed region. */
+ − 1604 orig_windows_structure_changed = f->windows_structure_changed;
+ − 1605 f->windows_structure_changed = 1;
+ − 1606 }
+ − 1607
+ − 1608 if (window_needs_vertical_divider (w))
+ − 1609 {
+ − 1610 gtk_output_vertical_divider (w, 0);
+ − 1611 }
+ − 1612
+ − 1613 for (line = 0; line < Dynarr_length (cdla); line++)
+ − 1614 {
+ − 1615 struct display_line *cdl = Dynarr_atp (cdla, line);
+ − 1616 int top_y = cdl->ypos - cdl->ascent;
+ − 1617 int bottom_y = cdl->ypos + cdl->descent;
+ − 1618
+ − 1619 if (bottom_y >= start_y)
+ − 1620 {
+ − 1621 if (top_y > end_y)
+ − 1622 {
+ − 1623 if (line == 0)
+ − 1624 continue;
+ − 1625 else
+ − 1626 break;
+ − 1627 }
+ − 1628 else
+ − 1629 {
+ − 1630 output_display_line (w, 0, cdla, line, start_x, end_x);
+ − 1631 }
+ − 1632 }
+ − 1633 }
+ − 1634
+ − 1635 f->windows_structure_changed = orig_windows_structure_changed;
+ − 1636
+ − 1637 /* If there have never been any face cache_elements created, then this
+ − 1638 expose event doesn't actually have anything to do. */
+ − 1639 if (Dynarr_largest (w->face_cachels))
+ − 1640 redisplay_clear_bottom_of_window (w, cdla, start_y, end_y);
+ − 1641 }
+ − 1642
+ − 1643 /*****************************************************************************
+ − 1644 gtk_redraw_exposed_windows
+ − 1645
+ − 1646 For each window beneath the given window in the window hierarchy,
+ − 1647 ensure that it is redrawn if necessary after an Expose event.
+ − 1648 ****************************************************************************/
+ − 1649 static void
+ − 1650 gtk_redraw_exposed_windows (Lisp_Object window, int x, int y, int width,
+ − 1651 int height)
+ − 1652 {
+ − 1653 for (; !NILP (window); window = XWINDOW (window)->next)
+ − 1654 gtk_redraw_exposed_window (XWINDOW (window), x, y, width, height);
+ − 1655 }
+ − 1656
+ − 1657 /*****************************************************************************
+ − 1658 gtk_redraw_exposed_area
+ − 1659
+ − 1660 For each window on the given frame, ensure that any area in the
+ − 1661 Exposed area is redrawn.
+ − 1662 ****************************************************************************/
+ − 1663 void
+ − 1664 gtk_redraw_exposed_area (struct frame *f, int x, int y, int width, int height)
+ − 1665 {
+ − 1666 /* If any window on the frame has had its face cache reset then the
+ − 1667 redisplay structures are effectively invalid. If we attempt to
+ − 1668 use them we'll blow up. We mark the frame as changed to ensure
+ − 1669 that redisplay will do a full update. This probably isn't
+ − 1670 necessary but it can't hurt. */
+ − 1671
+ − 1672 #ifdef HAVE_TOOLBARS
+ − 1673 /* #### We would rather put these off as well but there is currently
+ − 1674 no combination of flags which will force an unchanged toolbar to
+ − 1675 redraw anyhow. */
+ − 1676 MAYBE_FRAMEMETH (f, redraw_exposed_toolbars, (f, x, y, width, height));
+ − 1677 #endif
+ − 1678 redraw_exposed_gutters (f, x, y, width, height);
+ − 1679
+ − 1680 if (!f->window_face_cache_reset)
+ − 1681 {
+ − 1682 gtk_redraw_exposed_windows (f->root_window, x, y, width, height);
+ − 1683 }
+ − 1684 else
+ − 1685 MARK_FRAME_CHANGED (f);
+ − 1686 }
+ − 1687
+ − 1688 /****************************************************************************
+ − 1689 gtk_clear_region
+ − 1690
+ − 1691 Clear the area in the box defined by the given parameters using the
+ − 1692 given face.
+ − 1693 ****************************************************************************/
+ − 1694 static void
+ − 1695 gtk_clear_region (Lisp_Object locale, struct device* d, struct frame* f, face_index findex,
+ − 1696 int x, int y,
+ − 1697 int width, int height, Lisp_Object fcolor, Lisp_Object bcolor,
+ − 1698 Lisp_Object background_pixmap)
+ − 1699 {
+ − 1700 GdkWindow *x_win;
+ − 1701 GdkGC *gc = NULL;
+ − 1702
+ − 1703 x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1704
+ − 1705 if (!UNBOUNDP (background_pixmap))
+ − 1706 {
+ − 1707 gc = gtk_get_gc (d, Qnil, fcolor, bcolor, background_pixmap, Qnil);
+ − 1708 }
+ − 1709
+ − 1710 if (gc)
+ − 1711 {
+ − 1712 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc,TRUE,
+ − 1713 x, y, width, height);
+ − 1714 }
+ − 1715 else
+ − 1716 {
+ − 1717 gdk_window_clear_area (x_win, x, y, width, height);
+ − 1718 }
+ − 1719 }
+ − 1720
+ − 1721 /*****************************************************************************
+ − 1722 gtk_output_eol_cursor
+ − 1723
+ − 1724 Draw a cursor at the end of a line. The end-of-line cursor is
+ − 1725 narrower than the normal cursor.
+ − 1726 ****************************************************************************/
+ − 1727 static void
+ − 1728 gtk_output_eol_cursor (struct window *w, struct display_line *dl, int xpos,
+ − 1729 face_index findex)
+ − 1730 {
+ − 1731 struct frame *f = XFRAME (w->frame);
+ − 1732 struct device *d = XDEVICE (f->device);
+ − 1733 Lisp_Object window;
+ − 1734
+ − 1735 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1736 GdkGC *gc;
+ − 1737 face_index elt = get_builtin_face_cache_index (w, Vtext_cursor_face);
+ − 1738 struct face_cachel *cursor_cachel = WINDOW_FACE_CACHEL (w, elt);
+ − 1739
+ − 1740 int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d));
+ − 1741 Lisp_Object bar_cursor_value = symbol_value_in_buffer (Qbar_cursor,
+ − 1742 WINDOW_BUFFER (w));
+ − 1743
+ − 1744 int x = xpos;
+ − 1745 int y = dl->ypos - dl->ascent;
+ − 1746 int width = EOL_CURSOR_WIDTH;
+ − 1747 int height = dl->ascent + dl->descent - dl->clip;
+ − 1748 int cursor_height, cursor_y;
+ − 1749 int defheight, defascent;
+ − 1750
+ − 1751 XSETWINDOW (window, w);
+ − 1752 redisplay_clear_region (window, findex, x, y, width, height);
+ − 1753
+ − 1754 if (NILP (w->text_cursor_visible_p))
+ − 1755 return;
+ − 1756
+ − 1757 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil);
+ − 1758
+ − 1759 default_face_font_info (window, &defascent, 0, &defheight, 0, 0);
+ − 1760
+ − 1761 /* make sure the cursor is entirely contained between y and y+height */
+ − 1762 cursor_height = min (defheight, height);
+ − 1763 cursor_y = max (y, min (y + height - cursor_height,
+ − 1764 dl->ypos - defascent));
+ − 1765
+ − 1766 if (focus)
+ − 1767 {
+ − 1768 if (NILP (bar_cursor_value))
+ − 1769 {
+ − 1770 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, TRUE, x, cursor_y, width, cursor_height);
+ − 1771 }
+ − 1772 else
+ − 1773 {
+ − 1774 int bar_width = EQ (bar_cursor_value, Qt) ? 1 : 2;
+ − 1775
+ − 1776 gc = gtk_get_gc (d, Qnil, cursor_cachel->background, Qnil, Qnil,
+ − 1777 make_int (bar_width));
+ − 1778 gdk_draw_line (GDK_DRAWABLE (x_win), gc, x + bar_width - 1, cursor_y,
+ − 1779 x + bar_width - 1, cursor_y + cursor_height - 1);
+ − 1780 }
+ − 1781 }
+ − 1782 else if (NILP (bar_cursor_value))
+ − 1783 {
+ − 1784 gdk_draw_rectangle (GDK_DRAWABLE (x_win), gc, FALSE, x, cursor_y, width - 1,
+ − 1785 cursor_height - 1);
+ − 1786 }
+ − 1787 }
+ − 1788
+ − 1789 static void
+ − 1790 gtk_clear_frame_window (Lisp_Object window)
+ − 1791 {
+ − 1792 struct window *w = XWINDOW (window);
+ − 1793
+ − 1794 if (!NILP (w->vchild))
+ − 1795 {
+ − 1796 gtk_clear_frame_windows (w->vchild);
+ − 1797 return;
+ − 1798 }
+ − 1799
+ − 1800 if (!NILP (w->hchild))
+ − 1801 {
+ − 1802 gtk_clear_frame_windows (w->hchild);
+ − 1803 return;
+ − 1804 }
+ − 1805
+ − 1806 gtk_clear_to_window_end (w, WINDOW_TEXT_TOP (w), WINDOW_TEXT_BOTTOM (w));
+ − 1807 }
+ − 1808
+ − 1809 static void
+ − 1810 gtk_clear_frame_windows (Lisp_Object window)
+ − 1811 {
+ − 1812 for (; !NILP (window); window = XWINDOW (window)->next)
+ − 1813 gtk_clear_frame_window (window);
+ − 1814 }
+ − 1815
+ − 1816 static void
+ − 1817 gtk_clear_frame (struct frame *f)
+ − 1818 {
+ − 1819 GdkWindow *x_win = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (f));
+ − 1820 int x, y, width, height;
+ − 1821 Lisp_Object frame;
+ − 1822
+ − 1823 x = FRAME_LEFT_BORDER_START (f);
+ − 1824 width = (FRAME_PIXWIDTH (f) - FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) -
+ − 1825 FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) -
+ − 1826 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f) -
+ − 1827 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f));
+ − 1828 /* #### This adjustment by 1 should be being done in the macros.
+ − 1829 There is some small differences between when the menubar is on
+ − 1830 and off that we still need to deal with. */
+ − 1831 y = FRAME_TOP_BORDER_START (f) - 1;
+ − 1832 height = (FRAME_PIXHEIGHT (f) - FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) -
+ − 1833 FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) -
+ − 1834 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f) -
+ − 1835 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f)) + 1;
+ − 1836
+ − 1837 gdk_window_clear_area (x_win, x, y, width, height);
+ − 1838
+ − 1839 XSETFRAME (frame, f);
+ − 1840
+ − 1841 if (!UNBOUNDP (FACE_BACKGROUND_PIXMAP (Vdefault_face, frame))
+ − 1842 || !UNBOUNDP (FACE_BACKGROUND_PIXMAP (Vleft_margin_face, frame))
+ − 1843 || !UNBOUNDP (FACE_BACKGROUND_PIXMAP (Vright_margin_face, frame)))
+ − 1844 {
+ − 1845 gtk_clear_frame_windows (f->root_window);
+ − 1846 }
+ − 1847 }
+ − 1848
+ − 1849 static int
+ − 1850 gtk_flash (struct device *d)
+ − 1851 {
+ − 1852 GdkGCValues gcv;
+ − 1853 GdkGC *gc;
+ − 1854 GdkColor tmp_fcolor, tmp_bcolor;
+ − 1855 Lisp_Object tmp_pixel, frame;
+ − 1856 struct frame *f = device_selected_frame (d);
+ − 1857 struct window *w = XWINDOW (FRAME_ROOT_WINDOW (f));
+ − 1858
+ − 1859 XSETFRAME (frame, f);
+ − 1860
+ − 1861 tmp_pixel = FACE_FOREGROUND (Vdefault_face, frame);
+ − 1862 tmp_fcolor = * (COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (tmp_pixel)));
+ − 1863 tmp_pixel = FACE_BACKGROUND (Vdefault_face, frame);
+ − 1864 tmp_bcolor = * (COLOR_INSTANCE_GTK_COLOR (XCOLOR_INSTANCE (tmp_pixel)));
+ − 1865
+ − 1866 memset (&gcv, ~0, sizeof (gcv)); /* initialize all slots to ~0 */
+ − 1867 gcv.foreground.pixel = (tmp_fcolor.pixel ^ tmp_bcolor.pixel);
+ − 1868 gcv.function = GDK_XOR;
+ − 1869 gcv.graphics_exposures = FALSE;
+ − 1870 gc = gc_cache_lookup (DEVICE_GTK_GC_CACHE (XDEVICE (f->device)), &gcv,
+ − 1871 GDK_GC_FOREGROUND | GDK_GC_FUNCTION | GDK_GC_EXPOSURES);
+ − 1872
+ − 1873 gdk_draw_rectangle (GDK_DRAWABLE (GET_GTK_WIDGET_WINDOW (FRAME_GTK_SHELL_WIDGET (f))),
+ − 1874 gc, TRUE, w->pixel_left, w->pixel_top,
+ − 1875 w->pixel_width, w->pixel_height);
+ − 1876
+ − 1877 gdk_flush ();
+ − 1878
+ − 1879 #ifdef HAVE_POLL
+ − 1880 poll (0, 0, 100);
+ − 1881 #else /* !HAVE_POLL */
+ − 1882 #ifdef HAVE_SELECT
+ − 1883 {
+ − 1884 int usecs = 100000;
+ − 1885 struct timeval tv;
+ − 1886 tv.tv_sec = usecs / 1000000L;
+ − 1887 tv.tv_usec = usecs % 1000000L;
+ − 1888 /* I'm sure someone is going to complain about this... */
+ − 1889 select (0, 0, 0, 0, &tv);
+ − 1890 }
+ − 1891 #else
+ − 1892 bite me
+ − 1893 #endif /* HAVE_POLL */
+ − 1894 #endif /* HAVE_SELECT */
+ − 1895
+ − 1896 gdk_draw_rectangle (GDK_DRAWABLE (GET_GTK_WIDGET_WINDOW (FRAME_GTK_SHELL_WIDGET (f))),
+ − 1897 gc, TRUE, w->pixel_left, w->pixel_top,
+ − 1898 w->pixel_width, w->pixel_height);
+ − 1899
+ − 1900 gdk_flush ();
+ − 1901
+ − 1902 return 1;
+ − 1903 }
+ − 1904
+ − 1905 static void
+ − 1906 gtk_bevel_area (struct window *w, face_index findex,
+ − 1907 int x, int y, int width, int height,
+ − 1908 int shadow_thickness, int edges, enum edge_style style)
+ − 1909 {
+ − 1910 struct frame *f = XFRAME (w->frame);
+ − 1911 struct device *d = XDEVICE (f->device);
+ − 1912
+ − 1913 gtk_output_shadows (f, x, y, width, height, shadow_thickness);
+ − 1914 }
+ − 1915
+ − 1916
+ − 1917
+ − 1918 /* Make audible bell. */
+ − 1919 static void
+ − 1920 gtk_ring_bell (struct device *d, int volume, int pitch, int duration)
+ − 1921 {
+ − 1922 /* Gdk does not allow us to control the duration / pitch / volume */
+ − 1923 gdk_beep ();
+ − 1924 }
+ − 1925
+ − 1926
+ − 1927 /************************************************************************/
+ − 1928 /* initialization */
+ − 1929 /************************************************************************/
+ − 1930
+ − 1931 void
+ − 1932 console_type_create_redisplay_gtk (void)
+ − 1933 {
+ − 1934 /* redisplay methods */
+ − 1935 CONSOLE_HAS_METHOD (gtk, text_width);
+ − 1936 CONSOLE_HAS_METHOD (gtk, output_display_block);
+ − 1937 CONSOLE_HAS_METHOD (gtk, divider_height);
+ − 1938 CONSOLE_HAS_METHOD (gtk, eol_cursor_width);
+ − 1939 CONSOLE_HAS_METHOD (gtk, output_vertical_divider);
+ − 1940 CONSOLE_HAS_METHOD (gtk, clear_to_window_end);
+ − 1941 CONSOLE_HAS_METHOD (gtk, clear_region);
+ − 1942 CONSOLE_HAS_METHOD (gtk, clear_frame);
+ − 1943 CONSOLE_HAS_METHOD (gtk, flash);
+ − 1944 CONSOLE_HAS_METHOD (gtk, ring_bell);
+ − 1945 CONSOLE_HAS_METHOD (gtk, bevel_area);
+ − 1946 CONSOLE_HAS_METHOD (gtk, output_string);
+ − 1947 /* CONSOLE_HAS_METHOD (gtk, output_pixmap); */
+ − 1948 }
+ − 1949
+ − 1950 /* This makes me feel incredibly dirty... but there is no other way to
+ − 1951 get this done right other than calling clear_area before every
+ − 1952 single $#!%@ing piece of text, which I do NOT want to do. */
+ − 1953 #define USE_X_SPECIFIC_DRAW_ROUTINES 1
+ − 1954
+ − 1955 #include <gdk/gdkx.h>
+ − 1956
+ − 1957 void
+ − 1958 gdk_draw_text_image (GdkDrawable *drawable,
+ − 1959 GdkFont *font,
+ − 1960 GdkGC *gc,
+ − 1961 gint x,
+ − 1962 gint y,
+ − 1963 const gchar *text,
+ − 1964 gint text_length)
+ − 1965 {
+ − 1966 #if !USE_X_SPECIFIC_DRAW_ROUTINES
+ − 1967 int width = gdk_text_measure (font, text, text_length);
+ − 1968 int height = gdk_text_height (font, text, text_length);
+ − 1969
+ − 1970 gdk_draw_rectangle (drawable, gc, TRUE, x, y, width, height);
+ − 1971 gdk_draw_text (drawable, font, gc, x, y, text, text_length);
+ − 1972 #else
+ − 1973 GdkWindowPrivate *drawable_private;
+ − 1974 GdkFontPrivate *font_private;
+ − 1975 GdkGCPrivate *gc_private;
+ − 1976
+ − 1977 g_return_if_fail (drawable != NULL);
+ − 1978 g_return_if_fail (font != NULL);
+ − 1979 g_return_if_fail (gc != NULL);
+ − 1980 g_return_if_fail (text != NULL);
+ − 1981
+ − 1982 drawable_private = (GdkWindowPrivate*) drawable;
+ − 1983 if (drawable_private->destroyed)
+ − 1984 return;
+ − 1985 gc_private = (GdkGCPrivate*) gc;
+ − 1986 font_private = (GdkFontPrivate*) font;
+ − 1987
+ − 1988 if (font->type == GDK_FONT_FONT)
+ − 1989 {
+ − 1990 XFontStruct *xfont = (XFontStruct *) font_private->xfont;
+ − 1991 XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid);
+ − 1992 if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
+ − 1993 {
+ − 1994 XDrawImageString (drawable_private->xdisplay, drawable_private->xwindow,
+ − 1995 gc_private->xgc, x, y, text, text_length);
+ − 1996 }
+ − 1997 else
+ − 1998 {
+ − 1999 XDrawImageString16 (drawable_private->xdisplay, drawable_private->xwindow,
+ − 2000 gc_private->xgc, x, y, (XChar2b *) text, text_length / 2);
+ − 2001 }
+ − 2002 }
+ − 2003 else if (font->type == GDK_FONT_FONTSET)
+ − 2004 {
+ − 2005 XFontSet fontset = (XFontSet) font_private->xfont;
+ − 2006 XmbDrawImageString (drawable_private->xdisplay, drawable_private->xwindow,
+ − 2007 fontset, gc_private->xgc, x, y, text, text_length);
+ − 2008 }
+ − 2009 else
+ − 2010 g_error("undefined font type\n");
+ − 2011 #endif
+ − 2012 }
+ − 2013
+ − 2014 static void
+ − 2015 our_draw_bitmap (GdkDrawable *drawable,
+ − 2016 GdkGC *gc,
+ − 2017 GdkPixmap *src,
+ − 2018 gint xsrc,
+ − 2019 gint ysrc,
+ − 2020 gint xdest,
+ − 2021 gint ydest,
+ − 2022 gint width,
+ − 2023 gint height)
+ − 2024 {
+ − 2025 GdkWindowPrivate *drawable_private;
+ − 2026 GdkWindowPrivate *src_private;
+ − 2027 GdkGCPrivate *gc_private;
+ − 2028
+ − 2029 g_return_if_fail (drawable != NULL);
+ − 2030 g_return_if_fail (src != NULL);
+ − 2031 g_return_if_fail (gc != NULL);
+ − 2032
+ − 2033 drawable_private = (GdkWindowPrivate*) drawable;
+ − 2034 src_private = (GdkWindowPrivate*) src;
+ − 2035 if (drawable_private->destroyed || src_private->destroyed)
+ − 2036 return;
+ − 2037 gc_private = (GdkGCPrivate*) gc;
+ − 2038
+ − 2039 if (width == -1)
+ − 2040 width = src_private->width;
+ − 2041 if (height == -1)
+ − 2042 height = src_private->height;
+ − 2043
+ − 2044 XCopyPlane (drawable_private->xdisplay,
+ − 2045 src_private->xwindow,
+ − 2046 drawable_private->xwindow,
+ − 2047 gc_private->xgc,
+ − 2048 xsrc, ysrc,
+ − 2049 width, height,
+ − 2050 xdest, ydest, 1L);
+ − 2051 }
