1/* Implementation of GUI terminal on the Microsoft W32 API. 2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 2006, 2007 Free Software Foundation, Inc. 5 6This file is part of GNU Emacs. 7 8GNU Emacs is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GNU Emacs is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GNU Emacs; see the file COPYING. If not, write to 20the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, USA. */ 22 23#include <config.h> 24#include <signal.h> 25#include <stdio.h> 26#include <stdlib.h> 27#include "lisp.h" 28#include "charset.h" 29#include "blockinput.h" 30 31#include "w32heap.h" 32#include "w32term.h" 33#include "w32bdf.h" 34#include <shellapi.h> 35 36#include "systty.h" 37#include "systime.h" 38#include "atimer.h" 39#include "keymap.h" 40 41#include <ctype.h> 42#include <errno.h> 43#include <setjmp.h> 44#include <sys/stat.h> 45 46#include "keyboard.h" 47#include "frame.h" 48#include "dispextern.h" 49#include "fontset.h" 50#include "termhooks.h" 51#include "termopts.h" 52#include "termchar.h" 53#include "gnu.h" 54#include "disptab.h" 55#include "buffer.h" 56#include "window.h" 57#include "intervals.h" 58#include "composite.h" 59#include "coding.h" 60 61#define abs(x) ((x) < 0 ? -(x) : (x)) 62 63 64/* Fringe bitmaps. */ 65 66static int max_fringe_bmp = 0; 67static HBITMAP *fringe_bmp = 0; 68 69/* Non-nil means Emacs uses toolkit scroll bars. */ 70 71Lisp_Object Vx_toolkit_scroll_bars; 72 73/* Temporary variables for w32_read_socket. */ 74 75static int last_mousemove_x = 0; 76static int last_mousemove_y = 0; 77 78/* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */ 79#ifndef GET_WHEEL_DELTA_WPARAM 80#define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam)) 81#endif 82 83/* Non-zero means that a HELP_EVENT has been generated since Emacs 84 start. */ 85 86static int any_help_event_p; 87 88/* Last window where we saw the mouse. Used by mouse-autoselect-window. */ 89static Lisp_Object last_window; 90 91/* Non-zero means make use of UNDERLINE_POSITION font properties. 92 (Not yet supported, see TODO in x_draw_glyph_string.) */ 93int x_use_underline_position_properties; 94 95/* Non-zero means to draw the underline at the same place as the descent line. */ 96 97int x_underline_at_descent_line; 98 99extern unsigned int msh_mousewheel; 100 101extern void free_frame_menubar (); 102 103extern int w32_codepage_for_font (char *fontname); 104extern Cursor w32_load_cursor (LPCTSTR name); 105 106extern glyph_metric *w32_BDF_TextMetric(bdffont *fontp, 107 unsigned char *text, int dim); 108extern Lisp_Object Vwindow_system; 109 110#define x_any_window_to_frame x_window_to_frame 111#define x_top_window_to_frame x_window_to_frame 112 113 114/* This is display since w32 does not support multiple ones. */ 115struct w32_display_info one_w32_display_info; 116struct w32_display_info *x_display_list; 117 118/* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE), 119 one for each element of w32_display_list and in the same order. 120 NAME is the name of the frame. 121 FONT-LIST-CACHE records previous values returned by x-list-fonts. */ 122Lisp_Object w32_display_name_list; 123 124/* Frame being updated by update_frame. This is declared in term.c. 125 This is set by update_begin and looked at by all the 126 w32 functions. It is zero while not inside an update. 127 In that case, the w32 functions assume that `SELECTED_FRAME ()' 128 is the frame to apply to. */ 129extern struct frame *updating_frame; 130 131/* This is a frame waiting to be autoraised, within w32_read_socket. */ 132struct frame *pending_autoraise_frame; 133 134/* The handle of the frame that currently owns the system caret. */ 135HWND w32_system_caret_hwnd; 136int w32_system_caret_height; 137int w32_system_caret_x; 138int w32_system_caret_y; 139int w32_use_visible_system_caret; 140 141/* Flag to enable Unicode output in case users wish to use programs 142 like Twinbridge on '95 rather than installed system level support 143 for Far East languages. */ 144int w32_enable_unicode_output; 145 146/* Flag to enable Cleartype hack for font metrics. */ 147static int cleartype_active; 148 149DWORD dwWindowsThreadId = 0; 150HANDLE hWindowsThread = NULL; 151DWORD dwMainThreadId = 0; 152HANDLE hMainThread = NULL; 153 154int vertical_scroll_bar_min_handle; 155int vertical_scroll_bar_top_border; 156int vertical_scroll_bar_bottom_border; 157 158int last_scroll_bar_drag_pos; 159 160/* Mouse movement. */ 161 162/* Where the mouse was last time we reported a mouse event. */ 163 164static RECT last_mouse_glyph; 165static FRAME_PTR last_mouse_glyph_frame; 166static Lisp_Object last_mouse_press_frame; 167 168int w32_num_mouse_buttons; 169 170Lisp_Object Vw32_swap_mouse_buttons; 171 172/* Control whether x_raise_frame also sets input focus. */ 173Lisp_Object Vw32_grab_focus_on_raise; 174 175/* Control whether Caps Lock affects non-ascii characters. */ 176Lisp_Object Vw32_capslock_is_shiftlock; 177 178/* Control whether right-alt and left-ctrl should be recognized as AltGr. */ 179Lisp_Object Vw32_recognize_altgr; 180 181/* The scroll bar in which the last motion event occurred. 182 183 If the last motion event occurred in a scroll bar, we set this 184 so w32_mouse_position can know whether to report a scroll bar motion or 185 an ordinary motion. 186 187 If the last motion event didn't occur in a scroll bar, we set this 188 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */ 189static Lisp_Object last_mouse_scroll_bar; 190static int last_mouse_scroll_bar_pos; 191 192/* This is a hack. We would really prefer that w32_mouse_position would 193 return the time associated with the position it returns, but there 194 doesn't seem to be any way to wrest the time-stamp from the server 195 along with the position query. So, we just keep track of the time 196 of the last movement we received, and return that in hopes that 197 it's somewhat accurate. */ 198 199static Time last_mouse_movement_time; 200 201/* Incremented by w32_read_socket whenever it really tries to read 202 events. */ 203 204#ifdef __STDC__ 205static int volatile input_signal_count; 206#else 207static int input_signal_count; 208#endif 209 210extern Lisp_Object Vcommand_line_args, Vsystem_name; 211 212#ifndef USE_CRT_DLL 213extern int errno; 214#endif 215 216/* A mask of extra modifier bits to put into every keyboard char. */ 217 218extern EMACS_INT extra_keyboard_modifiers; 219 220static void x_update_window_end P_ ((struct window *, int, int)); 221void w32_delete_display P_ ((struct w32_display_info *)); 222static void w32_handle_tool_bar_click P_ ((struct frame *, 223 struct input_event *)); 224void w32_define_cursor P_ ((Window, Cursor)); 225 226void x_lower_frame P_ ((struct frame *)); 227void x_scroll_bar_clear P_ ((struct frame *)); 228void x_wm_set_size_hint P_ ((struct frame *, long, int)); 229void x_raise_frame P_ ((struct frame *)); 230void x_set_window_size P_ ((struct frame *, int, int, int)); 231void x_wm_set_window_state P_ ((struct frame *, int)); 232void x_wm_set_icon_pixmap P_ ((struct frame *, int)); 233void w32_initialize P_ ((void)); 234static void x_font_min_bounds P_ ((XFontStruct *, int *, int *)); 235int x_compute_min_glyph_bounds P_ ((struct frame *)); 236static void x_update_end P_ ((struct frame *)); 237static void w32_frame_up_to_date P_ ((struct frame *)); 238static void w32_set_terminal_modes P_ ((void)); 239static void w32_reset_terminal_modes P_ ((void)); 240static void x_clear_frame P_ ((void)); 241static void frame_highlight P_ ((struct frame *)); 242static void frame_unhighlight P_ ((struct frame *)); 243static void x_new_focus_frame P_ ((struct w32_display_info *, 244 struct frame *)); 245static void x_focus_changed P_ ((int, int, struct w32_display_info *, 246 struct frame *, struct input_event *)); 247static void w32_detect_focus_change P_ ((struct w32_display_info *, 248 W32Msg *, struct input_event *)); 249static void w32_frame_rehighlight P_ ((struct frame *)); 250static void x_frame_rehighlight P_ ((struct w32_display_info *)); 251static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *)); 252static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int, 253 enum text_cursor_kinds)); 254static void w32_clip_to_row P_ ((struct window *, struct glyph_row *, int, HDC)); 255static BOOL my_show_window P_ ((struct frame *, HWND, int)); 256static void my_set_window_pos P_ ((HWND, HWND, int, int, int, int, UINT)); 257static void my_set_focus P_ ((struct frame *, HWND)); 258static void my_set_foreground_window P_ ((HWND)); 259static void my_destroy_window P_ ((struct frame *, HWND)); 260 261static Lisp_Object Qvendor_specific_keysyms; 262 263 264/*********************************************************************** 265 Debugging 266 ***********************************************************************/ 267 268#if 0 269 270/* This is a function useful for recording debugging information about 271 the sequence of occurrences in this file. */ 272 273struct record 274{ 275 char *locus; 276 int type; 277}; 278 279struct record event_record[100]; 280 281int event_record_index; 282 283record_event (locus, type) 284 char *locus; 285 int type; 286{ 287 if (event_record_index == sizeof (event_record) / sizeof (struct record)) 288 event_record_index = 0; 289 290 event_record[event_record_index].locus = locus; 291 event_record[event_record_index].type = type; 292 event_record_index++; 293} 294 295#endif /* 0 */ 296 297 298void 299XChangeGC (void * ignore, XGCValues* gc, unsigned long mask, 300 XGCValues *xgcv) 301{ 302 if (mask & GCForeground) 303 gc->foreground = xgcv->foreground; 304 if (mask & GCBackground) 305 gc->background = xgcv->background; 306 if (mask & GCFont) 307 gc->font = xgcv->font; 308} 309 310XGCValues *XCreateGC (void * ignore, Window window, unsigned long mask, 311 XGCValues *xgcv) 312{ 313 XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues)); 314 bzero (gc, sizeof (XGCValues)); 315 316 XChangeGC (ignore, gc, mask, xgcv); 317 318 return gc; 319} 320 321void 322XGetGCValues (void* ignore, XGCValues *gc, 323 unsigned long mask, XGCValues *xgcv) 324{ 325 XChangeGC (ignore, xgcv, mask, gc); 326} 327 328static void 329w32_set_clip_rectangle (HDC hdc, RECT *rect) 330{ 331 if (rect) 332 { 333 HRGN clip_region = CreateRectRgnIndirect (rect); 334 SelectClipRgn (hdc, clip_region); 335 DeleteObject (clip_region); 336 } 337 else 338 SelectClipRgn (hdc, NULL); 339} 340 341 342/* Draw a hollow rectangle at the specified position. */ 343void 344w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y, 345 int width, int height) 346{ 347 HBRUSH hb, oldhb; 348 HPEN hp, oldhp; 349 350 hb = CreateSolidBrush (gc->background); 351 hp = CreatePen (PS_SOLID, 0, gc->foreground); 352 oldhb = SelectObject (hdc, hb); 353 oldhp = SelectObject (hdc, hp); 354 355 Rectangle (hdc, x, y, x + width, y + height); 356 357 SelectObject (hdc, oldhb); 358 SelectObject (hdc, oldhp); 359 DeleteObject (hb); 360 DeleteObject (hp); 361} 362 363/* Draw a filled rectangle at the specified position. */ 364void 365w32_fill_rect (f, hdc, pix, lprect) 366 FRAME_PTR f; 367 HDC hdc; 368 COLORREF pix; 369 RECT * lprect; 370{ 371 HBRUSH hb; 372 373 hb = CreateSolidBrush (pix); 374 FillRect (hdc, lprect, hb); 375 DeleteObject (hb); 376} 377 378void 379w32_clear_window (f) 380 FRAME_PTR f; 381{ 382 RECT rect; 383 HDC hdc = get_frame_dc (f); 384 385 /* Under certain conditions, this can be called at startup with 386 a console frame pointer before the GUI frame is created. An HDC 387 of 0 indicates this. */ 388 if (hdc) 389 { 390 GetClientRect (FRAME_W32_WINDOW (f), &rect); 391 w32_clear_rect (f, hdc, &rect); 392 } 393 394 release_frame_dc (f, hdc); 395} 396 397 398/*********************************************************************** 399 Starting and ending an update 400 ***********************************************************************/ 401 402/* Start an update of frame F. This function is installed as a hook 403 for update_begin, i.e. it is called when update_begin is called. 404 This function is called prior to calls to x_update_window_begin for 405 each window being updated. */ 406 407static void 408x_update_begin (f) 409 struct frame *f; 410{ 411 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f); 412 413 if (! FRAME_W32_P (f)) 414 return; 415 416 /* Regenerate display palette before drawing if list of requested 417 colors has changed. */ 418 if (display_info->regen_palette) 419 { 420 w32_regenerate_palette (f); 421 display_info->regen_palette = FALSE; 422 } 423} 424 425 426/* Start update of window W. Set the global variable updated_window 427 to the window being updated and set output_cursor to the cursor 428 position of W. */ 429 430static void 431x_update_window_begin (w) 432 struct window *w; 433{ 434 struct frame *f = XFRAME (WINDOW_FRAME (w)); 435 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f); 436 437 /* Hide the system caret during an update. */ 438 if (w32_use_visible_system_caret && w32_system_caret_hwnd) 439 { 440 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0); 441 } 442 443 updated_window = w; 444 set_output_cursor (&w->cursor); 445 446 BLOCK_INPUT; 447 448 if (f == display_info->mouse_face_mouse_frame) 449 { 450 /* Don't do highlighting for mouse motion during the update. */ 451 display_info->mouse_face_defer = 1; 452 453 /* If F needs to be redrawn, simply forget about any prior mouse 454 highlighting. */ 455 if (FRAME_GARBAGED_P (f)) 456 display_info->mouse_face_window = Qnil; 457 458#if 0 /* Rows in a current matrix containing glyphs in mouse-face have 459 their mouse_face_p flag set, which means that they are always 460 unequal to rows in a desired matrix which never have that 461 flag set. So, rows containing mouse-face glyphs are never 462 scrolled, and we don't have to switch the mouse highlight off 463 here to prevent it from being scrolled. */ 464 465 /* Can we tell that this update does not affect the window 466 where the mouse highlight is? If so, no need to turn off. 467 Likewise, don't do anything if the frame is garbaged; 468 in that case, the frame's current matrix that we would use 469 is all wrong, and we will redisplay that line anyway. */ 470 if (!NILP (display_info->mouse_face_window) 471 && w == XWINDOW (display_info->mouse_face_window)) 472 { 473 int i; 474 475 for (i = 0; i < w->desired_matrix->nrows; ++i) 476 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i)) 477 break; 478 479 if (i < w->desired_matrix->nrows) 480 clear_mouse_face (display_info); 481 } 482#endif /* 0 */ 483 } 484 485 UNBLOCK_INPUT; 486} 487 488/* Draw a vertical window border from (x,y0) to (x,y1) */ 489 490static void 491w32_draw_vertical_window_border (w, x, y0, y1) 492 struct window *w; 493 int x, y0, y1; 494{ 495 struct frame *f = XFRAME (WINDOW_FRAME (w)); 496 RECT r; 497 HDC hdc; 498 struct face *face; 499 500 r.left = x; 501 r.right = x + 1; 502 r.top = y0; 503 r.bottom = y1; 504 505 hdc = get_frame_dc (f); 506 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID); 507 if (face) 508 w32_fill_rect (f, hdc, face->foreground, &r); 509 else 510 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r); 511 512 release_frame_dc (f, hdc); 513} 514 515 516/* End update of window W (which is equal to updated_window). 517 518 Draw vertical borders between horizontally adjacent windows, and 519 display W's cursor if CURSOR_ON_P is non-zero. 520 521 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing 522 glyphs in mouse-face were overwritten. In that case we have to 523 make sure that the mouse-highlight is properly redrawn. 524 525 W may be a menu bar pseudo-window in case we don't have X toolkit 526 support. Such windows don't have a cursor, so don't display it 527 here. */ 528 529static void 530x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p) 531 struct window *w; 532 int cursor_on_p, mouse_face_overwritten_p; 533{ 534 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (XFRAME (w->frame)); 535 536 if (!w->pseudo_window_p) 537 { 538 BLOCK_INPUT; 539 540 if (cursor_on_p) 541 display_and_set_cursor (w, 1, output_cursor.hpos, 542 output_cursor.vpos, 543 output_cursor.x, output_cursor.y); 544 545 if (draw_window_fringes (w, 1)) 546 x_draw_vertical_border (w); 547 548 UNBLOCK_INPUT; 549 } 550 551 /* If a row with mouse-face was overwritten, arrange for 552 XTframe_up_to_date to redisplay the mouse highlight. */ 553 if (mouse_face_overwritten_p) 554 { 555 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1; 556 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1; 557 dpyinfo->mouse_face_window = Qnil; 558 } 559 560 /* Unhide the caret. This won't actually show the cursor, unless it 561 was visible before the corresponding call to HideCaret in 562 x_update_window_begin. */ 563 if (w32_use_visible_system_caret && w32_system_caret_hwnd) 564 { 565 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0); 566 } 567 568 updated_window = NULL; 569} 570 571 572/* End update of frame F. This function is installed as a hook in 573 update_end. */ 574 575static void 576x_update_end (f) 577 struct frame *f; 578{ 579 if (! FRAME_W32_P (f)) 580 return; 581 582 /* Mouse highlight may be displayed again. */ 583 FRAME_W32_DISPLAY_INFO (f)->mouse_face_defer = 0; 584} 585 586 587/* This function is called from various places in xdisp.c whenever a 588 complete update has been performed. The global variable 589 updated_window is not available here. */ 590 591static void 592w32_frame_up_to_date (f) 593 struct frame *f; 594{ 595 if (FRAME_W32_P (f)) 596 { 597 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 598 599 if (dpyinfo->mouse_face_deferred_gc 600 || f == dpyinfo->mouse_face_mouse_frame) 601 { 602 BLOCK_INPUT; 603 if (dpyinfo->mouse_face_mouse_frame) 604 note_mouse_highlight (dpyinfo->mouse_face_mouse_frame, 605 dpyinfo->mouse_face_mouse_x, 606 dpyinfo->mouse_face_mouse_y); 607 dpyinfo->mouse_face_deferred_gc = 0; 608 UNBLOCK_INPUT; 609 } 610 } 611} 612 613 614/* Draw truncation mark bitmaps, continuation mark bitmaps, overlay 615 arrow bitmaps, or clear the fringes if no bitmaps are required 616 before DESIRED_ROW is made current. The window being updated is 617 found in updated_window. This function is called from 618 update_window_line only if it is known that there are differences 619 between bitmaps to be drawn between current row and DESIRED_ROW. */ 620 621static void 622x_after_update_window_line (desired_row) 623 struct glyph_row *desired_row; 624{ 625 struct window *w = updated_window; 626 struct frame *f; 627 int width, height; 628 629 xassert (w); 630 631 if (!desired_row->mode_line_p && !w->pseudo_window_p) 632 desired_row->redraw_fringe_bitmaps_p = 1; 633 634 /* When a window has disappeared, make sure that no rest of 635 full-width rows stays visible in the internal border. Could 636 check here if updated_window is the leftmost/rightmost window, 637 but I guess it's not worth doing since vertically split windows 638 are almost never used, internal border is rarely set, and the 639 overhead is very small. */ 640 if (windows_or_buffers_changed 641 && desired_row->full_width_p 642 && (f = XFRAME (w->frame), 643 width = FRAME_INTERNAL_BORDER_WIDTH (f), 644 width != 0) 645 && (height = desired_row->visible_height, 646 height > 0)) 647 { 648 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y)); 649 650 /* Internal border is drawn below the tool bar. */ 651 if (WINDOWP (f->tool_bar_window) 652 && w == XWINDOW (f->tool_bar_window)) 653 y -= width; 654 655 BLOCK_INPUT; 656 { 657 HDC hdc = get_frame_dc (f); 658 w32_clear_area (f, hdc, 0, y, width, height); 659 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width, 660 y, width, height); 661 release_frame_dc (f, hdc); 662 } 663 UNBLOCK_INPUT; 664 } 665} 666 667 668/* Draw the bitmap WHICH in one of the left or right fringes of 669 window W. ROW is the glyph row for which to display the bitmap; it 670 determines the vertical position at which the bitmap has to be 671 drawn. */ 672 673static void 674w32_draw_fringe_bitmap (w, row, p) 675 struct window *w; 676 struct glyph_row *row; 677 struct draw_fringe_bitmap_params *p; 678{ 679 struct frame *f = XFRAME (WINDOW_FRAME (w)); 680 HDC hdc; 681 struct face *face = p->face; 682 int rowY; 683 684 hdc = get_frame_dc (f); 685 686 /* Must clip because of partially visible lines. */ 687 rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y); 688 if (p->y < rowY) 689 { 690 /* Adjust position of "bottom aligned" bitmap on partially 691 visible last row. */ 692 int oldY = row->y; 693 int oldVH = row->visible_height; 694 row->visible_height = p->h; 695 row->y -= rowY - p->y; 696 w32_clip_to_row (w, row, -1, hdc); 697 row->y = oldY; 698 row->visible_height = oldVH; 699 } 700 else 701 w32_clip_to_row (w, row, -1, hdc); 702 703 if (p->bx >= 0 && !p->overlay_p) 704 { 705 w32_fill_area (f, hdc, face->background, 706 p->bx, p->by, p->nx, p->ny); 707 } 708 709 if (p->which && p->which < max_fringe_bmp) 710 { 711 HBITMAP pixmap = fringe_bmp[p->which]; 712 HDC compat_hdc; 713 HANDLE horig_obj; 714 715 compat_hdc = CreateCompatibleDC (hdc); 716 717 SaveDC (hdc); 718 719 horig_obj = SelectObject (compat_hdc, pixmap); 720 721 /* Paint overlays transparently. */ 722 if (p->overlay_p) 723 { 724 HBRUSH h_brush, h_orig_brush; 725 726 SetTextColor (hdc, BLACK_PIX_DEFAULT (f)); 727 SetBkColor (hdc, WHITE_PIX_DEFAULT (f)); 728 h_brush = CreateSolidBrush (face->foreground); 729 h_orig_brush = SelectObject (hdc, h_brush); 730 731 BitBlt (hdc, p->x, p->y, p->wd, p->h, 732 compat_hdc, 0, p->dh, 733 DSTINVERT); 734 BitBlt (hdc, p->x, p->y, p->wd, p->h, 735 compat_hdc, 0, p->dh, 736 0x2E064A); 737 BitBlt (hdc, p->x, p->y, p->wd, p->h, 738 compat_hdc, 0, p->dh, 739 DSTINVERT); 740 741 SelectObject (hdc, h_orig_brush); 742 DeleteObject (h_brush); 743 } 744 else 745 { 746 SetTextColor (hdc, face->background); 747 SetBkColor (hdc, (p->cursor_p 748 ? f->output_data.w32->cursor_pixel 749 : face->foreground)); 750 751 BitBlt (hdc, p->x, p->y, p->wd, p->h, 752 compat_hdc, 0, p->dh, 753 SRCCOPY); 754 } 755 756 SelectObject (compat_hdc, horig_obj); 757 DeleteDC (compat_hdc); 758 RestoreDC (hdc, -1); 759 } 760 761 w32_set_clip_rectangle (hdc, NULL); 762 763 release_frame_dc (f, hdc); 764} 765 766static void 767w32_define_fringe_bitmap (which, bits, h, wd) 768 int which; 769 unsigned short *bits; 770 int h, wd; 771{ 772 if (which >= max_fringe_bmp) 773 { 774 int i = max_fringe_bmp; 775 max_fringe_bmp = which + 20; 776 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP)); 777 while (i < max_fringe_bmp) 778 fringe_bmp[i++] = 0; 779 } 780 781 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits); 782} 783 784static void 785w32_destroy_fringe_bitmap (which) 786 int which; 787{ 788 if (which >= max_fringe_bmp) 789 return; 790 791 if (fringe_bmp[which]) 792 DeleteObject (fringe_bmp[which]); 793 fringe_bmp[which] = 0; 794} 795 796 797 798/* This is called when starting Emacs and when restarting after 799 suspend. When starting Emacs, no window is mapped. And nothing 800 must be done to Emacs's own window if it is suspended (though that 801 rarely happens). */ 802 803static void 804w32_set_terminal_modes (void) 805{ 806} 807 808/* This is called when exiting or suspending Emacs. Exiting will make 809 the W32 windows go away, and suspending requires no action. */ 810 811static void 812w32_reset_terminal_modes (void) 813{ 814} 815 816 817 818/*********************************************************************** 819 Display Iterator 820 ***********************************************************************/ 821 822/* Function prototypes of this page. */ 823 824XCharStruct *w32_per_char_metric P_ ((XFontStruct *, wchar_t *, int)); 825static int w32_encode_char P_ ((int, wchar_t *, struct font_info *, int *)); 826 827 828/* Get metrics of character CHAR2B in FONT. Value is always non-null. 829 If CHAR2B is not contained in FONT, the font's default character 830 metric is returned. */ 831 832static int 833w32_bdf_per_char_metric (font, char2b, dim, pcm) 834 XFontStruct *font; 835 wchar_t *char2b; 836 int dim; 837 XCharStruct * pcm; 838{ 839 glyph_metric * bdf_metric; 840 char buf[2]; 841 842 if (dim == 1) 843 buf[0] = (char)(*char2b); 844 else 845 { 846 buf[0] = XCHAR2B_BYTE1 (char2b); 847 buf[1] = XCHAR2B_BYTE2 (char2b); 848 } 849 850 bdf_metric = w32_BDF_TextMetric (font->bdf, buf, dim); 851 852 if (bdf_metric) 853 { 854 pcm->width = bdf_metric->dwidth; 855 pcm->lbearing = bdf_metric->bbox; 856 pcm->rbearing = bdf_metric->dwidth 857 - (bdf_metric->bbox + bdf_metric->bbw); 858 pcm->ascent = bdf_metric->bboy + bdf_metric->bbh; 859 pcm->descent = -bdf_metric->bboy; 860 861 return 1; 862 } 863 return 0; 864} 865 866 867static int 868w32_native_per_char_metric (font, char2b, font_type, pcm) 869 XFontStruct *font; 870 wchar_t *char2b; 871 enum w32_char_font_type font_type; 872 XCharStruct * pcm; 873{ 874 HDC hdc = GetDC (NULL); 875 HFONT old_font; 876 BOOL retval = FALSE; 877 878 xassert (font && char2b); 879 xassert (font->hfont); 880 xassert (font_type == UNICODE_FONT || font_type == ANSI_FONT); 881 882 old_font = SelectObject (hdc, font->hfont); 883 884 if ((font->tm.tmPitchAndFamily & TMPF_TRUETYPE) != 0) 885 { 886 ABC char_widths; 887 888 if (font_type == UNICODE_FONT) 889 retval = GetCharABCWidthsW (hdc, *char2b, *char2b, &char_widths); 890 else 891 retval = GetCharABCWidthsA (hdc, *char2b, *char2b, &char_widths); 892 893 if (retval) 894 { 895#if 0 896 /* Disabled until we can find a way to get the right results 897 on all versions of Windows. */ 898 899 /* Don't trust the ABC widths. For synthesized fonts they are 900 wrong, and so is the result of GetCharWidth()! */ 901 int real_width; 902 GetCharWidth (hdc, *char2b, *char2b, &real_width); 903#endif 904 if (cleartype_active) 905 { 906 /* Cleartype antialiasing causes characters to overhang 907 by a pixel on each side compared with what GetCharABCWidths 908 reports. */ 909 char_widths.abcA -= 1; 910 char_widths.abcC -= 1; 911 char_widths.abcB += 2; 912 } 913 914 pcm->width = char_widths.abcA + char_widths.abcB + char_widths.abcC; 915#if 0 916 /* As far as I can tell, this is the best way to determine what 917 ExtTextOut will do with the broken font. */ 918 if (pcm->width != real_width) 919 pcm->width = (pcm->width + real_width) / 2; 920#endif 921 pcm->lbearing = char_widths.abcA; 922 pcm->rbearing = char_widths.abcA + char_widths.abcB; 923 pcm->ascent = FONT_BASE (font); 924 pcm->descent = FONT_DESCENT (font); 925 } 926 } 927 928 if (!retval) 929 { 930 /* Either font is not a True-type font, or GetCharABCWidthsW 931 failed (it is not supported on Windows 9x for instance), so we 932 can't determine the full info we would like. All is not lost 933 though - we can call GetTextExtentPoint32 to get rbearing and 934 deduce width based on the font's per-string overhang. lbearing 935 is assumed to be zero. */ 936 937 /* TODO: Some Thai characters (and other composites if Windows 938 supports them) do have lbearing, and report their total width 939 as zero. Need some way of handling them when 940 GetCharABCWidthsW fails. */ 941 SIZE sz; 942 943 if (font_type == UNICODE_FONT) 944 retval = GetTextExtentPoint32W (hdc, char2b, 1, &sz); 945 else 946 retval = GetTextExtentPoint32A (hdc, (char*)char2b, 1, &sz); 947 948 if (retval) 949 { 950 pcm->width = sz.cx - font->tm.tmOverhang; 951 pcm->rbearing = sz.cx; 952 pcm->lbearing = 0; 953 pcm->ascent = FONT_BASE (font); 954 pcm->descent = FONT_DESCENT (font); 955 } 956 } 957 958 959 if (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0) 960 { 961 retval = FALSE; 962 } 963 964 SelectObject (hdc, old_font); 965 ReleaseDC (NULL, hdc); 966 967 return retval; 968} 969 970 971XCharStruct * 972w32_per_char_metric (font, char2b, font_type) 973 XFontStruct *font; 974 wchar_t *char2b; 975 int /* enum w32_char_font_type */ font_type; 976{ 977 /* The result metric information. */ 978 XCharStruct *pcm; 979 BOOL retval; 980 981 xassert (font && char2b); 982 983 /* TODO: This function is currently called through the RIF, and in 984 some cases font_type is UNKNOWN_FONT. We currently allow the 985 cached metrics to be used, which seems to work, but in cases 986 where font_type is UNKNOWN_FONT, we probably haven't encoded 987 char2b appropriately. All callers need checking to see what they 988 are passing. This is most likely to affect variable width fonts 989 outside the Latin-1 range, particularly in languages like Thai 990 that rely on rbearing and lbearing to provide composition. I 991 don't think that is working currently anyway, but we don't seem 992 to have anyone testing such languages on Windows. */ 993 994 /* Handle the common cases quickly. */ 995 if (!font->bdf && font->per_char == NULL) 996 /* TODO: determine whether char2b exists in font? */ 997 return &font->max_bounds; 998 else if (!font->bdf && *char2b < 128) 999 return &font->per_char[*char2b]; 1000 1001 xassert (font_type != UNKNOWN_FONT); 1002 1003 pcm = &font->scratch; 1004 1005 if (font_type == BDF_1D_FONT) 1006 retval = w32_bdf_per_char_metric (font, char2b, 1, pcm); 1007 else if (font_type == BDF_2D_FONT) 1008 retval = w32_bdf_per_char_metric (font, char2b, 2, pcm); 1009 else 1010 retval = w32_native_per_char_metric (font, char2b, font_type, pcm); 1011 1012 if (retval) 1013 return pcm; 1014 1015 return NULL; 1016} 1017 1018void 1019w32_cache_char_metrics (font) 1020 XFontStruct *font; 1021{ 1022 wchar_t char2b = L'x'; 1023 1024 /* Cache char metrics for the common cases. */ 1025 if (font->bdf) 1026 { 1027 /* TODO: determine whether font is fixed-pitch. */ 1028 if (!w32_bdf_per_char_metric (font, &char2b, 1, &font->max_bounds)) 1029 { 1030 /* Use the font width and height as max bounds, as not all BDF 1031 fonts contain the letter 'x'. */ 1032 font->max_bounds.width = FONT_MAX_WIDTH (font); 1033 font->max_bounds.lbearing = -font->bdf->llx; 1034 font->max_bounds.rbearing = FONT_MAX_WIDTH (font) - font->bdf->urx; 1035 font->max_bounds.ascent = FONT_BASE (font); 1036 font->max_bounds.descent = FONT_DESCENT (font); 1037 } 1038 } 1039 else 1040 { 1041 if (((font->tm.tmPitchAndFamily & TMPF_FIXED_PITCH) != 0) 1042 /* Some fonts (eg DBCS fonts) are marked as fixed width even 1043 though they contain characters of different widths. */ 1044 || (font->tm.tmMaxCharWidth != font->tm.tmAveCharWidth)) 1045 { 1046 /* Font is not fixed pitch, so cache per_char info for the 1047 ASCII characters. It would be much more work, and probably 1048 not worth it, to cache other chars, since we may change 1049 between using Unicode and ANSI text drawing functions at 1050 run-time. */ 1051 int i; 1052 1053 font->per_char = xmalloc (128 * sizeof(XCharStruct)); 1054 for (i = 0; i < 128; i++) 1055 { 1056 char2b = i; 1057 w32_native_per_char_metric (font, &char2b, ANSI_FONT, 1058 &font->per_char[i]); 1059 } 1060 } 1061 else 1062 w32_native_per_char_metric (font, &char2b, ANSI_FONT, 1063 &font->max_bounds); 1064 } 1065} 1066 1067 1068/* Determine if a font is double byte. */ 1069int w32_font_is_double_byte (XFontStruct *font) 1070{ 1071 return font->double_byte_p; 1072} 1073 1074 1075static BOOL 1076w32_use_unicode_for_codepage (codepage) 1077 int codepage; 1078{ 1079 /* If the current codepage is supported, use Unicode for output. */ 1080 return (w32_enable_unicode_output 1081 && codepage != CP_8BIT 1082 && (codepage == CP_UNICODE || IsValidCodePage (codepage))); 1083} 1084 1085/* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is 1086 the two-byte form of C. Encoding is returned in *CHAR2B. */ 1087 1088static int /* enum w32_char_font_type */ 1089w32_encode_char (c, char2b, font_info, two_byte_p) 1090 int c; 1091 wchar_t *char2b; 1092 struct font_info *font_info; 1093 int * two_byte_p; 1094{ 1095 int charset = CHAR_CHARSET (c); 1096 int codepage; 1097 int unicode_p = 0; 1098 int internal_two_byte_p = 0; 1099 1100 XFontStruct *font = font_info->font; 1101 1102 internal_two_byte_p = w32_font_is_double_byte (font); 1103 1104 /* FONT_INFO may define a scheme by which to encode byte1 and byte2. 1105 This may be either a program in a special encoder language or a 1106 fixed encoding. */ 1107 if (font_info->font_encoder) 1108 { 1109 /* It's a program. */ 1110 struct ccl_program *ccl = font_info->font_encoder; 1111 1112 if (CHARSET_DIMENSION (charset) == 1) 1113 { 1114 ccl->reg[0] = charset; 1115 ccl->reg[1] = XCHAR2B_BYTE2 (char2b); 1116 ccl->reg[2] = -1; 1117 } 1118 else 1119 { 1120 ccl->reg[0] = charset; 1121 ccl->reg[1] = XCHAR2B_BYTE1 (char2b); 1122 ccl->reg[2] = XCHAR2B_BYTE2 (char2b); 1123 } 1124 1125 ccl_driver (ccl, NULL, NULL, 0, 0, NULL); 1126 1127 /* We assume that MSBs are appropriately set/reset by CCL 1128 program. */ 1129 if (!internal_two_byte_p) /* 1-byte font */ 1130 STORE_XCHAR2B (char2b, 0, ccl->reg[1]); 1131 else 1132 STORE_XCHAR2B (char2b, ccl->reg[1], ccl->reg[2]); 1133 } 1134 else if (font_info->encoding[charset]) 1135 { 1136 /* Fixed encoding scheme. See fontset.h for the meaning of the 1137 encoding numbers. */ 1138 int enc = font_info->encoding[charset]; 1139 1140 if ((enc == 1 || enc == 2) 1141 && CHARSET_DIMENSION (charset) == 2) 1142 STORE_XCHAR2B (char2b, XCHAR2B_BYTE1 (char2b) | 0x80, XCHAR2B_BYTE2 (char2b)); 1143 1144 if (enc == 1 || enc == 3 1145 || (enc == 4 && CHARSET_DIMENSION (charset) == 1)) 1146 STORE_XCHAR2B (char2b, XCHAR2B_BYTE1 (char2b), XCHAR2B_BYTE2 (char2b) | 0x80); 1147 else if (enc == 4) 1148 { 1149 int sjis1, sjis2; 1150 1151 ENCODE_SJIS (XCHAR2B_BYTE1 (char2b), XCHAR2B_BYTE2 (char2b), 1152 sjis1, sjis2); 1153 STORE_XCHAR2B (char2b, sjis1, sjis2); 1154 } 1155 } 1156 codepage = font_info->codepage; 1157 1158 /* If charset is not ASCII or Latin-1, may need to move it into 1159 Unicode space. */ 1160 if ( font && !font->bdf && w32_use_unicode_for_codepage (codepage) 1161 && charset != CHARSET_ASCII && charset != charset_latin_iso8859_1 1162 && charset != CHARSET_8_BIT_CONTROL && charset != CHARSET_8_BIT_GRAPHIC) 1163 { 1164 char temp[3]; 1165 temp[0] = XCHAR2B_BYTE1 (char2b); 1166 temp[1] = XCHAR2B_BYTE2 (char2b); 1167 temp[2] = '\0'; 1168 if (codepage != CP_UNICODE) 1169 { 1170 if (temp[0]) 1171 MultiByteToWideChar (codepage, 0, temp, 2, char2b, 1); 1172 else 1173 MultiByteToWideChar (codepage, 0, temp+1, 1, char2b, 1); 1174 } 1175 unicode_p = 1; 1176 internal_two_byte_p = 1; 1177 } 1178 1179 if (two_byte_p) 1180 *two_byte_p = internal_two_byte_p; 1181 1182 if (!font) 1183 return UNKNOWN_FONT; 1184 else if (font->bdf && CHARSET_DIMENSION (charset) == 1) 1185 return BDF_1D_FONT; 1186 else if (font->bdf) 1187 return BDF_2D_FONT; 1188 else if (unicode_p) 1189 return UNICODE_FONT; 1190 else 1191 return ANSI_FONT; 1192} 1193 1194 1195 1196/*********************************************************************** 1197 Glyph display 1198 ***********************************************************************/ 1199 1200 1201/* Encapsulate the different ways of displaying text under W32. */ 1202 1203static void 1204w32_text_out (s, x, y,chars,nchars) 1205 struct glyph_string * s; 1206 int x, y; 1207 wchar_t * chars; 1208 int nchars; 1209{ 1210 int charset_dim = w32_font_is_double_byte (s->font) ? 2 : 1; 1211 if (s->font->bdf) 1212 w32_BDF_TextOut (s->font->bdf, s->hdc, 1213 x, y, (char *) chars, charset_dim, 1214 nchars * charset_dim, 0); 1215 else if (s->first_glyph->font_type == UNICODE_FONT) 1216 ExtTextOutW (s->hdc, x, y, 0, NULL, chars, nchars, NULL); 1217 else 1218 ExtTextOutA (s->hdc, x, y, 0, NULL, (char *) chars, 1219 nchars * charset_dim, NULL); 1220} 1221 1222 1223static void x_set_glyph_string_clipping P_ ((struct glyph_string *)); 1224static void x_set_glyph_string_gc P_ ((struct glyph_string *)); 1225static void x_draw_glyph_string_background P_ ((struct glyph_string *, 1226 int)); 1227static void x_draw_glyph_string_foreground P_ ((struct glyph_string *)); 1228static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *)); 1229static void x_draw_glyph_string_box P_ ((struct glyph_string *)); 1230static void x_draw_glyph_string P_ ((struct glyph_string *)); 1231static void x_set_cursor_gc P_ ((struct glyph_string *)); 1232static void x_set_mode_line_face_gc P_ ((struct glyph_string *)); 1233static void x_set_mouse_face_gc P_ ((struct glyph_string *)); 1234static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int); 1235static void w32_setup_relief_color P_ ((struct frame *, struct relief *, 1236 double, int, COLORREF)); 1237static void x_setup_relief_colors P_ ((struct glyph_string *)); 1238static void x_draw_image_glyph_string P_ ((struct glyph_string *)); 1239static void x_draw_image_relief P_ ((struct glyph_string *)); 1240static void x_draw_image_foreground P_ ((struct glyph_string *)); 1241static void w32_draw_image_foreground_1 P_ ((struct glyph_string *, HBITMAP)); 1242static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int, 1243 int, int, int)); 1244static void w32_draw_relief_rect P_ ((struct frame *, int, int, int, int, 1245 int, int, int, int, int, int, 1246 RECT *)); 1247static void w32_draw_box_rect P_ ((struct glyph_string *, int, int, int, int, 1248 int, int, int, RECT *)); 1249 1250#if GLYPH_DEBUG 1251static void x_check_font P_ ((struct frame *, XFontStruct *)); 1252#endif 1253 1254 1255/* Set S->gc to a suitable GC for drawing glyph string S in cursor 1256 face. */ 1257 1258static void 1259x_set_cursor_gc (s) 1260 struct glyph_string *s; 1261{ 1262 if (s->font == FRAME_FONT (s->f) 1263 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f) 1264 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f) 1265 && !s->cmp) 1266 s->gc = s->f->output_data.w32->cursor_gc; 1267 else 1268 { 1269 /* Cursor on non-default face: must merge. */ 1270 XGCValues xgcv; 1271 unsigned long mask; 1272 1273 xgcv.background = s->f->output_data.w32->cursor_pixel; 1274 xgcv.foreground = s->face->background; 1275 1276 /* If the glyph would be invisible, try a different foreground. */ 1277 if (xgcv.foreground == xgcv.background) 1278 xgcv.foreground = s->face->foreground; 1279 if (xgcv.foreground == xgcv.background) 1280 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel; 1281 if (xgcv.foreground == xgcv.background) 1282 xgcv.foreground = s->face->foreground; 1283 1284 /* Make sure the cursor is distinct from text in this face. */ 1285 if (xgcv.background == s->face->background 1286 && xgcv.foreground == s->face->foreground) 1287 { 1288 xgcv.background = s->face->foreground; 1289 xgcv.foreground = s->face->background; 1290 } 1291 1292 IF_DEBUG (x_check_font (s->f, s->font)); 1293 xgcv.font = s->font; 1294 mask = GCForeground | GCBackground | GCFont; 1295 1296 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc) 1297 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc, 1298 mask, &xgcv); 1299 else 1300 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc 1301 = XCreateGC (NULL, s->window, mask, &xgcv); 1302 1303 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc; 1304 } 1305} 1306 1307 1308/* Set up S->gc of glyph string S for drawing text in mouse face. */ 1309 1310static void 1311x_set_mouse_face_gc (s) 1312 struct glyph_string *s; 1313{ 1314 int face_id; 1315 struct face *face; 1316 1317 /* What face has to be used last for the mouse face? */ 1318 face_id = FRAME_W32_DISPLAY_INFO (s->f)->mouse_face_face_id; 1319 face = FACE_FROM_ID (s->f, face_id); 1320 if (face == NULL) 1321 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID); 1322 1323 if (s->first_glyph->type == CHAR_GLYPH) 1324 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch); 1325 else 1326 face_id = FACE_FOR_CHAR (s->f, face, 0); 1327 s->face = FACE_FROM_ID (s->f, face_id); 1328 PREPARE_FACE_FOR_DISPLAY (s->f, s->face); 1329 1330 /* If font in this face is same as S->font, use it. */ 1331 if (s->font == s->face->font) 1332 s->gc = s->face->gc; 1333 else 1334 { 1335 /* Otherwise construct scratch_cursor_gc with values from FACE 1336 but font FONT. */ 1337 XGCValues xgcv; 1338 unsigned long mask; 1339 1340 xgcv.background = s->face->background; 1341 xgcv.foreground = s->face->foreground; 1342 IF_DEBUG (x_check_font (s->f, s->font)); 1343 xgcv.font = s->font; 1344 mask = GCForeground | GCBackground | GCFont; 1345 1346 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc) 1347 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc, 1348 mask, &xgcv); 1349 else 1350 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc 1351 = XCreateGC (NULL, s->window, mask, &xgcv); 1352 1353 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc; 1354 } 1355 1356 xassert (s->gc != 0); 1357} 1358 1359 1360/* Set S->gc of glyph string S to a GC suitable for drawing a mode line. 1361 Faces to use in the mode line have already been computed when the 1362 matrix was built, so there isn't much to do, here. */ 1363 1364static INLINE void 1365x_set_mode_line_face_gc (s) 1366 struct glyph_string *s; 1367{ 1368 s->gc = s->face->gc; 1369} 1370 1371 1372/* Set S->gc of glyph string S for drawing that glyph string. Set 1373 S->stippled_p to a non-zero value if the face of S has a stipple 1374 pattern. */ 1375 1376static INLINE void 1377x_set_glyph_string_gc (s) 1378 struct glyph_string *s; 1379{ 1380 PREPARE_FACE_FOR_DISPLAY (s->f, s->face); 1381 1382 if (s->hl == DRAW_NORMAL_TEXT) 1383 { 1384 s->gc = s->face->gc; 1385 s->stippled_p = s->face->stipple != 0; 1386 } 1387 else if (s->hl == DRAW_INVERSE_VIDEO) 1388 { 1389 x_set_mode_line_face_gc (s); 1390 s->stippled_p = s->face->stipple != 0; 1391 } 1392 else if (s->hl == DRAW_CURSOR) 1393 { 1394 x_set_cursor_gc (s); 1395 s->stippled_p = 0; 1396 } 1397 else if (s->hl == DRAW_MOUSE_FACE) 1398 { 1399 x_set_mouse_face_gc (s); 1400 s->stippled_p = s->face->stipple != 0; 1401 } 1402 else if (s->hl == DRAW_IMAGE_RAISED 1403 || s->hl == DRAW_IMAGE_SUNKEN) 1404 { 1405 s->gc = s->face->gc; 1406 s->stippled_p = s->face->stipple != 0; 1407 } 1408 else 1409 { 1410 s->gc = s->face->gc; 1411 s->stippled_p = s->face->stipple != 0; 1412 } 1413 1414 /* GC must have been set. */ 1415 xassert (s->gc != 0); 1416} 1417 1418 1419/* Set clipping for output of glyph string S. S may be part of a mode 1420 line or menu if we don't have X toolkit support. */ 1421 1422static INLINE void 1423x_set_glyph_string_clipping (s) 1424 struct glyph_string *s; 1425{ 1426 RECT r; 1427 get_glyph_string_clip_rect (s, &r); 1428 w32_set_clip_rectangle (s->hdc, &r); 1429} 1430 1431 1432/* RIF: 1433 Compute left and right overhang of glyph string S. If S is a glyph 1434 string for a composition, assume overhangs don't exist. */ 1435 1436static void 1437w32_compute_glyph_string_overhangs (s) 1438 struct glyph_string *s; 1439{ 1440 /* TODO: Windows does not appear to have a method for 1441 getting this info without getting the ABC widths for each 1442 individual character and working it out manually. */ 1443} 1444 1445 1446static void 1447w32_get_glyph_overhangs (glyph, f, left, right) 1448 struct glyph *glyph; 1449 struct frame *f; 1450 int *left, *right; 1451{ 1452 HDC hdc = get_frame_dc (f); 1453 /* Convert to unicode! */ 1454 x_get_glyph_overhangs (glyph, f, left, right); 1455 release_frame_dc (f, hdc); 1456} 1457 1458 1459/* Fill rectangle X, Y, W, H with background color of glyph string S. */ 1460 1461static INLINE void 1462x_clear_glyph_string_rect (s, x, y, w, h) 1463 struct glyph_string *s; 1464 int x, y, w, h; 1465{ 1466 int real_x = x; 1467 int real_y = y; 1468 int real_w = w; 1469 int real_h = h; 1470#if 0 1471 /* Take clipping into account. */ 1472 if (s->gc->clip_mask == Rect) 1473 { 1474 real_x = max (real_x, s->gc->clip_rectangle.left); 1475 real_y = max (real_y, s->gc->clip_rectangle.top); 1476 real_w = min (real_w, s->gc->clip_rectangle.right 1477 - s->gc->clip_rectangle.left); 1478 real_h = min (real_h, s->gc->clip_rectangle.bottom 1479 - s->gc->clip_rectangle.top); 1480 } 1481#endif 1482 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y, 1483 real_w, real_h); 1484} 1485 1486 1487/* Draw the background of glyph_string S. If S->background_filled_p 1488 is non-zero don't draw it. FORCE_P non-zero means draw the 1489 background even if it wouldn't be drawn normally. This is used 1490 when a string preceding S draws into the background of S, or S 1491 contains the first component of a composition. */ 1492 1493static void 1494x_draw_glyph_string_background (s, force_p) 1495 struct glyph_string *s; 1496 int force_p; 1497{ 1498 /* Nothing to do if background has already been drawn or if it 1499 shouldn't be drawn in the first place. */ 1500 if (!s->background_filled_p) 1501 { 1502 int box_line_width = max (s->face->box_line_width, 0); 1503 1504#if 0 /* TODO: stipple */ 1505 if (s->stippled_p) 1506 { 1507 /* Fill background with a stipple pattern. */ 1508 XSetFillStyle (s->display, s->gc, FillOpaqueStippled); 1509 XFillRectangle (s->display, s->window, s->gc, s->x, 1510 s->y + box_line_width, 1511 s->background_width, 1512 s->height - 2 * box_line_width); 1513 XSetFillStyle (s->display, s->gc, FillSolid); 1514 s->background_filled_p = 1; 1515 } 1516 else 1517#endif 1518 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width 1519 || s->font_not_found_p 1520 || s->extends_to_end_of_line_p 1521 || s->font->bdf 1522 || force_p) 1523 { 1524 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width, 1525 s->background_width, 1526 s->height - 2 * box_line_width); 1527 s->background_filled_p = 1; 1528 } 1529 } 1530} 1531 1532 1533/* Draw the foreground of glyph string S. */ 1534 1535static void 1536x_draw_glyph_string_foreground (s) 1537 struct glyph_string *s; 1538{ 1539 int i, x; 1540 HFONT old_font; 1541 1542 /* If first glyph of S has a left box line, start drawing the text 1543 of S to the right of that box line. */ 1544 if (s->face->box != FACE_NO_BOX 1545 && s->first_glyph->left_box_line_p) 1546 x = s->x + abs (s->face->box_line_width); 1547 else 1548 x = s->x; 1549 1550 if (s->for_overlaps || (s->background_filled_p && s->hl != DRAW_CURSOR)) 1551 SetBkMode (s->hdc, TRANSPARENT); 1552 else 1553 SetBkMode (s->hdc, OPAQUE); 1554 1555 SetTextColor (s->hdc, s->gc->foreground); 1556 SetBkColor (s->hdc, s->gc->background); 1557 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT); 1558 1559 if (s->font && s->font->hfont) 1560 old_font = SelectObject (s->hdc, s->font->hfont); 1561 1562 /* Draw characters of S as rectangles if S's font could not be 1563 loaded. */ 1564 if (s->font_not_found_p) 1565 { 1566 for (i = 0; i < s->nchars; ++i) 1567 { 1568 struct glyph *g = s->first_glyph + i; 1569 1570 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1, 1571 s->height - 1); 1572 x += g->pixel_width; 1573 } 1574 } 1575 else 1576 { 1577 char *char1b = (char *) s->char2b; 1578 int boff = s->font_info->baseline_offset; 1579 1580 if (s->font_info->vertical_centering) 1581 boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff; 1582 1583 /* If we can use 8-bit functions, condense S->char2b. */ 1584 if (!s->two_byte_p) 1585 for (i = 0; i < s->nchars; ++i) 1586 char1b[i] = XCHAR2B_BYTE2 (&s->char2b[i]); 1587 1588 /* Draw text with TextOut and friends. */ 1589 w32_text_out (s, x, s->ybase - boff, s->char2b, s->nchars); 1590 1591 if (s->face->overstrike) 1592 { 1593 /* For overstriking (to simulate bold-face), draw the 1594 characters again shifted to the right by one pixel. */ 1595 int old_BkMode = SetBkMode (s->hdc, TRANSPARENT); 1596 w32_text_out (s, x + 1, s->ybase - boff, s->char2b, s->nchars); 1597 if (old_BkMode && old_BkMode != TRANSPARENT) 1598 SetBkMode (s->hdc, old_BkMode); 1599 } 1600 } 1601 if (s->font && s->font->hfont) 1602 SelectObject (s->hdc, old_font); 1603} 1604 1605/* Draw the foreground of composite glyph string S. */ 1606 1607static void 1608x_draw_composite_glyph_string_foreground (s) 1609 struct glyph_string *s; 1610{ 1611 int i, x; 1612 HFONT old_font; 1613 1614 /* If first glyph of S has a left box line, start drawing the text 1615 of S to the right of that box line. */ 1616 if (s->face->box != FACE_NO_BOX 1617 && s->first_glyph->left_box_line_p) 1618 x = s->x + abs (s->face->box_line_width); 1619 else 1620 x = s->x; 1621 1622 /* S is a glyph string for a composition. S->gidx is the index of 1623 the first character drawn for glyphs of this composition. 1624 S->gidx == 0 means we are drawing the very first character of 1625 this composition. */ 1626 1627 SetTextColor (s->hdc, s->gc->foreground); 1628 SetBkColor (s->hdc, s->gc->background); 1629 SetBkMode (s->hdc, TRANSPARENT); 1630 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT); 1631 1632 if (s->font && s->font->hfont) 1633 old_font = SelectObject (s->hdc, s->font->hfont); 1634 1635 /* Draw a rectangle for the composition if the font for the very 1636 first character of the composition could not be loaded. */ 1637 if (s->font_not_found_p) 1638 { 1639 if (s->gidx == 0) 1640 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1, 1641 s->height - 1); 1642 } 1643 else 1644 { 1645 for (i = 0; i < s->nchars; i++, ++s->gidx) 1646 { 1647 w32_text_out (s, x + s->cmp->offsets[s->gidx * 2], 1648 s->ybase - s->cmp->offsets[s->gidx * 2 + 1], 1649 s->char2b + i, 1); 1650 if (s->face->overstrike) 1651 w32_text_out (s, x + s->cmp->offsets[s->gidx * 2] + 1, 1652 s->ybase - s->cmp->offsets[s->gidx * 2 + 1], 1653 s->char2b + i, 1); 1654 } 1655 } 1656 1657 if (s->font && s->font->hfont) 1658 SelectObject (s->hdc, old_font); 1659} 1660 1661 1662/* Brightness beyond which a color won't have its highlight brightness 1663 boosted. 1664 1665 Nominally, highlight colors for `3d' faces are calculated by 1666 brightening an object's color by a constant scale factor, but this 1667 doesn't yield good results for dark colors, so for colors who's 1668 brightness is less than this value (on a scale of 0-255) have to 1669 use an additional additive factor. 1670 1671 The value here is set so that the default menu-bar/mode-line color 1672 (grey75) will not have its highlights changed at all. */ 1673#define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187 1674 1675 1676/* Allocate a color which is lighter or darker than *COLOR by FACTOR 1677 or DELTA. Try a color with RGB values multiplied by FACTOR first. 1678 If this produces the same color as COLOR, try a color where all RGB 1679 values have DELTA added. Return the allocated color in *COLOR. 1680 DISPLAY is the X display, CMAP is the colormap to operate on. 1681 Value is non-zero if successful. */ 1682 1683static int 1684w32_alloc_lighter_color (f, color, factor, delta) 1685 struct frame *f; 1686 COLORREF *color; 1687 double factor; 1688 int delta; 1689{ 1690 COLORREF new; 1691 long bright; 1692 1693 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */ 1694 delta /= 256; 1695 1696 /* Change RGB values by specified FACTOR. Avoid overflow! */ 1697 xassert (factor >= 0); 1698 new = PALETTERGB (min (0xff, factor * GetRValue (*color)), 1699 min (0xff, factor * GetGValue (*color)), 1700 min (0xff, factor * GetBValue (*color))); 1701 1702 /* Calculate brightness of COLOR. */ 1703 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color) 1704 + GetBValue (*color)) / 6; 1705 1706 /* We only boost colors that are darker than 1707 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */ 1708 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT) 1709 /* Make an additive adjustment to NEW, because it's dark enough so 1710 that scaling by FACTOR alone isn't enough. */ 1711 { 1712 /* How far below the limit this color is (0 - 1, 1 being darker). */ 1713 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT; 1714 /* The additive adjustment. */ 1715 int min_delta = delta * dimness * factor / 2; 1716 1717 if (factor < 1) 1718 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))), 1719 max (0, min (0xff, min_delta - GetGValue (*color))), 1720 max (0, min (0xff, min_delta - GetBValue (*color)))); 1721 else 1722 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))), 1723 max (0, min (0xff, min_delta + GetGValue (*color))), 1724 max (0, min (0xff, min_delta + GetBValue (*color)))); 1725 } 1726 1727 if (new == *color) 1728 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))), 1729 max (0, min (0xff, delta + GetGValue (*color))), 1730 max (0, min (0xff, delta + GetBValue (*color)))); 1731 1732 /* TODO: Map to palette and retry with delta if same? */ 1733 /* TODO: Free colors (if using palette)? */ 1734 1735 if (new == *color) 1736 return 0; 1737 1738 *color = new; 1739 1740 return 1; 1741} 1742 1743 1744/* Set up the foreground color for drawing relief lines of glyph 1745 string S. RELIEF is a pointer to a struct relief containing the GC 1746 with which lines will be drawn. Use a color that is FACTOR or 1747 DELTA lighter or darker than the relief's background which is found 1748 in S->f->output_data.x->relief_background. If such a color cannot 1749 be allocated, use DEFAULT_PIXEL, instead. */ 1750 1751static void 1752w32_setup_relief_color (f, relief, factor, delta, default_pixel) 1753 struct frame *f; 1754 struct relief *relief; 1755 double factor; 1756 int delta; 1757 COLORREF default_pixel; 1758{ 1759 XGCValues xgcv; 1760 struct w32_output *di = f->output_data.w32; 1761 unsigned long mask = GCForeground; 1762 COLORREF pixel; 1763 COLORREF background = di->relief_background; 1764 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 1765 1766 /* TODO: Free colors (if using palette)? */ 1767 1768 /* Allocate new color. */ 1769 xgcv.foreground = default_pixel; 1770 pixel = background; 1771 if (w32_alloc_lighter_color (f, &pixel, factor, delta)) 1772 { 1773 relief->allocated_p = 1; 1774 xgcv.foreground = relief->pixel = pixel; 1775 } 1776 1777 if (relief->gc == 0) 1778 { 1779#if 0 /* TODO: stipple */ 1780 xgcv.stipple = dpyinfo->gray; 1781 mask |= GCStipple; 1782#endif 1783 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv); 1784 } 1785 else 1786 XChangeGC (NULL, relief->gc, mask, &xgcv); 1787} 1788 1789 1790/* Set up colors for the relief lines around glyph string S. */ 1791 1792static void 1793x_setup_relief_colors (s) 1794 struct glyph_string *s; 1795{ 1796 struct w32_output *di = s->f->output_data.w32; 1797 COLORREF color; 1798 1799 if (s->face->use_box_color_for_shadows_p) 1800 color = s->face->box_color; 1801 else if (s->first_glyph->type == IMAGE_GLYPH 1802 && s->img->pixmap 1803 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0)) 1804 color = IMAGE_BACKGROUND (s->img, s->f, 0); 1805 else 1806 color = s->gc->background; 1807 1808 if (di->white_relief.gc == 0 1809 || color != di->relief_background) 1810 { 1811 di->relief_background = color; 1812 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000, 1813 WHITE_PIX_DEFAULT (s->f)); 1814 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000, 1815 BLACK_PIX_DEFAULT (s->f)); 1816 } 1817} 1818 1819 1820/* Draw a relief on frame F inside the rectangle given by LEFT_X, 1821 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief 1822 to draw, it must be >= 0. RAISED_P non-zero means draw a raised 1823 relief. LEFT_P non-zero means draw a relief on the left side of 1824 the rectangle. RIGHT_P non-zero means draw a relief on the right 1825 side of the rectangle. CLIP_RECT is the clipping rectangle to use 1826 when drawing. */ 1827 1828static void 1829w32_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width, 1830 raised_p, top_p, bot_p, left_p, right_p, clip_rect) 1831 struct frame *f; 1832 int left_x, top_y, right_x, bottom_y, width; 1833 int top_p, bot_p, left_p, right_p, raised_p; 1834 RECT *clip_rect; 1835{ 1836 int i; 1837 XGCValues gc; 1838 HDC hdc = get_frame_dc (f); 1839 1840 if (raised_p) 1841 gc.foreground = f->output_data.w32->white_relief.gc->foreground; 1842 else 1843 gc.foreground = f->output_data.w32->black_relief.gc->foreground; 1844 1845 w32_set_clip_rectangle (hdc, clip_rect); 1846 1847 /* Top. */ 1848 if (top_p) 1849 for (i = 0; i < width; ++i) 1850 w32_fill_area (f, hdc, gc.foreground, 1851 left_x + i * left_p, top_y + i, 1852 right_x - left_x - i * (left_p + right_p ) + 1, 1); 1853 1854 /* Left. */ 1855 if (left_p) 1856 for (i = 0; i < width; ++i) 1857 w32_fill_area (f, hdc, gc.foreground, 1858 left_x + i, top_y + i, 1, 1859 bottom_y - top_y - 2 * i + 1); 1860 1861 if (raised_p) 1862 gc.foreground = f->output_data.w32->black_relief.gc->foreground; 1863 else 1864 gc.foreground = f->output_data.w32->white_relief.gc->foreground; 1865 1866 /* Bottom. */ 1867 if (bot_p) 1868 for (i = 0; i < width; ++i) 1869 w32_fill_area (f, hdc, gc.foreground, 1870 left_x + i * left_p, bottom_y - i, 1871 right_x - left_x - i * (left_p + right_p) + 1, 1); 1872 1873 /* Right. */ 1874 if (right_p) 1875 for (i = 0; i < width; ++i) 1876 w32_fill_area (f, hdc, gc.foreground, 1877 right_x - i, top_y + i + 1, 1, 1878 bottom_y - top_y - 2 * i - 1); 1879 1880 w32_set_clip_rectangle (hdc, NULL); 1881 1882 release_frame_dc (f, hdc); 1883} 1884 1885 1886/* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y, 1887 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to 1888 draw, it must be >= 0. LEFT_P non-zero means draw a line on the 1889 left side of the rectangle. RIGHT_P non-zero means draw a line 1890 on the right side of the rectangle. CLIP_RECT is the clipping 1891 rectangle to use when drawing. */ 1892 1893static void 1894w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width, 1895 left_p, right_p, clip_rect) 1896 struct glyph_string *s; 1897 int left_x, top_y, right_x, bottom_y, width, left_p, right_p; 1898 RECT *clip_rect; 1899{ 1900 w32_set_clip_rectangle (s->hdc, clip_rect); 1901 1902 /* Top. */ 1903 w32_fill_area (s->f, s->hdc, s->face->box_color, 1904 left_x, top_y, right_x - left_x + 1, width); 1905 1906 /* Left. */ 1907 if (left_p) 1908 { 1909 w32_fill_area (s->f, s->hdc, s->face->box_color, 1910 left_x, top_y, width, bottom_y - top_y + 1); 1911 } 1912 1913 /* Bottom. */ 1914 w32_fill_area (s->f, s->hdc, s->face->box_color, 1915 left_x, bottom_y - width + 1, right_x - left_x + 1, width); 1916 1917 /* Right. */ 1918 if (right_p) 1919 { 1920 w32_fill_area (s->f, s->hdc, s->face->box_color, 1921 right_x - width + 1, top_y, width, bottom_y - top_y + 1); 1922 } 1923 1924 w32_set_clip_rectangle (s->hdc, NULL); 1925} 1926 1927 1928/* Draw a box around glyph string S. */ 1929 1930static void 1931x_draw_glyph_string_box (s) 1932 struct glyph_string *s; 1933{ 1934 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p; 1935 int left_p, right_p; 1936 struct glyph *last_glyph; 1937 RECT clip_rect; 1938 1939 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p) 1940 ? WINDOW_RIGHT_EDGE_X (s->w) 1941 : window_box_right (s->w, s->area)); 1942 1943 /* The glyph that may have a right box line. */ 1944 last_glyph = (s->cmp || s->img 1945 ? s->first_glyph 1946 : s->first_glyph + s->nchars - 1); 1947 1948 width = abs (s->face->box_line_width); 1949 raised_p = s->face->box == FACE_RAISED_BOX; 1950 left_x = s->x; 1951 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p 1952 ? last_x - 1 1953 : min (last_x, s->x + s->background_width) - 1)); 1954 top_y = s->y; 1955 bottom_y = top_y + s->height - 1; 1956 1957 left_p = (s->first_glyph->left_box_line_p 1958 || (s->hl == DRAW_MOUSE_FACE 1959 && (s->prev == NULL 1960 || s->prev->hl != s->hl))); 1961 right_p = (last_glyph->right_box_line_p 1962 || (s->hl == DRAW_MOUSE_FACE 1963 && (s->next == NULL 1964 || s->next->hl != s->hl))); 1965 1966 get_glyph_string_clip_rect (s, &clip_rect); 1967 1968 if (s->face->box == FACE_SIMPLE_BOX) 1969 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width, 1970 left_p, right_p, &clip_rect); 1971 else 1972 { 1973 x_setup_relief_colors (s); 1974 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y, 1975 width, raised_p, 1, 1, left_p, right_p, &clip_rect); 1976 } 1977} 1978 1979 1980/* Draw foreground of image glyph string S. */ 1981 1982static void 1983x_draw_image_foreground (s) 1984 struct glyph_string *s; 1985{ 1986 int x = s->x; 1987 int y = s->ybase - image_ascent (s->img, s->face, &s->slice); 1988 1989 /* If first glyph of S has a left box line, start drawing it to the 1990 right of that line. */ 1991 if (s->face->box != FACE_NO_BOX 1992 && s->first_glyph->left_box_line_p 1993 && s->slice.x == 0) 1994 x += abs (s->face->box_line_width); 1995 1996 /* If there is a margin around the image, adjust x- and y-position 1997 by that margin. */ 1998 if (s->slice.x == 0) 1999 x += s->img->hmargin; 2000 if (s->slice.y == 0) 2001 y += s->img->vmargin; 2002 2003 SaveDC (s->hdc); 2004 2005 if (s->img->pixmap) 2006 { 2007 HDC compat_hdc = CreateCompatibleDC (s->hdc); 2008 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground); 2009 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush); 2010 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap); 2011 SetBkColor (compat_hdc, RGB (255, 255, 255)); 2012 SetTextColor (s->hdc, RGB (0, 0, 0)); 2013 x_set_glyph_string_clipping (s); 2014 2015 if (s->img->mask) 2016 { 2017 HDC mask_dc = CreateCompatibleDC (s->hdc); 2018 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask); 2019 2020 SetTextColor (s->hdc, RGB (255, 255, 255)); 2021 SetBkColor (s->hdc, RGB (0, 0, 0)); 2022 2023 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height, 2024 compat_hdc, s->slice.x, s->slice.y, SRCINVERT); 2025 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height, 2026 mask_dc, s->slice.x, s->slice.y, SRCAND); 2027 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height, 2028 compat_hdc, s->slice.x, s->slice.y, SRCINVERT); 2029 2030 SelectObject (mask_dc, mask_orig_obj); 2031 DeleteDC (mask_dc); 2032 } 2033 else 2034 { 2035 SetTextColor (s->hdc, s->gc->foreground); 2036 SetBkColor (s->hdc, s->gc->background); 2037 2038 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height, 2039 compat_hdc, s->slice.x, s->slice.y, SRCCOPY); 2040 2041 /* When the image has a mask, we can expect that at 2042 least part of a mouse highlight or a block cursor will 2043 be visible. If the image doesn't have a mask, make 2044 a block cursor visible by drawing a rectangle around 2045 the image. I believe it's looking better if we do 2046 nothing here for mouse-face. */ 2047 if (s->hl == DRAW_CURSOR) 2048 { 2049 int r = s->img->relief; 2050 if (r < 0) r = -r; 2051 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r , 2052 s->slice.width + r*2 - 1, 2053 s->slice.height + r*2 - 1); 2054 } 2055 } 2056 2057 w32_set_clip_rectangle (s->hdc, NULL); 2058 SelectObject (s->hdc, orig_brush); 2059 DeleteObject (fg_brush); 2060 SelectObject (compat_hdc, orig_obj); 2061 DeleteDC (compat_hdc); 2062 } 2063 else 2064 w32_draw_rectangle (s->hdc, s->gc, x, y, 2065 s->slice.width - 1, s->slice.height - 1); 2066 2067 RestoreDC (s->hdc ,-1); 2068} 2069 2070 2071/* Draw a relief around the image glyph string S. */ 2072 2073static void 2074x_draw_image_relief (s) 2075 struct glyph_string *s; 2076{ 2077 int x0, y0, x1, y1, thick, raised_p; 2078 RECT r; 2079 int x = s->x; 2080 int y = s->ybase - image_ascent (s->img, s->face, &s->slice); 2081 2082 /* If first glyph of S has a left box line, start drawing it to the 2083 right of that line. */ 2084 if (s->face->box != FACE_NO_BOX 2085 && s->first_glyph->left_box_line_p 2086 && s->slice.x == 0) 2087 x += abs (s->face->box_line_width); 2088 2089 /* If there is a margin around the image, adjust x- and y-position 2090 by that margin. */ 2091 if (s->slice.x == 0) 2092 x += s->img->hmargin; 2093 if (s->slice.y == 0) 2094 y += s->img->vmargin; 2095 2096 if (s->hl == DRAW_IMAGE_SUNKEN 2097 || s->hl == DRAW_IMAGE_RAISED) 2098 { 2099 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF; 2100 raised_p = s->hl == DRAW_IMAGE_RAISED; 2101 } 2102 else 2103 { 2104 thick = abs (s->img->relief); 2105 raised_p = s->img->relief > 0; 2106 } 2107 2108 x0 = x - thick; 2109 y0 = y - thick; 2110 x1 = x + s->slice.width + thick - 1; 2111 y1 = y + s->slice.height + thick - 1; 2112 2113 x_setup_relief_colors (s); 2114 get_glyph_string_clip_rect (s, &r); 2115 w32_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 2116 s->slice.y == 0, 2117 s->slice.y + s->slice.height == s->img->height, 2118 s->slice.x == 0, 2119 s->slice.x + s->slice.width == s->img->width, 2120 &r); 2121} 2122 2123 2124/* Draw the foreground of image glyph string S to PIXMAP. */ 2125 2126static void 2127w32_draw_image_foreground_1 (s, pixmap) 2128 struct glyph_string *s; 2129 HBITMAP pixmap; 2130{ 2131 HDC hdc = CreateCompatibleDC (s->hdc); 2132 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap); 2133 int x = 0; 2134 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice); 2135 2136 /* If first glyph of S has a left box line, start drawing it to the 2137 right of that line. */ 2138 if (s->face->box != FACE_NO_BOX 2139 && s->first_glyph->left_box_line_p 2140 && s->slice.x == 0) 2141 x += abs (s->face->box_line_width); 2142 2143 /* If there is a margin around the image, adjust x- and y-position 2144 by that margin. */ 2145 if (s->slice.x == 0) 2146 x += s->img->hmargin; 2147 if (s->slice.y == 0) 2148 y += s->img->vmargin; 2149 2150 if (s->img->pixmap) 2151 { 2152 HDC compat_hdc = CreateCompatibleDC (hdc); 2153 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground); 2154 HBRUSH orig_brush = SelectObject (hdc, fg_brush); 2155 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap); 2156 2157 if (s->img->mask) 2158 { 2159 HDC mask_dc = CreateCompatibleDC (hdc); 2160 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask); 2161 2162 SetTextColor (hdc, RGB (0, 0, 0)); 2163 SetBkColor (hdc, RGB (255, 255, 255)); 2164 BitBlt (hdc, x, y, s->slice.width, s->slice.height, 2165 compat_hdc, s->slice.x, s->slice.y, SRCINVERT); 2166 BitBlt (hdc, x, y, s->slice.width, s->slice.height, 2167 mask_dc, s->slice.x, s->slice.y, SRCAND); 2168 BitBlt (hdc, x, y, s->slice.width, s->slice.height, 2169 compat_hdc, s->slice.x, s->slice.y, SRCINVERT); 2170 2171 SelectObject (mask_dc, mask_orig_obj); 2172 DeleteDC (mask_dc); 2173 } 2174 else 2175 { 2176 SetTextColor (hdc, s->gc->foreground); 2177 SetBkColor (hdc, s->gc->background); 2178 2179 BitBlt (hdc, x, y, s->slice.width, s->slice.height, 2180 compat_hdc, s->slice.x, s->slice.y, SRCCOPY); 2181 2182 /* When the image has a mask, we can expect that at 2183 least part of a mouse highlight or a block cursor will 2184 be visible. If the image doesn't have a mask, make 2185 a block cursor visible by drawing a rectangle around 2186 the image. I believe it's looking better if we do 2187 nothing here for mouse-face. */ 2188 if (s->hl == DRAW_CURSOR) 2189 { 2190 int r = s->img->relief; 2191 if (r < 0) r = -r; 2192 w32_draw_rectangle (hdc, s->gc, x - r, y - r, 2193 s->slice.width + r*2 - 1, 2194 s->slice.height + r*2 - 1); 2195 } 2196 } 2197 2198 SelectObject (hdc, orig_brush); 2199 DeleteObject (fg_brush); 2200 SelectObject (compat_hdc, orig_obj); 2201 DeleteDC (compat_hdc); 2202 } 2203 else 2204 w32_draw_rectangle (hdc, s->gc, x, y, 2205 s->slice.width - 1, s->slice.height - 1); 2206 2207 SelectObject (hdc, orig_hdc_obj); 2208 DeleteDC (hdc); 2209} 2210 2211 2212/* Draw part of the background of glyph string S. X, Y, W, and H 2213 give the rectangle to draw. */ 2214 2215static void 2216x_draw_glyph_string_bg_rect (s, x, y, w, h) 2217 struct glyph_string *s; 2218 int x, y, w, h; 2219{ 2220#if 0 /* TODO: stipple */ 2221 if (s->stippled_p) 2222 { 2223 /* Fill background with a stipple pattern. */ 2224 XSetFillStyle (s->display, s->gc, FillOpaqueStippled); 2225 XFillRectangle (s->display, s->window, s->gc, x, y, w, h); 2226 XSetFillStyle (s->display, s->gc, FillSolid); 2227 } 2228 else 2229#endif 2230 x_clear_glyph_string_rect (s, x, y, w, h); 2231} 2232 2233 2234/* Draw image glyph string S. 2235 2236 s->y 2237 s->x +------------------------- 2238 | s->face->box 2239 | 2240 | +------------------------- 2241 | | s->img->vmargin 2242 | | 2243 | | +------------------- 2244 | | | the image 2245 2246 */ 2247 2248static void 2249x_draw_image_glyph_string (s) 2250 struct glyph_string *s; 2251{ 2252 int x, y; 2253 int box_line_hwidth = abs (s->face->box_line_width); 2254 int box_line_vwidth = max (s->face->box_line_width, 0); 2255 int height; 2256 HBITMAP pixmap = 0; 2257 2258 height = s->height - 2 * box_line_vwidth; 2259 2260 /* Fill background with face under the image. Do it only if row is 2261 taller than image or if image has a clip mask to reduce 2262 flickering. */ 2263 s->stippled_p = s->face->stipple != 0; 2264 if (height > s->slice.height 2265 || s->img->hmargin 2266 || s->img->vmargin 2267 || s->img->mask 2268 || s->img->pixmap == 0 2269 || s->width != s->background_width) 2270 { 2271 x = s->x; 2272 if (s->first_glyph->left_box_line_p 2273 && s->slice.x == 0) 2274 x += box_line_hwidth; 2275 2276 y = s->y; 2277 if (s->slice.y == 0) 2278 y += box_line_vwidth; 2279 2280#if 0 /* TODO: figure out if we need to do this on Windows. */ 2281 if (s->img->mask) 2282 { 2283 /* Create a pixmap as large as the glyph string. Fill it 2284 with the background color. Copy the image to it, using 2285 its mask. Copy the temporary pixmap to the display. */ 2286 Screen *screen = FRAME_X_SCREEN (s->f); 2287 int depth = DefaultDepthOfScreen (screen); 2288 2289 /* Create a pixmap as large as the glyph string. */ 2290 pixmap = XCreatePixmap (s->display, s->window, 2291 s->background_width, 2292 s->height, depth); 2293 2294 /* Don't clip in the following because we're working on the 2295 pixmap. */ 2296 XSetClipMask (s->display, s->gc, None); 2297 2298 /* Fill the pixmap with the background color/stipple. */ 2299 if (s->stippled_p) 2300 { 2301 /* Fill background with a stipple pattern. */ 2302 XSetFillStyle (s->display, s->gc, FillOpaqueStippled); 2303 XFillRectangle (s->display, pixmap, s->gc, 2304 0, 0, s->background_width, s->height); 2305 XSetFillStyle (s->display, s->gc, FillSolid); 2306 } 2307 else 2308 { 2309 XGCValues xgcv; 2310 XGetGCValues (s->display, s->gc, GCForeground | GCBackground, 2311 &xgcv); 2312 XSetForeground (s->display, s->gc, xgcv.background); 2313 XFillRectangle (s->display, pixmap, s->gc, 2314 0, 0, s->background_width, s->height); 2315 XSetForeground (s->display, s->gc, xgcv.foreground); 2316 } 2317 } 2318 else 2319#endif 2320 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height); 2321 2322 s->background_filled_p = 1; 2323 } 2324 2325 /* Draw the foreground. */ 2326 if (pixmap != 0) 2327 { 2328 w32_draw_image_foreground_1 (s, pixmap); 2329 x_set_glyph_string_clipping (s); 2330 { 2331 HDC compat_hdc = CreateCompatibleDC (s->hdc); 2332 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground); 2333 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush); 2334 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap); 2335 2336 SetTextColor (s->hdc, s->gc->foreground); 2337 SetBkColor (s->hdc, s->gc->background); 2338 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height, 2339 compat_hdc, 0, 0, SRCCOPY); 2340 2341 SelectObject (s->hdc, orig_brush); 2342 DeleteObject (fg_brush); 2343 SelectObject (compat_hdc, orig_obj); 2344 DeleteDC (compat_hdc); 2345 } 2346 DeleteObject (pixmap); 2347 pixmap = 0; 2348 } 2349 else 2350 x_draw_image_foreground (s); 2351 2352 /* If we must draw a relief around the image, do it. */ 2353 if (s->img->relief 2354 || s->hl == DRAW_IMAGE_RAISED 2355 || s->hl == DRAW_IMAGE_SUNKEN) 2356 x_draw_image_relief (s); 2357} 2358 2359 2360/* Draw stretch glyph string S. */ 2361 2362static void 2363x_draw_stretch_glyph_string (s) 2364 struct glyph_string *s; 2365{ 2366 xassert (s->first_glyph->type == STRETCH_GLYPH); 2367 s->stippled_p = s->face->stipple != 0; 2368 2369 if (s->hl == DRAW_CURSOR 2370 && !x_stretch_cursor_p) 2371 { 2372 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor 2373 as wide as the stretch glyph. */ 2374 int width, background_width = s->background_width; 2375 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA); 2376 2377 if (x < left_x) 2378 { 2379 background_width -= left_x - x; 2380 x = left_x; 2381 } 2382 width = min (FRAME_COLUMN_WIDTH (s->f), background_width); 2383 2384 /* Draw cursor. */ 2385 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height); 2386 2387 /* Clear rest using the GC of the original non-cursor face. */ 2388 if (width < background_width) 2389 { 2390 XGCValues *gc = s->face->gc; 2391 int y = s->y; 2392 int w = background_width - width, h = s->height; 2393 RECT r; 2394 HDC hdc = s->hdc; 2395 2396 x += width; 2397 if (s->row->mouse_face_p 2398 && cursor_in_mouse_face_p (s->w)) 2399 { 2400 x_set_mouse_face_gc (s); 2401 gc = s->gc; 2402 } 2403 else 2404 gc = s->face->gc; 2405 2406 get_glyph_string_clip_rect (s, &r); 2407 w32_set_clip_rectangle (hdc, &r); 2408 2409#if 0 /* TODO: stipple */ 2410 if (s->face->stipple) 2411 { 2412 /* Fill background with a stipple pattern. */ 2413 XSetFillStyle (s->display, gc, FillOpaqueStippled); 2414 XFillRectangle (s->display, s->window, gc, x, y, w, h); 2415 XSetFillStyle (s->display, gc, FillSolid); 2416 } 2417 else 2418#endif 2419 { 2420 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h); 2421 } 2422 } 2423 } 2424 else if (!s->background_filled_p) 2425 { 2426 int background_width = s->background_width; 2427 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA); 2428 2429 /* Don't draw into left margin, fringe or scrollbar area 2430 except for header line and mode line. */ 2431 if (x < left_x && !s->row->mode_line_p) 2432 { 2433 background_width -= left_x - x; 2434 x = left_x; 2435 } 2436 if (background_width > 0) 2437 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height); 2438 } 2439 2440 s->background_filled_p = 1; 2441} 2442 2443 2444/* Draw glyph string S. */ 2445 2446static void 2447x_draw_glyph_string (s) 2448 struct glyph_string *s; 2449{ 2450 int relief_drawn_p = 0; 2451 2452 /* If S draws into the background of its successor, draw the 2453 background of the successor first so that S can draw into it. 2454 This makes S->next use XDrawString instead of XDrawImageString. */ 2455 if (s->next && s->right_overhang && !s->for_overlaps) 2456 { 2457 xassert (s->next->img == NULL); 2458 x_set_glyph_string_gc (s->next); 2459 x_set_glyph_string_clipping (s->next); 2460 x_draw_glyph_string_background (s->next, 1); 2461 } 2462 2463 /* Set up S->gc, set clipping and draw S. */ 2464 x_set_glyph_string_gc (s); 2465 2466 /* Draw relief (if any) in advance for char/composition so that the 2467 glyph string can be drawn over it. */ 2468 if (!s->for_overlaps 2469 && s->face->box != FACE_NO_BOX 2470 && (s->first_glyph->type == CHAR_GLYPH 2471 || s->first_glyph->type == COMPOSITE_GLYPH)) 2472 2473 { 2474 x_set_glyph_string_clipping (s); 2475 x_draw_glyph_string_background (s, 1); 2476 x_draw_glyph_string_box (s); 2477 x_set_glyph_string_clipping (s); 2478 relief_drawn_p = 1; 2479 } 2480 else 2481 x_set_glyph_string_clipping (s); 2482 2483 switch (s->first_glyph->type) 2484 { 2485 case IMAGE_GLYPH: 2486 x_draw_image_glyph_string (s); 2487 break; 2488 2489 case STRETCH_GLYPH: 2490 x_draw_stretch_glyph_string (s); 2491 break; 2492 2493 case CHAR_GLYPH: 2494 if (s->for_overlaps) 2495 s->background_filled_p = 1; 2496 else 2497 x_draw_glyph_string_background (s, 0); 2498 x_draw_glyph_string_foreground (s); 2499 break; 2500 2501 case COMPOSITE_GLYPH: 2502 if (s->for_overlaps || s->gidx > 0) 2503 s->background_filled_p = 1; 2504 else 2505 x_draw_glyph_string_background (s, 1); 2506 x_draw_composite_glyph_string_foreground (s); 2507 break; 2508 2509 default: 2510 abort (); 2511 } 2512 2513 if (!s->for_overlaps) 2514 { 2515 /* Draw underline. */ 2516 if (s->face->underline_p 2517 && (s->font->bdf || !s->font->tm.tmUnderlined)) 2518 { 2519 unsigned long h = 1; 2520 unsigned long dy = 0; 2521 2522 if (x_underline_at_descent_line) 2523 dy = s->height - h; 2524 else 2525 { 2526 /* TODO: Use font information for positioning and thickness of 2527 underline. See OUTLINETEXTMETRIC, and xterm.c. Note: If 2528 you make this work, don't forget to change the doc string of 2529 x-use-underline-position-properties below. */ 2530 dy = s->height - h; 2531 } 2532 if (s->face->underline_defaulted_p) 2533 { 2534 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, 2535 s->y + dy, s->background_width, 1); 2536 } 2537 else 2538 { 2539 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x, 2540 s->y + dy, s->background_width, 1); 2541 } 2542 } 2543 2544 /* Draw overline. */ 2545 if (s->face->overline_p) 2546 { 2547 unsigned long dy = 0, h = 1; 2548 2549 if (s->face->overline_color_defaulted_p) 2550 { 2551 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, 2552 s->y + dy, s->background_width, h); 2553 } 2554 else 2555 { 2556 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x, 2557 s->y + dy, s->background_width, h); 2558 } 2559 } 2560 2561 /* Draw strike-through. */ 2562 if (s->face->strike_through_p 2563 && (s->font->bdf || !s->font->tm.tmStruckOut)) 2564 { 2565 unsigned long h = 1; 2566 unsigned long dy = (s->height - h) / 2; 2567 2568 if (s->face->strike_through_color_defaulted_p) 2569 { 2570 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy, 2571 s->width, h); 2572 } 2573 else 2574 { 2575 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x, 2576 s->y + dy, s->width, h); 2577 } 2578 } 2579 2580 /* Draw relief. */ 2581 if (!relief_drawn_p && s->face->box != FACE_NO_BOX) 2582 x_draw_glyph_string_box (s); 2583 } 2584 2585 /* Reset clipping. */ 2586 w32_set_clip_rectangle (s->hdc, NULL); 2587} 2588 2589 2590/* Shift display to make room for inserted glyphs. */ 2591 2592void 2593w32_shift_glyphs_for_insert (f, x, y, width, height, shift_by) 2594 struct frame *f; 2595 int x, y, width, height, shift_by; 2596{ 2597 HDC hdc; 2598 2599 hdc = get_frame_dc (f); 2600 BitBlt (hdc, x + shift_by, y, width, height, 2601 hdc, x, y, SRCCOPY); 2602 2603 release_frame_dc (f, hdc); 2604} 2605 2606 2607/* Delete N glyphs at the nominal cursor position. Not implemented 2608 for X frames. */ 2609 2610static void 2611x_delete_glyphs (n) 2612 register int n; 2613{ 2614 struct frame *f; 2615 2616 if (updating_frame) 2617 f = updating_frame; 2618 else 2619 f = SELECTED_FRAME (); 2620 2621 if (! FRAME_W32_P (f)) 2622 return; 2623 2624 abort (); 2625} 2626 2627 2628/* Clear entire frame. If updating_frame is non-null, clear that 2629 frame. Otherwise clear the selected frame. */ 2630 2631static void 2632x_clear_frame () 2633{ 2634 struct frame *f; 2635 2636 if (updating_frame) 2637 f = updating_frame; 2638 else 2639 f = SELECTED_FRAME (); 2640 2641 if (! FRAME_W32_P (f)) 2642 return; 2643 2644 /* Clearing the frame will erase any cursor, so mark them all as no 2645 longer visible. */ 2646 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f))); 2647 output_cursor.hpos = output_cursor.vpos = 0; 2648 output_cursor.x = -1; 2649 2650 /* We don't set the output cursor here because there will always 2651 follow an explicit cursor_to. */ 2652 BLOCK_INPUT; 2653 2654 w32_clear_window (f); 2655 2656 /* We have to clear the scroll bars, too. If we have changed 2657 colors or something like that, then they should be notified. */ 2658 x_scroll_bar_clear (f); 2659 2660 UNBLOCK_INPUT; 2661} 2662 2663 2664/* Make audible bell. */ 2665 2666static void 2667w32_ring_bell (void) 2668{ 2669 struct frame *f; 2670 2671 f = SELECTED_FRAME (); 2672 2673 BLOCK_INPUT; 2674 2675 if (FRAME_W32_P (f) && visible_bell) 2676 { 2677 int i; 2678 HWND hwnd = FRAME_W32_WINDOW (SELECTED_FRAME ()); 2679 2680 for (i = 0; i < 5; i++) 2681 { 2682 FlashWindow (hwnd, TRUE); 2683 Sleep (10); 2684 } 2685 FlashWindow (hwnd, FALSE); 2686 } 2687 else 2688 w32_sys_ring_bell (); 2689 2690 UNBLOCK_INPUT; 2691} 2692 2693 2694/* Specify how many text lines, from the top of the window, 2695 should be affected by insert-lines and delete-lines operations. 2696 This, and those operations, are used only within an update 2697 that is bounded by calls to x_update_begin and x_update_end. */ 2698 2699static void 2700w32_set_terminal_window (n) 2701 register int n; 2702{ 2703 /* This function intentionally left blank. */ 2704} 2705 2706 2707/*********************************************************************** 2708 Line Dance 2709 ***********************************************************************/ 2710 2711/* Perform an insert-lines or delete-lines operation, inserting N 2712 lines or deleting -N lines at vertical position VPOS. */ 2713 2714static void 2715x_ins_del_lines (vpos, n) 2716 int vpos, n; 2717{ 2718 struct frame *f; 2719 2720 if (updating_frame) 2721 f = updating_frame; 2722 else 2723 f = SELECTED_FRAME (); 2724 2725 if (! FRAME_W32_P (f)) 2726 return; 2727 2728 abort (); 2729} 2730 2731 2732/* Scroll part of the display as described by RUN. */ 2733 2734static void 2735x_scroll_run (w, run) 2736 struct window *w; 2737 struct run *run; 2738{ 2739 struct frame *f = XFRAME (w->frame); 2740 int x, y, width, height, from_y, to_y, bottom_y; 2741 HWND hwnd = FRAME_W32_WINDOW (f); 2742 HRGN expect_dirty; 2743 2744 /* Get frame-relative bounding box of the text display area of W, 2745 without mode lines. Include in this box the left and right 2746 fringes of W. */ 2747 window_box (w, -1, &x, &y, &width, &height); 2748 2749 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y); 2750 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y); 2751 bottom_y = y + height; 2752 2753 if (to_y < from_y) 2754 { 2755 /* Scrolling up. Make sure we don't copy part of the mode 2756 line at the bottom. */ 2757 if (from_y + run->height > bottom_y) 2758 height = bottom_y - from_y; 2759 else 2760 height = run->height; 2761 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y); 2762 } 2763 else 2764 { 2765 /* Scolling down. Make sure we don't copy over the mode line. 2766 at the bottom. */ 2767 if (to_y + run->height > bottom_y) 2768 height = bottom_y - to_y; 2769 else 2770 height = run->height; 2771 expect_dirty = CreateRectRgn (x, y, x + width, to_y); 2772 } 2773 2774 BLOCK_INPUT; 2775 2776 /* Cursor off. Will be switched on again in x_update_window_end. */ 2777 updated_window = w; 2778 x_clear_cursor (w); 2779 2780 { 2781 RECT from; 2782 RECT to; 2783 HRGN dirty = CreateRectRgn (0, 0, 0, 0); 2784 HRGN combined = CreateRectRgn (0, 0, 0, 0); 2785 2786 from.left = to.left = x; 2787 from.right = to.right = x + width; 2788 from.top = from_y; 2789 from.bottom = from_y + height; 2790 to.top = y; 2791 to.bottom = bottom_y; 2792 2793 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty, 2794 NULL, SW_INVALIDATE); 2795 2796 /* Combine this with what we expect to be dirty. This covers the 2797 case where not all of the region we expect is actually dirty. */ 2798 CombineRgn (combined, dirty, expect_dirty, RGN_OR); 2799 2800 /* If the dirty region is not what we expected, redraw the entire frame. */ 2801 if (!EqualRgn (combined, expect_dirty)) 2802 SET_FRAME_GARBAGED (f); 2803 2804 DeleteObject (dirty); 2805 DeleteObject (combined); 2806 } 2807 2808 UNBLOCK_INPUT; 2809 DeleteObject (expect_dirty); 2810} 2811 2812 2813 2814/*********************************************************************** 2815 Exposure Events 2816 ***********************************************************************/ 2817 2818static void 2819frame_highlight (f) 2820 struct frame *f; 2821{ 2822 x_update_cursor (f, 1); 2823} 2824 2825static void 2826frame_unhighlight (f) 2827 struct frame *f; 2828{ 2829 x_update_cursor (f, 1); 2830} 2831 2832/* The focus has changed. Update the frames as necessary to reflect 2833 the new situation. Note that we can't change the selected frame 2834 here, because the Lisp code we are interrupting might become confused. 2835 Each event gets marked with the frame in which it occurred, so the 2836 Lisp code can tell when the switch took place by examining the events. */ 2837 2838static void 2839x_new_focus_frame (dpyinfo, frame) 2840 struct w32_display_info *dpyinfo; 2841 struct frame *frame; 2842{ 2843 struct frame *old_focus = dpyinfo->w32_focus_frame; 2844 2845 if (frame != dpyinfo->w32_focus_frame) 2846 { 2847 /* Set this before calling other routines, so that they see 2848 the correct value of w32_focus_frame. */ 2849 dpyinfo->w32_focus_frame = frame; 2850 2851 if (old_focus && old_focus->auto_lower) 2852 x_lower_frame (old_focus); 2853 2854 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise) 2855 pending_autoraise_frame = dpyinfo->w32_focus_frame; 2856 else 2857 pending_autoraise_frame = 0; 2858 } 2859 2860 x_frame_rehighlight (dpyinfo); 2861} 2862 2863 2864/* Handle FocusIn and FocusOut state changes for FRAME. 2865 If FRAME has focus and there exists more than one frame, puts 2866 a FOCUS_IN_EVENT into *BUFP. */ 2867 2868static void 2869x_focus_changed (type, state, dpyinfo, frame, bufp) 2870 int type; 2871 int state; 2872 struct w32_display_info *dpyinfo; 2873 struct frame *frame; 2874 struct input_event *bufp; 2875{ 2876 if (type == WM_SETFOCUS) 2877 { 2878 if (dpyinfo->w32_focus_event_frame != frame) 2879 { 2880 x_new_focus_frame (dpyinfo, frame); 2881 dpyinfo->w32_focus_event_frame = frame; 2882 2883 /* Don't stop displaying the initial startup message 2884 for a switch-frame event we don't need. */ 2885 if (GC_NILP (Vterminal_frame) 2886 && GC_CONSP (Vframe_list) 2887 && !GC_NILP (XCDR (Vframe_list))) 2888 { 2889 bufp->kind = FOCUS_IN_EVENT; 2890 XSETFRAME (bufp->frame_or_window, frame); 2891 } 2892 } 2893 2894 frame->output_data.x->focus_state |= state; 2895 2896 /* TODO: IME focus? */ 2897 } 2898 else if (type == WM_KILLFOCUS) 2899 { 2900 frame->output_data.x->focus_state &= ~state; 2901 2902 if (dpyinfo->w32_focus_event_frame == frame) 2903 { 2904 dpyinfo->w32_focus_event_frame = 0; 2905 x_new_focus_frame (dpyinfo, 0); 2906 } 2907 2908 /* TODO: IME focus? */ 2909 } 2910} 2911 2912 2913/* The focus may have changed. Figure out if it is a real focus change, 2914 by checking both FocusIn/Out and Enter/LeaveNotify events. 2915 2916 Returns FOCUS_IN_EVENT event in *BUFP. */ 2917 2918static void 2919w32_detect_focus_change (dpyinfo, event, bufp) 2920 struct w32_display_info *dpyinfo; 2921 W32Msg *event; 2922 struct input_event *bufp; 2923{ 2924 struct frame *frame; 2925 2926 frame = x_any_window_to_frame (dpyinfo, event->msg.hwnd); 2927 if (! frame) 2928 return; 2929 2930 /* On w32, this is only called from focus events, so no switch needed. */ 2931 x_focus_changed (event->msg.message, 2932 (event->msg.message == WM_KILLFOCUS ? 2933 FOCUS_IMPLICIT : FOCUS_EXPLICIT), 2934 dpyinfo, frame, bufp); 2935} 2936 2937 2938/* Handle an event saying the mouse has moved out of an Emacs frame. */ 2939 2940void 2941x_mouse_leave (dpyinfo) 2942 struct w32_display_info *dpyinfo; 2943{ 2944 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame); 2945} 2946 2947/* The focus has changed, or we have redirected a frame's focus to 2948 another frame (this happens when a frame uses a surrogate 2949 mini-buffer frame). Shift the highlight as appropriate. 2950 2951 The FRAME argument doesn't necessarily have anything to do with which 2952 frame is being highlighted or un-highlighted; we only use it to find 2953 the appropriate X display info. */ 2954 2955static void 2956w32_frame_rehighlight (frame) 2957 struct frame *frame; 2958{ 2959 if (! FRAME_W32_P (frame)) 2960 return; 2961 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame)); 2962} 2963 2964static void 2965x_frame_rehighlight (dpyinfo) 2966 struct w32_display_info *dpyinfo; 2967{ 2968 struct frame *old_highlight = dpyinfo->x_highlight_frame; 2969 2970 if (dpyinfo->w32_focus_frame) 2971 { 2972 dpyinfo->x_highlight_frame 2973 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))) 2974 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)) 2975 : dpyinfo->w32_focus_frame); 2976 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame)) 2977 { 2978 FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame) = Qnil; 2979 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame; 2980 } 2981 } 2982 else 2983 dpyinfo->x_highlight_frame = 0; 2984 2985 if (dpyinfo->x_highlight_frame != old_highlight) 2986 { 2987 if (old_highlight) 2988 frame_unhighlight (old_highlight); 2989 if (dpyinfo->x_highlight_frame) 2990 frame_highlight (dpyinfo->x_highlight_frame); 2991 } 2992} 2993 2994/* Keyboard processing - modifier keys, etc. */ 2995 2996/* Convert a keysym to its name. */ 2997 2998char * 2999x_get_keysym_name (keysym) 3000 int keysym; 3001{ 3002 /* Make static so we can always return it */ 3003 static char value[100]; 3004 3005 BLOCK_INPUT; 3006 GetKeyNameText (keysym, value, 100); 3007 UNBLOCK_INPUT; 3008 3009 return value; 3010} 3011 3012 3013 3014/* Mouse clicks and mouse movement. Rah. */ 3015 3016/* Parse a button MESSAGE. The button index is returned in PBUTTON, and 3017 the state in PUP. XBUTTON provides extra information for extended mouse 3018 button messages. Returns FALSE if unable to parse the message. */ 3019BOOL 3020parse_button (message, xbutton, pbutton, pup) 3021 int message; 3022 int xbutton; 3023 int * pbutton; 3024 int * pup; 3025{ 3026 int button = 0; 3027 int up = 0; 3028 3029 switch (message) 3030 { 3031 case WM_LBUTTONDOWN: 3032 button = 0; 3033 up = 0; 3034 break; 3035 case WM_LBUTTONUP: 3036 button = 0; 3037 up = 1; 3038 break; 3039 case WM_MBUTTONDOWN: 3040 if (NILP (Vw32_swap_mouse_buttons)) 3041 button = 1; 3042 else 3043 button = 2; 3044 up = 0; 3045 break; 3046 case WM_MBUTTONUP: 3047 if (NILP (Vw32_swap_mouse_buttons)) 3048 button = 1; 3049 else 3050 button = 2; 3051 up = 1; 3052 break; 3053 case WM_RBUTTONDOWN: 3054 if (NILP (Vw32_swap_mouse_buttons)) 3055 button = 2; 3056 else 3057 button = 1; 3058 up = 0; 3059 break; 3060 case WM_RBUTTONUP: 3061 if (NILP (Vw32_swap_mouse_buttons)) 3062 button = 2; 3063 else 3064 button = 1; 3065 up = 1; 3066 break; 3067 case WM_XBUTTONDOWN: 3068 button = xbutton + 2; 3069 up = 0; 3070 break; 3071 case WM_XBUTTONUP: 3072 button = xbutton + 2; 3073 up = 1; 3074 break; 3075 default: 3076 return (FALSE); 3077 } 3078 3079 if (pup) *pup = up; 3080 if (pbutton) *pbutton = button; 3081 3082 return (TRUE); 3083} 3084 3085 3086/* Prepare a mouse-event in *RESULT for placement in the input queue. 3087 3088 If the event is a button press, then note that we have grabbed 3089 the mouse. */ 3090 3091static Lisp_Object 3092construct_mouse_click (result, msg, f) 3093 struct input_event *result; 3094 W32Msg *msg; 3095 struct frame *f; 3096{ 3097 int button; 3098 int up; 3099 3100 parse_button (msg->msg.message, HIWORD (msg->msg.wParam), 3101 &button, &up); 3102 3103 /* Make the event type NO_EVENT; we'll change that when we decide 3104 otherwise. */ 3105 result->kind = MOUSE_CLICK_EVENT; 3106 result->code = button; 3107 result->timestamp = msg->msg.time; 3108 result->modifiers = (msg->dwModifiers 3109 | (up 3110 ? up_modifier 3111 : down_modifier)); 3112 3113 XSETINT (result->x, LOWORD (msg->msg.lParam)); 3114 XSETINT (result->y, HIWORD (msg->msg.lParam)); 3115 XSETFRAME (result->frame_or_window, f); 3116 result->arg = Qnil; 3117 return Qnil; 3118} 3119 3120static Lisp_Object 3121construct_mouse_wheel (result, msg, f) 3122 struct input_event *result; 3123 W32Msg *msg; 3124 struct frame *f; 3125{ 3126 POINT p; 3127 int delta; 3128 3129 result->kind = WHEEL_EVENT; 3130 result->code = 0; 3131 result->timestamp = msg->msg.time; 3132 3133 /* A WHEEL_DELTA positive value indicates that the wheel was rotated 3134 forward, away from the user (up); a negative value indicates that 3135 the wheel was rotated backward, toward the user (down). */ 3136 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam); 3137 3138 /* The up and down modifiers indicate if the wheel was rotated up or 3139 down based on WHEEL_DELTA value. */ 3140 result->modifiers = (msg->dwModifiers 3141 | ((delta < 0 ) ? down_modifier : up_modifier)); 3142 3143 /* With multiple monitors, we can legitimately get negative 3144 coordinates, so cast to short to interpret them correctly. */ 3145 p.x = (short) LOWORD (msg->msg.lParam); 3146 p.y = (short) HIWORD (msg->msg.lParam); 3147 ScreenToClient (msg->msg.hwnd, &p); 3148 XSETINT (result->x, p.x); 3149 XSETINT (result->y, p.y); 3150 XSETFRAME (result->frame_or_window, f); 3151 result->arg = Qnil; 3152 return Qnil; 3153} 3154 3155static Lisp_Object 3156construct_drag_n_drop (result, msg, f) 3157 struct input_event *result; 3158 W32Msg *msg; 3159 struct frame *f; 3160{ 3161 Lisp_Object files; 3162 Lisp_Object frame; 3163 HDROP hdrop; 3164 POINT p; 3165 WORD num_files; 3166 char *name; 3167 int i, len; 3168 3169 result->kind = DRAG_N_DROP_EVENT; 3170 result->code = 0; 3171 result->timestamp = msg->msg.time; 3172 result->modifiers = msg->dwModifiers; 3173 3174 hdrop = (HDROP) msg->msg.wParam; 3175 DragQueryPoint (hdrop, &p); 3176 3177#if 0 3178 p.x = LOWORD (msg->msg.lParam); 3179 p.y = HIWORD (msg->msg.lParam); 3180 ScreenToClient (msg->msg.hwnd, &p); 3181#endif 3182 3183 XSETINT (result->x, p.x); 3184 XSETINT (result->y, p.y); 3185 3186 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0); 3187 files = Qnil; 3188 3189 for (i = 0; i < num_files; i++) 3190 { 3191 len = DragQueryFile (hdrop, i, NULL, 0); 3192 if (len <= 0) 3193 continue; 3194 name = alloca (len + 1); 3195 DragQueryFile (hdrop, i, name, len + 1); 3196 files = Fcons (DECODE_FILE (build_string (name)), files); 3197 } 3198 3199 DragFinish (hdrop); 3200 3201 XSETFRAME (frame, f); 3202 result->frame_or_window = frame; 3203 result->arg = files; 3204 return Qnil; 3205} 3206 3207 3208/* Function to report a mouse movement to the mainstream Emacs code. 3209 The input handler calls this. 3210 3211 We have received a mouse movement event, which is given in *event. 3212 If the mouse is over a different glyph than it was last time, tell 3213 the mainstream emacs code by setting mouse_moved. If not, ask for 3214 another motion event, so we can check again the next time it moves. */ 3215 3216static MSG last_mouse_motion_event; 3217static Lisp_Object last_mouse_motion_frame; 3218 3219static int 3220note_mouse_movement (frame, msg) 3221 FRAME_PTR frame; 3222 MSG *msg; 3223{ 3224 int mouse_x = LOWORD (msg->lParam); 3225 int mouse_y = HIWORD (msg->lParam); 3226 3227 last_mouse_movement_time = msg->time; 3228 memcpy (&last_mouse_motion_event, msg, sizeof (last_mouse_motion_event)); 3229 XSETFRAME (last_mouse_motion_frame, frame); 3230 3231 if (msg->hwnd != FRAME_W32_WINDOW (frame)) 3232 { 3233 frame->mouse_moved = 1; 3234 last_mouse_scroll_bar = Qnil; 3235 note_mouse_highlight (frame, -1, -1); 3236 last_mouse_glyph_frame = 0; 3237 return 1; 3238 } 3239 3240 /* Has the mouse moved off the glyph it was on at the last sighting? */ 3241 if (frame != last_mouse_glyph_frame 3242 || mouse_x < last_mouse_glyph.left 3243 || mouse_x >= last_mouse_glyph.right 3244 || mouse_y < last_mouse_glyph.top 3245 || mouse_y >= last_mouse_glyph.bottom) 3246 { 3247 frame->mouse_moved = 1; 3248 last_mouse_scroll_bar = Qnil; 3249 note_mouse_highlight (frame, mouse_x, mouse_y); 3250 /* Remember the mouse position here, as w32_mouse_position only 3251 gets called when mouse tracking is enabled but we also need 3252 to keep track of the mouse for help_echo and highlighting at 3253 other times. */ 3254 remember_mouse_glyph (frame, mouse_x, mouse_y, &last_mouse_glyph); 3255 last_mouse_glyph_frame = frame; 3256 return 1; 3257 } 3258 3259 return 0; 3260} 3261 3262 3263/************************************************************************ 3264 Mouse Face 3265 ************************************************************************/ 3266 3267static struct scroll_bar *x_window_to_scroll_bar (); 3268static void x_scroll_bar_report_motion (); 3269static void x_check_fullscreen P_ ((struct frame *)); 3270 3271static void 3272redo_mouse_highlight () 3273{ 3274 if (!NILP (last_mouse_motion_frame) 3275 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame))) 3276 note_mouse_highlight (XFRAME (last_mouse_motion_frame), 3277 LOWORD (last_mouse_motion_event.lParam), 3278 HIWORD (last_mouse_motion_event.lParam)); 3279} 3280 3281void 3282w32_define_cursor (window, cursor) 3283 Window window; 3284 Cursor cursor; 3285{ 3286 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0); 3287} 3288/* Return the current position of the mouse. 3289 *fp should be a frame which indicates which display to ask about. 3290 3291 If the mouse movement started in a scroll bar, set *fp, *bar_window, 3292 and *part to the frame, window, and scroll bar part that the mouse 3293 is over. Set *x and *y to the portion and whole of the mouse's 3294 position on the scroll bar. 3295 3296 If the mouse movement started elsewhere, set *fp to the frame the 3297 mouse is on, *bar_window to nil, and *x and *y to the character cell 3298 the mouse is over. 3299 3300 Set *time to the server time-stamp for the time at which the mouse 3301 was at this position. 3302 3303 Don't store anything if we don't have a valid set of values to report. 3304 3305 This clears the mouse_moved flag, so we can wait for the next mouse 3306 movement. */ 3307 3308static void 3309w32_mouse_position (fp, insist, bar_window, part, x, y, time) 3310 FRAME_PTR *fp; 3311 int insist; 3312 Lisp_Object *bar_window; 3313 enum scroll_bar_part *part; 3314 Lisp_Object *x, *y; 3315 unsigned long *time; 3316{ 3317 FRAME_PTR f1; 3318 3319 BLOCK_INPUT; 3320 3321 if (! NILP (last_mouse_scroll_bar) && insist == 0) 3322 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time); 3323 else 3324 { 3325 POINT pt; 3326 3327 Lisp_Object frame, tail; 3328 3329 /* Clear the mouse-moved flag for every frame on this display. */ 3330 FOR_EACH_FRAME (tail, frame) 3331 XFRAME (frame)->mouse_moved = 0; 3332 3333 last_mouse_scroll_bar = Qnil; 3334 3335 GetCursorPos (&pt); 3336 3337 /* Now we have a position on the root; find the innermost window 3338 containing the pointer. */ 3339 { 3340 if (FRAME_W32_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame 3341 && FRAME_LIVE_P (last_mouse_frame)) 3342 { 3343 /* If mouse was grabbed on a frame, give coords for that frame 3344 even if the mouse is now outside it. */ 3345 f1 = last_mouse_frame; 3346 } 3347 else 3348 { 3349 /* Is window under mouse one of our frames? */ 3350 f1 = x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp), 3351 WindowFromPoint (pt)); 3352 } 3353 3354 /* If not, is it one of our scroll bars? */ 3355 if (! f1) 3356 { 3357 struct scroll_bar *bar 3358 = x_window_to_scroll_bar (WindowFromPoint (pt)); 3359 3360 if (bar) 3361 { 3362 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window))); 3363 } 3364 } 3365 3366 if (f1 == 0 && insist > 0) 3367 f1 = SELECTED_FRAME (); 3368 3369 if (f1) 3370 { 3371 /* Ok, we found a frame. Store all the values. 3372 last_mouse_glyph is a rectangle used to reduce the 3373 generation of mouse events. To not miss any motion 3374 events, we must divide the frame into rectangles of the 3375 size of the smallest character that could be displayed 3376 on it, i.e. into the same rectangles that matrices on 3377 the frame are divided into. */ 3378 3379 ScreenToClient (FRAME_W32_WINDOW (f1), &pt); 3380 remember_mouse_glyph (f1, pt.x, pt.y, &last_mouse_glyph); 3381 last_mouse_glyph_frame = f1; 3382 3383 *bar_window = Qnil; 3384 *part = 0; 3385 *fp = f1; 3386 XSETINT (*x, pt.x); 3387 XSETINT (*y, pt.y); 3388 *time = last_mouse_movement_time; 3389 } 3390 } 3391 } 3392 3393 UNBLOCK_INPUT; 3394} 3395 3396 3397/*********************************************************************** 3398 Tool-bars 3399 ***********************************************************************/ 3400 3401/* Handle mouse button event on the tool-bar of frame F, at 3402 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress 3403 or ButtonRelase. */ 3404 3405static void 3406w32_handle_tool_bar_click (f, button_event) 3407 struct frame *f; 3408 struct input_event *button_event; 3409{ 3410 int x = XFASTINT (button_event->x); 3411 int y = XFASTINT (button_event->y); 3412 3413 if (button_event->modifiers & down_modifier) 3414 handle_tool_bar_click (f, x, y, 1, 0); 3415 else 3416 handle_tool_bar_click (f, x, y, 0, 3417 button_event->modifiers & ~up_modifier); 3418} 3419 3420 3421 3422/*********************************************************************** 3423 Scroll bars 3424 ***********************************************************************/ 3425 3426/* Scroll bar support. */ 3427 3428/* Given a window ID, find the struct scroll_bar which manages it. 3429 This can be called in GC, so we have to make sure to strip off mark 3430 bits. */ 3431 3432static struct scroll_bar * 3433x_window_to_scroll_bar (window_id) 3434 Window window_id; 3435{ 3436 Lisp_Object tail; 3437 3438 for (tail = Vframe_list; 3439 XGCTYPE (tail) == Lisp_Cons; 3440 tail = XCDR (tail)) 3441 { 3442 Lisp_Object frame, bar, condemned; 3443 3444 frame = XCAR (tail); 3445 /* All elements of Vframe_list should be frames. */ 3446 if (! GC_FRAMEP (frame)) 3447 abort (); 3448 3449 /* Scan this frame's scroll bar list for a scroll bar with the 3450 right window ID. */ 3451 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame)); 3452 for (bar = FRAME_SCROLL_BARS (XFRAME (frame)); 3453 /* This trick allows us to search both the ordinary and 3454 condemned scroll bar lists with one loop. */ 3455 ! GC_NILP (bar) || (bar = condemned, 3456 condemned = Qnil, 3457 ! GC_NILP (bar)); 3458 bar = XSCROLL_BAR (bar)->next) 3459 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id) 3460 return XSCROLL_BAR (bar); 3461 } 3462 3463 return 0; 3464} 3465 3466 3467 3468/* Set the thumb size and position of scroll bar BAR. We are currently 3469 displaying PORTION out of a whole WHOLE, and our position POSITION. */ 3470 3471static void 3472w32_set_scroll_bar_thumb (bar, portion, position, whole) 3473 struct scroll_bar *bar; 3474 int portion, position, whole; 3475{ 3476 Window w = SCROLL_BAR_W32_WINDOW (bar); 3477 /* We use the whole scroll-bar height in the calculations below, to 3478 avoid strange effects like scrolling backwards when just clicking 3479 on the handle (without moving it). */ 3480 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) 3481 + VERTICAL_SCROLL_BAR_MIN_HANDLE; 3482 int sb_page, sb_pos; 3483 BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE; 3484 SCROLLINFO si; 3485 3486 /* We used to change the nPage setting while dragging the handle, 3487 but that had very strange effects (such as scrolling backwards 3488 while dragging downwards). 3489 3490 Now, we don't change the nPage setting while dragging unless we 3491 get near to the end of the buffer, in which case we often have to 3492 resize the handle to "go all the way". */ 3493 3494 if (draggingp) 3495 { 3496 int near_bottom_p; 3497 BLOCK_INPUT; 3498 si.cbSize = sizeof (si); 3499 si.fMask = SIF_POS | SIF_PAGE; 3500 GetScrollInfo(w, SB_CTL, &si); 3501 near_bottom_p = si.nPos + si.nPage >= range; 3502 UNBLOCK_INPUT; 3503 if (!near_bottom_p) 3504 return; 3505 } 3506 3507 if (whole) 3508 { 3509 /* Position scroll bar at rock bottom if the bottom of the 3510 buffer is visible. This avoids shinking the thumb away 3511 to nothing if it is held at the bottom of the buffer. */ 3512 if (position + portion >= whole && !draggingp) 3513 { 3514 sb_page = range * (whole - position) / whole; 3515 sb_pos = range; 3516 } 3517 else 3518 { 3519 sb_pos = position * range / whole; 3520 sb_page = (min (portion, (whole - position)) * range) / whole; 3521 } 3522 } 3523 else 3524 { 3525 sb_page = range; 3526 sb_pos = 0; 3527 } 3528 3529 sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE); 3530 3531 BLOCK_INPUT; 3532 3533 si.cbSize = sizeof (si); 3534 si.fMask = SIF_PAGE | SIF_POS; 3535 si.nPage = sb_page; 3536 si.nPos = sb_pos; 3537 3538 SetScrollInfo (w, SB_CTL, &si, TRUE); 3539 3540 UNBLOCK_INPUT; 3541} 3542 3543 3544/************************************************************************ 3545 Scroll bars, general 3546 ************************************************************************/ 3547 3548HWND 3549my_create_scrollbar (f, bar) 3550 struct frame * f; 3551 struct scroll_bar * bar; 3552{ 3553 return (HWND) SendMessage (FRAME_W32_WINDOW (f), 3554 WM_EMACS_CREATESCROLLBAR, (WPARAM) f, 3555 (LPARAM) bar); 3556} 3557 3558/*#define ATTACH_THREADS*/ 3559 3560static BOOL 3561my_show_window (FRAME_PTR f, HWND hwnd, int how) 3562{ 3563#ifndef ATTACH_THREADS 3564 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW, 3565 (WPARAM) hwnd, (LPARAM) how); 3566#else 3567 return ShowWindow (hwnd, how); 3568#endif 3569} 3570 3571static void 3572my_set_window_pos (HWND hwnd, HWND hwndAfter, 3573 int x, int y, int cx, int cy, UINT flags) 3574{ 3575#ifndef ATTACH_THREADS 3576 WINDOWPOS pos; 3577 pos.hwndInsertAfter = hwndAfter; 3578 pos.x = x; 3579 pos.y = y; 3580 pos.cx = cx; 3581 pos.cy = cy; 3582 pos.flags = flags; 3583 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0); 3584#else 3585 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags); 3586#endif 3587} 3588 3589static void 3590my_set_focus (f, hwnd) 3591 struct frame * f; 3592 HWND hwnd; 3593{ 3594 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS, 3595 (WPARAM) hwnd, 0); 3596} 3597 3598static void 3599my_set_foreground_window (hwnd) 3600 HWND hwnd; 3601{ 3602 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0); 3603} 3604 3605 3606static void 3607my_destroy_window (f, hwnd) 3608 struct frame * f; 3609 HWND hwnd; 3610{ 3611 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW, 3612 (WPARAM) hwnd, 0); 3613} 3614 3615/* Create a scroll bar and return the scroll bar vector for it. W is 3616 the Emacs window on which to create the scroll bar. TOP, LEFT, 3617 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the 3618 scroll bar. */ 3619 3620static struct scroll_bar * 3621x_scroll_bar_create (w, top, left, width, height) 3622 struct window *w; 3623 int top, left, width, height; 3624{ 3625 struct frame *f = XFRAME (WINDOW_FRAME (w)); 3626 HWND hwnd; 3627 SCROLLINFO si; 3628 struct scroll_bar *bar 3629 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil)); 3630 3631 BLOCK_INPUT; 3632 3633 XSETWINDOW (bar->window, w); 3634 XSETINT (bar->top, top); 3635 XSETINT (bar->left, left); 3636 XSETINT (bar->width, width); 3637 XSETINT (bar->height, height); 3638 XSETINT (bar->start, 0); 3639 XSETINT (bar->end, 0); 3640 bar->dragging = Qnil; 3641 3642 /* Requires geometry to be set before call to create the real window */ 3643 3644 hwnd = my_create_scrollbar (f, bar); 3645 3646 si.cbSize = sizeof (si); 3647 si.fMask = SIF_ALL; 3648 si.nMin = 0; 3649 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height) 3650 + VERTICAL_SCROLL_BAR_MIN_HANDLE; 3651 si.nPage = si.nMax; 3652 si.nPos = 0; 3653 3654 SetScrollInfo (hwnd, SB_CTL, &si, FALSE); 3655 3656 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd); 3657 3658 /* Add bar to its frame's list of scroll bars. */ 3659 bar->next = FRAME_SCROLL_BARS (f); 3660 bar->prev = Qnil; 3661 XSETVECTOR (FRAME_SCROLL_BARS (f), bar); 3662 if (! NILP (bar->next)) 3663 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar); 3664 3665 UNBLOCK_INPUT; 3666 3667 return bar; 3668} 3669 3670 3671/* Destroy scroll bar BAR, and set its Emacs window's scroll bar to 3672 nil. */ 3673 3674static void 3675x_scroll_bar_remove (bar) 3676 struct scroll_bar *bar; 3677{ 3678 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window))); 3679 3680 BLOCK_INPUT; 3681 3682 /* Destroy the window. */ 3683 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar)); 3684 3685 /* Disassociate this scroll bar from its window. */ 3686 XWINDOW (bar->window)->vertical_scroll_bar = Qnil; 3687 3688 UNBLOCK_INPUT; 3689} 3690 3691/* Set the handle of the vertical scroll bar for WINDOW to indicate 3692 that we are displaying PORTION characters out of a total of WHOLE 3693 characters, starting at POSITION. If WINDOW has no scroll bar, 3694 create one. */ 3695static void 3696w32_set_vertical_scroll_bar (w, portion, whole, position) 3697 struct window *w; 3698 int portion, whole, position; 3699{ 3700 struct frame *f = XFRAME (w->frame); 3701 struct scroll_bar *bar; 3702 int top, height, left, sb_left, width, sb_width; 3703 int window_y, window_height; 3704 3705 /* Get window dimensions. */ 3706 window_box (w, -1, 0, &window_y, 0, &window_height); 3707 top = window_y; 3708 width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f); 3709 height = window_height; 3710 3711 /* Compute the left edge of the scroll bar area. */ 3712 left = WINDOW_SCROLL_BAR_AREA_X (w); 3713 3714 /* Compute the width of the scroll bar which might be less than 3715 the width of the area reserved for the scroll bar. */ 3716 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0) 3717 sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w); 3718 else 3719 sb_width = width; 3720 3721 /* Compute the left edge of the scroll bar. */ 3722 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)) 3723 sb_left = left + width - sb_width - (width - sb_width) / 2; 3724 else 3725 sb_left = left + (width - sb_width) / 2; 3726 3727 /* Does the scroll bar exist yet? */ 3728 if (NILP (w->vertical_scroll_bar)) 3729 { 3730 HDC hdc; 3731 BLOCK_INPUT; 3732 if (width > 0 && height > 0) 3733 { 3734 hdc = get_frame_dc (f); 3735 w32_clear_area (f, hdc, left, top, width, height); 3736 release_frame_dc (f, hdc); 3737 } 3738 UNBLOCK_INPUT; 3739 3740 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height); 3741 } 3742 else 3743 { 3744 /* It may just need to be moved and resized. */ 3745 HWND hwnd; 3746 3747 bar = XSCROLL_BAR (w->vertical_scroll_bar); 3748 hwnd = SCROLL_BAR_W32_WINDOW (bar); 3749 3750 /* If already correctly positioned, do nothing. */ 3751 if ( XINT (bar->left) == sb_left 3752 && XINT (bar->top) == top 3753 && XINT (bar->width) == sb_width 3754 && XINT (bar->height) == height ) 3755 { 3756 /* Redraw after clear_frame. */ 3757 if (!my_show_window (f, hwnd, SW_NORMAL)) 3758 InvalidateRect (hwnd, NULL, FALSE); 3759 } 3760 else 3761 { 3762 HDC hdc; 3763 SCROLLINFO si; 3764 3765 BLOCK_INPUT; 3766 if (width && height) 3767 { 3768 hdc = get_frame_dc (f); 3769 /* Since Windows scroll bars are smaller than the space reserved 3770 for them on the frame, we have to clear "under" them. */ 3771 w32_clear_area (f, hdc, 3772 left, 3773 top, 3774 width, 3775 height); 3776 release_frame_dc (f, hdc); 3777 } 3778 /* Make sure scroll bar is "visible" before moving, to ensure the 3779 area of the parent window now exposed will be refreshed. */ 3780 my_show_window (f, hwnd, SW_HIDE); 3781 MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, 3782 top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, 3783 max (height, 1), TRUE); 3784 3785 si.cbSize = sizeof (si); 3786 si.fMask = SIF_RANGE; 3787 si.nMin = 0; 3788 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height) 3789 + VERTICAL_SCROLL_BAR_MIN_HANDLE; 3790 3791 SetScrollInfo (hwnd, SB_CTL, &si, FALSE); 3792 3793 my_show_window (f, hwnd, SW_NORMAL); 3794 /* InvalidateRect (w, NULL, FALSE); */ 3795 3796 /* Remember new settings. */ 3797 XSETINT (bar->left, sb_left); 3798 XSETINT (bar->top, top); 3799 XSETINT (bar->width, sb_width); 3800 XSETINT (bar->height, height); 3801 3802 UNBLOCK_INPUT; 3803 } 3804 } 3805 w32_set_scroll_bar_thumb (bar, portion, position, whole); 3806 3807 XSETVECTOR (w->vertical_scroll_bar, bar); 3808} 3809 3810 3811/* The following three hooks are used when we're doing a thorough 3812 redisplay of the frame. We don't explicitly know which scroll bars 3813 are going to be deleted, because keeping track of when windows go 3814 away is a real pain - "Can you say set-window-configuration, boys 3815 and girls?" Instead, we just assert at the beginning of redisplay 3816 that *all* scroll bars are to be removed, and then save a scroll bar 3817 from the fiery pit when we actually redisplay its window. */ 3818 3819/* Arrange for all scroll bars on FRAME to be removed at the next call 3820 to `*judge_scroll_bars_hook'. A scroll bar may be spared if 3821 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */ 3822 3823static void 3824w32_condemn_scroll_bars (frame) 3825 FRAME_PTR frame; 3826{ 3827 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */ 3828 while (! NILP (FRAME_SCROLL_BARS (frame))) 3829 { 3830 Lisp_Object bar; 3831 bar = FRAME_SCROLL_BARS (frame); 3832 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next; 3833 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame); 3834 XSCROLL_BAR (bar)->prev = Qnil; 3835 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame))) 3836 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar; 3837 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar; 3838 } 3839} 3840 3841 3842/* Un-mark WINDOW's scroll bar for deletion in this judgment cycle. 3843 Note that WINDOW isn't necessarily condemned at all. */ 3844 3845static void 3846w32_redeem_scroll_bar (window) 3847 struct window *window; 3848{ 3849 struct scroll_bar *bar; 3850 struct frame *f; 3851 3852 /* We can't redeem this window's scroll bar if it doesn't have one. */ 3853 if (NILP (window->vertical_scroll_bar)) 3854 abort (); 3855 3856 bar = XSCROLL_BAR (window->vertical_scroll_bar); 3857 3858 /* Unlink it from the condemned list. */ 3859 f = XFRAME (WINDOW_FRAME (window)); 3860 if (NILP (bar->prev)) 3861 { 3862 /* If the prev pointer is nil, it must be the first in one of 3863 the lists. */ 3864 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar)) 3865 /* It's not condemned. Everything's fine. */ 3866 return; 3867 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f), 3868 window->vertical_scroll_bar)) 3869 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next; 3870 else 3871 /* If its prev pointer is nil, it must be at the front of 3872 one or the other! */ 3873 abort (); 3874 } 3875 else 3876 XSCROLL_BAR (bar->prev)->next = bar->next; 3877 3878 if (! NILP (bar->next)) 3879 XSCROLL_BAR (bar->next)->prev = bar->prev; 3880 3881 bar->next = FRAME_SCROLL_BARS (f); 3882 bar->prev = Qnil; 3883 XSETVECTOR (FRAME_SCROLL_BARS (f), bar); 3884 if (! NILP (bar->next)) 3885 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar); 3886} 3887 3888/* Remove all scroll bars on FRAME that haven't been saved since the 3889 last call to `*condemn_scroll_bars_hook'. */ 3890 3891static void 3892w32_judge_scroll_bars (f) 3893 FRAME_PTR f; 3894{ 3895 Lisp_Object bar, next; 3896 3897 bar = FRAME_CONDEMNED_SCROLL_BARS (f); 3898 3899 /* Clear out the condemned list now so we won't try to process any 3900 more events on the hapless scroll bars. */ 3901 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil; 3902 3903 for (; ! NILP (bar); bar = next) 3904 { 3905 struct scroll_bar *b = XSCROLL_BAR (bar); 3906 3907 x_scroll_bar_remove (b); 3908 3909 next = b->next; 3910 b->next = b->prev = Qnil; 3911 } 3912 3913 /* Now there should be no references to the condemned scroll bars, 3914 and they should get garbage-collected. */ 3915} 3916 3917/* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind 3918 is set to something other than NO_EVENT, it is enqueued. 3919 3920 This may be called from a signal handler, so we have to ignore GC 3921 mark bits. */ 3922 3923static int 3924w32_scroll_bar_handle_click (bar, msg, emacs_event) 3925 struct scroll_bar *bar; 3926 W32Msg *msg; 3927 struct input_event *emacs_event; 3928{ 3929 if (! GC_WINDOWP (bar->window)) 3930 abort (); 3931 3932 emacs_event->kind = W32_SCROLL_BAR_CLICK_EVENT; 3933 emacs_event->code = 0; 3934 /* not really meaningful to distinguish up/down */ 3935 emacs_event->modifiers = msg->dwModifiers; 3936 emacs_event->frame_or_window = bar->window; 3937 emacs_event->arg = Qnil; 3938 emacs_event->timestamp = msg->msg.time; 3939 3940 { 3941 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)); 3942 int y; 3943 int dragging = !NILP (bar->dragging); 3944 SCROLLINFO si; 3945 3946 si.cbSize = sizeof (si); 3947 si.fMask = SIF_POS; 3948 3949 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si); 3950 y = si.nPos; 3951 3952 bar->dragging = Qnil; 3953 3954 3955 last_mouse_scroll_bar_pos = msg->msg.wParam; 3956 3957 switch (LOWORD (msg->msg.wParam)) 3958 { 3959 case SB_LINEDOWN: 3960 emacs_event->part = scroll_bar_down_arrow; 3961 break; 3962 case SB_LINEUP: 3963 emacs_event->part = scroll_bar_up_arrow; 3964 break; 3965 case SB_PAGEUP: 3966 emacs_event->part = scroll_bar_above_handle; 3967 break; 3968 case SB_PAGEDOWN: 3969 emacs_event->part = scroll_bar_below_handle; 3970 break; 3971 case SB_TOP: 3972 emacs_event->part = scroll_bar_handle; 3973 y = 0; 3974 break; 3975 case SB_BOTTOM: 3976 emacs_event->part = scroll_bar_handle; 3977 y = top_range; 3978 break; 3979 case SB_THUMBTRACK: 3980 case SB_THUMBPOSITION: 3981 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff) 3982 y = HIWORD (msg->msg.wParam); 3983 bar->dragging = Qt; 3984 emacs_event->part = scroll_bar_handle; 3985 3986 /* "Silently" update current position. */ 3987 { 3988 SCROLLINFO si; 3989 3990 si.cbSize = sizeof (si); 3991 si.fMask = SIF_POS; 3992 si.nPos = y; 3993 /* Remember apparent position (we actually lag behind the real 3994 position, so don't set that directly. */ 3995 last_scroll_bar_drag_pos = y; 3996 3997 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE); 3998 } 3999 break; 4000 case SB_ENDSCROLL: 4001 /* If this is the end of a drag sequence, then reset the scroll 4002 handle size to normal and do a final redraw. Otherwise do 4003 nothing. */ 4004 if (dragging) 4005 { 4006 SCROLLINFO si; 4007 int start = XINT (bar->start); 4008 int end = XINT (bar->end); 4009 4010 si.cbSize = sizeof (si); 4011 si.fMask = SIF_PAGE | SIF_POS; 4012 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE; 4013 si.nPos = last_scroll_bar_drag_pos; 4014 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE); 4015 } 4016 /* fall through */ 4017 default: 4018 emacs_event->kind = NO_EVENT; 4019 return FALSE; 4020 } 4021 4022 XSETINT (emacs_event->x, y); 4023 XSETINT (emacs_event->y, top_range); 4024 4025 return TRUE; 4026 } 4027} 4028 4029/* Return information to the user about the current position of the mouse 4030 on the scroll bar. */ 4031 4032static void 4033x_scroll_bar_report_motion (fp, bar_window, part, x, y, time) 4034 FRAME_PTR *fp; 4035 Lisp_Object *bar_window; 4036 enum scroll_bar_part *part; 4037 Lisp_Object *x, *y; 4038 unsigned long *time; 4039{ 4040 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar); 4041 Window w = SCROLL_BAR_W32_WINDOW (bar); 4042 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window))); 4043 int pos; 4044 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)); 4045 SCROLLINFO si; 4046 4047 BLOCK_INPUT; 4048 4049 *fp = f; 4050 *bar_window = bar->window; 4051 4052 si.cbSize = sizeof (si); 4053 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE; 4054 4055 GetScrollInfo (w, SB_CTL, &si); 4056 pos = si.nPos; 4057 top_range = si.nMax - si.nPage + 1; 4058 4059 switch (LOWORD (last_mouse_scroll_bar_pos)) 4060 { 4061 case SB_THUMBPOSITION: 4062 case SB_THUMBTRACK: 4063 *part = scroll_bar_handle; 4064 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff) 4065 pos = HIWORD (last_mouse_scroll_bar_pos); 4066 break; 4067 case SB_LINEDOWN: 4068 *part = scroll_bar_handle; 4069 pos++; 4070 break; 4071 default: 4072 *part = scroll_bar_handle; 4073 break; 4074 } 4075 4076 XSETINT (*x, pos); 4077 XSETINT (*y, top_range); 4078 4079 f->mouse_moved = 0; 4080 last_mouse_scroll_bar = Qnil; 4081 4082 *time = last_mouse_movement_time; 4083 4084 UNBLOCK_INPUT; 4085} 4086 4087 4088/* The screen has been cleared so we may have changed foreground or 4089 background colors, and the scroll bars may need to be redrawn. 4090 Clear out the scroll bars, and ask for expose events, so we can 4091 redraw them. */ 4092 4093void 4094x_scroll_bar_clear (f) 4095 FRAME_PTR f; 4096{ 4097 Lisp_Object bar; 4098 4099 /* We can have scroll bars even if this is 0, 4100 if we just turned off scroll bar mode. 4101 But in that case we should not clear them. */ 4102 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)) 4103 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar); 4104 bar = XSCROLL_BAR (bar)->next) 4105 { 4106 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)); 4107 HDC hdc = GetDC (window); 4108 RECT rect; 4109 4110 /* Hide scroll bar until ready to repaint. x_scroll_bar_move 4111 arranges to refresh the scroll bar if hidden. */ 4112 my_show_window (f, window, SW_HIDE); 4113 4114 GetClientRect (window, &rect); 4115 select_palette (f, hdc); 4116 w32_clear_rect (f, hdc, &rect); 4117 deselect_palette (f, hdc); 4118 4119 ReleaseDC (window, hdc); 4120 } 4121} 4122 4123 4124/* The main W32 event-reading loop - w32_read_socket. */ 4125 4126/* Record the last 100 characters stored 4127 to help debug the loss-of-chars-during-GC problem. */ 4128 4129static int temp_index; 4130static short temp_buffer[100]; 4131 4132 4133/* Read events coming from the W32 shell. 4134 This routine is called by the SIGIO handler. 4135 We return as soon as there are no more events to be read. 4136 4137 We return the number of characters stored into the buffer, 4138 thus pretending to be `read'. 4139 4140 EXPECTED is nonzero if the caller knows input is available. 4141 4142 Some of these messages are reposted back to the message queue since the 4143 system calls the windows proc directly in a context where we cannot return 4144 the data nor can we guarantee the state we are in. So if we dispatch them 4145 we will get into an infinite loop. To prevent this from ever happening we 4146 will set a variable to indicate we are in the read_socket call and indicate 4147 which message we are processing since the windows proc gets called 4148 recursively with different messages by the system. 4149*/ 4150 4151int 4152w32_read_socket (sd, expected, hold_quit) 4153 register int sd; 4154 int expected; 4155 struct input_event *hold_quit; 4156{ 4157 int count = 0; 4158 int check_visibility = 0; 4159 W32Msg msg; 4160 struct frame *f; 4161 struct w32_display_info *dpyinfo = &one_w32_display_info; 4162 4163 if (interrupt_input_blocked) 4164 { 4165 interrupt_input_pending = 1; 4166 return -1; 4167 } 4168 4169 interrupt_input_pending = 0; 4170 BLOCK_INPUT; 4171 4172 /* So people can tell when we have read the available input. */ 4173 input_signal_count++; 4174 4175 /* TODO: ghostscript integration. */ 4176 while (get_next_msg (&msg, FALSE)) 4177 { 4178 struct input_event inev; 4179 int do_help = 0; 4180 4181 EVENT_INIT (inev); 4182 inev.kind = NO_EVENT; 4183 inev.arg = Qnil; 4184 4185 switch (msg.msg.message) 4186 { 4187 case WM_PAINT: 4188 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4189 4190 if (f) 4191 { 4192 if (msg.rect.right == msg.rect.left || 4193 msg.rect.bottom == msg.rect.top) 4194 { 4195 /* We may get paint messages even though the client 4196 area is clipped - these are not expose events. */ 4197 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f, 4198 SDATA (f->name))); 4199 } 4200 else if (f->async_visible != 1) 4201 { 4202 /* Definitely not obscured, so mark as visible. */ 4203 f->async_visible = 1; 4204 f->async_iconified = 0; 4205 SET_FRAME_GARBAGED (f); 4206 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f, 4207 SDATA (f->name))); 4208 4209 /* WM_PAINT serves as MapNotify as well, so report 4210 visibility changes properly. */ 4211 if (f->iconified) 4212 { 4213 inev.kind = DEICONIFY_EVENT; 4214 XSETFRAME (inev.frame_or_window, f); 4215 } 4216 else if (! NILP (Vframe_list) 4217 && ! NILP (XCDR (Vframe_list))) 4218 /* Force a redisplay sooner or later to update the 4219 frame titles in case this is the second frame. */ 4220 record_asynch_buffer_change (); 4221 } 4222 else 4223 { 4224 HDC hdc = get_frame_dc (f); 4225 4226 /* Erase background again for safety. */ 4227 w32_clear_rect (f, hdc, &msg.rect); 4228 release_frame_dc (f, hdc); 4229 expose_frame (f, 4230 msg.rect.left, 4231 msg.rect.top, 4232 msg.rect.right - msg.rect.left, 4233 msg.rect.bottom - msg.rect.top); 4234 } 4235 } 4236 break; 4237 4238 case WM_INPUTLANGCHANGE: 4239 /* Generate a language change event. */ 4240 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4241 4242 if (f) 4243 { 4244 inev.kind = LANGUAGE_CHANGE_EVENT; 4245 XSETFRAME (inev.frame_or_window, f); 4246 inev.code = msg.msg.wParam; 4247 inev.modifiers = msg.msg.lParam & 0xffff; 4248 } 4249 break; 4250 4251 case WM_KEYDOWN: 4252 case WM_SYSKEYDOWN: 4253 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4254 4255 if (f && !f->iconified) 4256 { 4257 if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight) 4258 && !EQ (f->tool_bar_window, dpyinfo->mouse_face_window)) 4259 { 4260 clear_mouse_face (dpyinfo); 4261 dpyinfo->mouse_face_hidden = 1; 4262 } 4263 4264 if (temp_index == sizeof temp_buffer / sizeof (short)) 4265 temp_index = 0; 4266 temp_buffer[temp_index++] = msg.msg.wParam; 4267 inev.kind = NON_ASCII_KEYSTROKE_EVENT; 4268 inev.code = msg.msg.wParam; 4269 inev.modifiers = msg.dwModifiers; 4270 XSETFRAME (inev.frame_or_window, f); 4271 inev.timestamp = msg.msg.time; 4272 } 4273 break; 4274 4275 case WM_SYSCHAR: 4276 case WM_CHAR: 4277 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4278 4279 if (f && !f->iconified) 4280 { 4281 if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight) 4282 && !EQ (f->tool_bar_window, dpyinfo->mouse_face_window)) 4283 { 4284 clear_mouse_face (dpyinfo); 4285 dpyinfo->mouse_face_hidden = 1; 4286 } 4287 4288 if (temp_index == sizeof temp_buffer / sizeof (short)) 4289 temp_index = 0; 4290 temp_buffer[temp_index++] = msg.msg.wParam; 4291 inev.kind = ASCII_KEYSTROKE_EVENT; 4292 inev.code = msg.msg.wParam; 4293 inev.modifiers = msg.dwModifiers; 4294 XSETFRAME (inev.frame_or_window, f); 4295 inev.timestamp = msg.msg.time; 4296 } 4297 break; 4298 4299 case WM_MOUSEMOVE: 4300 /* Ignore non-movement. */ 4301 { 4302 int x = LOWORD (msg.msg.lParam); 4303 int y = HIWORD (msg.msg.lParam); 4304 if (x == last_mousemove_x && y == last_mousemove_y) 4305 break; 4306 last_mousemove_x = x; 4307 last_mousemove_y = y; 4308 } 4309 4310 previous_help_echo_string = help_echo_string; 4311 help_echo_string = Qnil; 4312 4313 if (dpyinfo->grabbed && last_mouse_frame 4314 && FRAME_LIVE_P (last_mouse_frame)) 4315 f = last_mouse_frame; 4316 else 4317 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4318 4319 if (dpyinfo->mouse_face_hidden) 4320 { 4321 dpyinfo->mouse_face_hidden = 0; 4322 clear_mouse_face (dpyinfo); 4323 } 4324 4325 if (f) 4326 { 4327 /* Generate SELECT_WINDOW_EVENTs when needed. */ 4328 if (!NILP (Vmouse_autoselect_window)) 4329 { 4330 Lisp_Object window; 4331 int x = LOWORD (msg.msg.lParam); 4332 int y = HIWORD (msg.msg.lParam); 4333 4334 window = window_from_coordinates (f, x, y, 0, 0, 0, 0); 4335 4336 /* Window will be selected only when it is not 4337 selected now and last mouse movement event was 4338 not in it. Minibuffer window will be selected 4339 iff it is active. */ 4340 if (WINDOWP(window) 4341 && !EQ (window, last_window) 4342 && !EQ (window, selected_window)) 4343 { 4344 inev.kind = SELECT_WINDOW_EVENT; 4345 inev.frame_or_window = window; 4346 } 4347 4348 last_window=window; 4349 } 4350 if (!note_mouse_movement (f, &msg.msg)) 4351 help_echo_string = previous_help_echo_string; 4352 } 4353 else 4354 { 4355 /* If we move outside the frame, then we're 4356 certainly no longer on any text in the frame. */ 4357 clear_mouse_face (dpyinfo); 4358 } 4359 4360 /* If the contents of the global variable help_echo_string 4361 has changed, generate a HELP_EVENT. */ 4362#if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE. 4363 But it was originally changed to this to fix a bug, so I have 4364 not removed it completely in case the bug is still there. */ 4365 if (help_echo_string != previous_help_echo_string || 4366 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved)) 4367#else /* This is what xterm.c does. */ 4368 if (!NILP (help_echo_string) 4369 || !NILP (previous_help_echo_string)) 4370 do_help = 1; 4371#endif 4372 break; 4373 4374 case WM_LBUTTONDOWN: 4375 case WM_LBUTTONUP: 4376 case WM_MBUTTONDOWN: 4377 case WM_MBUTTONUP: 4378 case WM_RBUTTONDOWN: 4379 case WM_RBUTTONUP: 4380 case WM_XBUTTONDOWN: 4381 case WM_XBUTTONUP: 4382 { 4383 /* If we decide we want to generate an event to be seen 4384 by the rest of Emacs, we put it here. */ 4385 int tool_bar_p = 0; 4386 int button; 4387 int up; 4388 4389 if (dpyinfo->grabbed && last_mouse_frame 4390 && FRAME_LIVE_P (last_mouse_frame)) 4391 f = last_mouse_frame; 4392 else 4393 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4394 4395 if (f) 4396 { 4397 construct_mouse_click (&inev, &msg, f); 4398 4399 /* Is this in the tool-bar? */ 4400 if (WINDOWP (f->tool_bar_window) 4401 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window))) 4402 { 4403 Lisp_Object window; 4404 int x = XFASTINT (inev.x); 4405 int y = XFASTINT (inev.y); 4406 4407 window = window_from_coordinates (f, x, y, 0, 0, 0, 1); 4408 4409 if (EQ (window, f->tool_bar_window)) 4410 { 4411 w32_handle_tool_bar_click (f, &inev); 4412 tool_bar_p = 1; 4413 } 4414 } 4415 4416 if (tool_bar_p 4417 || (dpyinfo->w32_focus_frame 4418 && f != dpyinfo->w32_focus_frame)) 4419 inev.kind = NO_EVENT; 4420 } 4421 4422 parse_button (msg.msg.message, HIWORD (msg.msg.wParam), 4423 &button, &up); 4424 4425 if (up) 4426 { 4427 dpyinfo->grabbed &= ~ (1 << button); 4428 } 4429 else 4430 { 4431 dpyinfo->grabbed |= (1 << button); 4432 last_mouse_frame = f; 4433 /* Ignore any mouse motion that happened 4434 before this event; any subsequent mouse-movement 4435 Emacs events should reflect only motion after 4436 the ButtonPress. */ 4437 if (f != 0) 4438 f->mouse_moved = 0; 4439 4440 if (!tool_bar_p) 4441 last_tool_bar_item = -1; 4442 } 4443 break; 4444 } 4445 4446 case WM_MOUSEWHEEL: 4447 { 4448 if (dpyinfo->grabbed && last_mouse_frame 4449 && FRAME_LIVE_P (last_mouse_frame)) 4450 f = last_mouse_frame; 4451 else 4452 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4453 4454 if (f) 4455 { 4456 4457 if (!dpyinfo->w32_focus_frame 4458 || f == dpyinfo->w32_focus_frame) 4459 { 4460 /* Emit an Emacs wheel-up/down event. */ 4461 construct_mouse_wheel (&inev, &msg, f); 4462 } 4463 /* Ignore any mouse motion that happened before this 4464 event; any subsequent mouse-movement Emacs events 4465 should reflect only motion after the 4466 ButtonPress. */ 4467 f->mouse_moved = 0; 4468 } 4469 last_mouse_frame = f; 4470 last_tool_bar_item = -1; 4471 } 4472 break; 4473 4474 case WM_DROPFILES: 4475 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4476 4477 if (f) 4478 construct_drag_n_drop (&inev, &msg, f); 4479 break; 4480 4481 case WM_VSCROLL: 4482 { 4483 struct scroll_bar *bar = 4484 x_window_to_scroll_bar ((HWND)msg.msg.lParam); 4485 4486 if (bar) 4487 w32_scroll_bar_handle_click (bar, &msg, &inev); 4488 break; 4489 } 4490 4491 case WM_WINDOWPOSCHANGED: 4492 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4493 if (f) 4494 { 4495 if (f->want_fullscreen & FULLSCREEN_WAIT) 4496 f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH); 4497 } 4498 check_visibility = 1; 4499 break; 4500 4501 case WM_ACTIVATE: 4502 case WM_ACTIVATEAPP: 4503 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4504 if (f) 4505 x_check_fullscreen (f); 4506 check_visibility = 1; 4507 break; 4508 4509 case WM_MOVE: 4510 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4511 4512 if (f && !f->async_iconified) 4513 { 4514 int x, y; 4515 4516 x_real_positions (f, &x, &y); 4517 f->left_pos = x; 4518 f->top_pos = y; 4519 } 4520 4521 check_visibility = 1; 4522 break; 4523 4524 case WM_SHOWWINDOW: 4525 /* wParam non-zero means Window is about to be shown, 0 means 4526 about to be hidden. */ 4527 /* Redo the mouse-highlight after the tooltip has gone. */ 4528 if (!msg.msg.wParam && msg.msg.hwnd == tip_window) 4529 { 4530 tip_window = NULL; 4531 redo_mouse_highlight (); 4532 } 4533 4534 /* If window has been obscured or exposed by another window 4535 being maximised or minimised/restored, then recheck 4536 visibility of all frames. Direct changes to our own 4537 windows get handled by WM_SIZE. */ 4538#if 0 4539 if (msg.msg.lParam != 0) 4540 check_visibility = 1; 4541 else 4542 { 4543 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4544 f->async_visible = msg.msg.wParam; 4545 } 4546#endif 4547 4548 check_visibility = 1; 4549 break; 4550 4551 case WM_SIZE: 4552 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4553 4554 /* Inform lisp of whether frame has been iconified etc. */ 4555 if (f) 4556 { 4557 switch (msg.msg.wParam) 4558 { 4559 case SIZE_MINIMIZED: 4560 f->async_visible = 0; 4561 f->async_iconified = 1; 4562 4563 inev.kind = ICONIFY_EVENT; 4564 XSETFRAME (inev.frame_or_window, f); 4565 break; 4566 4567 case SIZE_MAXIMIZED: 4568 case SIZE_RESTORED: 4569 f->async_visible = 1; 4570 f->async_iconified = 0; 4571 4572 /* wait_reading_process_output will notice this and update 4573 the frame's display structures. */ 4574 SET_FRAME_GARBAGED (f); 4575 4576 if (f->iconified) 4577 { 4578 int x, y; 4579 4580 /* Reset top and left positions of the Window 4581 here since Windows sends a WM_MOVE message 4582 BEFORE telling us the Window is minimized 4583 when the Window is iconified, with 3000,3000 4584 as the co-ords. */ 4585 x_real_positions (f, &x, &y); 4586 f->left_pos = x; 4587 f->top_pos = y; 4588 4589 inev.kind = DEICONIFY_EVENT; 4590 XSETFRAME (inev.frame_or_window, f); 4591 } 4592 else if (! NILP (Vframe_list) 4593 && ! NILP (XCDR (Vframe_list))) 4594 /* Force a redisplay sooner or later 4595 to update the frame titles 4596 in case this is the second frame. */ 4597 record_asynch_buffer_change (); 4598 break; 4599 } 4600 } 4601 4602 if (f && !f->async_iconified && msg.msg.wParam != SIZE_MINIMIZED) 4603 { 4604 RECT rect; 4605 int rows; 4606 int columns; 4607 int width; 4608 int height; 4609 4610 GetClientRect (msg.msg.hwnd, &rect); 4611 4612 height = rect.bottom - rect.top; 4613 width = rect.right - rect.left; 4614 4615 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); 4616 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); 4617 4618 /* TODO: Clip size to the screen dimensions. */ 4619 4620 /* Even if the number of character rows and columns has 4621 not changed, the font size may have changed, so we need 4622 to check the pixel dimensions as well. */ 4623 4624 if (columns != FRAME_COLS (f) 4625 || rows != FRAME_LINES (f) 4626 || width != FRAME_PIXEL_WIDTH (f) 4627 || height != FRAME_PIXEL_HEIGHT (f)) 4628 { 4629 change_frame_size (f, rows, columns, 0, 1, 0); 4630 SET_FRAME_GARBAGED (f); 4631 cancel_mouse_face (f); 4632 FRAME_PIXEL_WIDTH (f) = width; 4633 FRAME_PIXEL_HEIGHT (f) = height; 4634 f->win_gravity = NorthWestGravity; 4635 } 4636 } 4637 4638 check_visibility = 1; 4639 break; 4640 4641 case WM_MOUSELEAVE: 4642 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd); 4643 if (f) 4644 { 4645 if (f == dpyinfo->mouse_face_mouse_frame) 4646 { 4647 /* If we move outside the frame, then we're 4648 certainly no longer on any text in the frame. */ 4649 clear_mouse_face (dpyinfo); 4650 dpyinfo->mouse_face_mouse_frame = 0; 4651 } 4652 4653 /* Generate a nil HELP_EVENT to cancel a help-echo. 4654 Do it only if there's something to cancel. 4655 Otherwise, the startup message is cleared when 4656 the mouse leaves the frame. */ 4657 if (any_help_event_p) 4658 do_help = -1; 4659 } 4660 break; 4661 4662 case WM_SETFOCUS: 4663 w32_detect_focus_change (dpyinfo, &msg, &inev); 4664 4665 dpyinfo->grabbed = 0; 4666 check_visibility = 1; 4667 break; 4668 4669 case WM_KILLFOCUS: 4670 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd); 4671 4672 if (f) 4673 { 4674 if (f == dpyinfo->w32_focus_event_frame) 4675 dpyinfo->w32_focus_event_frame = 0; 4676 4677 if (f == dpyinfo->w32_focus_frame) 4678 x_new_focus_frame (dpyinfo, 0); 4679 4680 if (f == dpyinfo->mouse_face_mouse_frame) 4681 { 4682 /* If we move outside the frame, then we're 4683 certainly no longer on any text in the frame. */ 4684 clear_mouse_face (dpyinfo); 4685 dpyinfo->mouse_face_mouse_frame = 0; 4686 } 4687 4688 /* Generate a nil HELP_EVENT to cancel a help-echo. 4689 Do it only if there's something to cancel. 4690 Otherwise, the startup message is cleared when 4691 the mouse leaves the frame. */ 4692 if (any_help_event_p) 4693 do_help = -1; 4694 } 4695 4696 dpyinfo->grabbed = 0; 4697 check_visibility = 1; 4698 break; 4699 4700 case WM_CLOSE: 4701 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4702 4703 if (f) 4704 { 4705 inev.kind = DELETE_WINDOW_EVENT; 4706 XSETFRAME (inev.frame_or_window, f); 4707 } 4708 break; 4709 4710 case WM_INITMENU: 4711 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4712 4713 if (f) 4714 { 4715 inev.kind = MENU_BAR_ACTIVATE_EVENT; 4716 XSETFRAME (inev.frame_or_window, f); 4717 } 4718 break; 4719 4720 case WM_COMMAND: 4721 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4722 4723 if (f) 4724 { 4725 extern void menubar_selection_callback 4726 (FRAME_PTR f, void * client_data); 4727 menubar_selection_callback (f, (void *)msg.msg.wParam); 4728 } 4729 4730 check_visibility = 1; 4731 break; 4732 4733 case WM_DISPLAYCHANGE: 4734 f = x_window_to_frame (dpyinfo, msg.msg.hwnd); 4735 4736 if (f) 4737 { 4738 dpyinfo->width = (short) LOWORD (msg.msg.lParam); 4739 dpyinfo->height = (short) HIWORD (msg.msg.lParam); 4740 dpyinfo->n_cbits = msg.msg.wParam; 4741 DebPrint (("display change: %d %d\n", dpyinfo->width, 4742 dpyinfo->height)); 4743 } 4744 4745 check_visibility = 1; 4746 break; 4747 4748 default: 4749 /* Check for messages registered at runtime. */ 4750 if (msg.msg.message == msh_mousewheel) 4751 { 4752 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */ 4753 msg.msg.message = WM_MOUSEWHEEL; 4754 prepend_msg (&msg); 4755 } 4756 break; 4757 } 4758 4759 if (inev.kind != NO_EVENT) 4760 { 4761 kbd_buffer_store_event_hold (&inev, hold_quit); 4762 count++; 4763 } 4764 4765 if (do_help 4766 && !(hold_quit && hold_quit->kind != NO_EVENT)) 4767 { 4768 Lisp_Object frame; 4769 4770 if (f) 4771 XSETFRAME (frame, f); 4772 else 4773 frame = Qnil; 4774 4775 if (do_help > 0) 4776 { 4777 if (NILP (help_echo_string)) 4778 { 4779 help_echo_object = help_echo_window = Qnil; 4780 help_echo_pos = -1; 4781 } 4782 4783 any_help_event_p = 1; 4784 gen_help_event (help_echo_string, frame, help_echo_window, 4785 help_echo_object, help_echo_pos); 4786 } 4787 else 4788 { 4789 help_echo_string = Qnil; 4790 gen_help_event (Qnil, frame, Qnil, Qnil, 0); 4791 } 4792 count++; 4793 } 4794 } 4795 4796 /* If the focus was just given to an autoraising frame, 4797 raise it now. */ 4798 /* ??? This ought to be able to handle more than one such frame. */ 4799 if (pending_autoraise_frame) 4800 { 4801 x_raise_frame (pending_autoraise_frame); 4802 pending_autoraise_frame = 0; 4803 } 4804 4805 /* Check which frames are still visisble, if we have enqueued any user 4806 events or been notified of events that may affect visibility. We 4807 do this here because there doesn't seem to be any direct 4808 notification from Windows that the visibility of a window has 4809 changed (at least, not in all cases). */ 4810 if (count > 0 || check_visibility) 4811 { 4812 Lisp_Object tail, frame; 4813 4814 FOR_EACH_FRAME (tail, frame) 4815 { 4816 FRAME_PTR f = XFRAME (frame); 4817 /* The tooltip has been drawn already. Avoid the 4818 SET_FRAME_GARBAGED below. */ 4819 if (EQ (frame, tip_frame)) 4820 continue; 4821 4822 /* Check "visible" frames and mark each as obscured or not. 4823 Note that async_visible is nonzero for unobscured and 4824 obscured frames, but zero for hidden and iconified frames. */ 4825 if (FRAME_W32_P (f) && f->async_visible) 4826 { 4827 RECT clipbox; 4828 HDC hdc; 4829 4830 enter_crit (); 4831 /* Query clipping rectangle for the entire window area 4832 (GetWindowDC), not just the client portion (GetDC). 4833 Otherwise, the scrollbars and menubar aren't counted as 4834 part of the visible area of the frame, and we may think 4835 the frame is obscured when really a scrollbar is still 4836 visible and gets WM_PAINT messages above. */ 4837 hdc = GetWindowDC (FRAME_W32_WINDOW (f)); 4838 GetClipBox (hdc, &clipbox); 4839 ReleaseDC (FRAME_W32_WINDOW (f), hdc); 4840 leave_crit (); 4841 4842 if (clipbox.right == clipbox.left 4843 || clipbox.bottom == clipbox.top) 4844 { 4845 /* Frame has become completely obscured so mark as 4846 such (we do this by setting async_visible to 2 so 4847 that FRAME_VISIBLE_P is still true, but redisplay 4848 will skip it). */ 4849 f->async_visible = 2; 4850 4851 if (!FRAME_OBSCURED_P (f)) 4852 { 4853 DebPrint (("frame %p (%s) obscured\n", f, 4854 SDATA (f->name))); 4855 } 4856 } 4857 else 4858 { 4859 /* Frame is not obscured, so mark it as such. */ 4860 f->async_visible = 1; 4861 4862 if (FRAME_OBSCURED_P (f)) 4863 { 4864 SET_FRAME_GARBAGED (f); 4865 DebPrint (("obscured frame %p (%s) found to be visible\n", f, 4866 SDATA (f->name))); 4867 4868 /* Force a redisplay sooner or later. */ 4869 record_asynch_buffer_change (); 4870 } 4871 } 4872 } 4873 } 4874 } 4875 4876 UNBLOCK_INPUT; 4877 return count; 4878} 4879 4880 4881 4882/*********************************************************************** 4883 Text Cursor 4884 ***********************************************************************/ 4885 4886/* Set clipping for output in glyph row ROW. W is the window in which 4887 we operate. GC is the graphics context to set clipping in. 4888 4889 ROW may be a text row or, e.g., a mode line. Text rows must be 4890 clipped to the interior of the window dedicated to text display, 4891 mode lines must be clipped to the whole window. */ 4892 4893static void 4894w32_clip_to_row (w, row, area, hdc) 4895 struct window *w; 4896 struct glyph_row *row; 4897 int area; 4898 HDC hdc; 4899{ 4900 struct frame *f = XFRAME (WINDOW_FRAME (w)); 4901 RECT clip_rect; 4902 int window_x, window_y, window_width; 4903 4904 window_box (w, area, &window_x, &window_y, &window_width, 0); 4905 4906 clip_rect.left = window_x; 4907 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y); 4908 clip_rect.top = max (clip_rect.top, window_y); 4909 clip_rect.right = clip_rect.left + window_width; 4910 clip_rect.bottom = clip_rect.top + row->visible_height; 4911 4912 w32_set_clip_rectangle (hdc, &clip_rect); 4913} 4914 4915 4916/* Draw a hollow box cursor on window W in glyph row ROW. */ 4917 4918static void 4919x_draw_hollow_cursor (w, row) 4920 struct window *w; 4921 struct glyph_row *row; 4922{ 4923 struct frame *f = XFRAME (WINDOW_FRAME (w)); 4924 HDC hdc; 4925 RECT rect; 4926 int left, top, h; 4927 struct glyph *cursor_glyph; 4928 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel); 4929 4930 /* Get the glyph the cursor is on. If we can't tell because 4931 the current matrix is invalid or such, give up. */ 4932 cursor_glyph = get_phys_cursor_glyph (w); 4933 if (cursor_glyph == NULL) 4934 return; 4935 4936 /* Compute frame-relative coordinates for phys cursor. */ 4937 get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h); 4938 rect.left = left; 4939 rect.top = top; 4940 rect.bottom = rect.top + h; 4941 rect.right = rect.left + w->phys_cursor_width; 4942 4943 hdc = get_frame_dc (f); 4944 /* Set clipping, draw the rectangle, and reset clipping again. */ 4945 w32_clip_to_row (w, row, TEXT_AREA, hdc); 4946 FrameRect (hdc, &rect, hb); 4947 DeleteObject (hb); 4948 w32_set_clip_rectangle (hdc, NULL); 4949 release_frame_dc (f, hdc); 4950} 4951 4952 4953/* Draw a bar cursor on window W in glyph row ROW. 4954 4955 Implementation note: One would like to draw a bar cursor with an 4956 angle equal to the one given by the font property XA_ITALIC_ANGLE. 4957 Unfortunately, I didn't find a font yet that has this property set. 4958 --gerd. */ 4959 4960static void 4961x_draw_bar_cursor (w, row, width, kind) 4962 struct window *w; 4963 struct glyph_row *row; 4964 int width; 4965 enum text_cursor_kinds kind; 4966{ 4967 struct frame *f = XFRAME (w->frame); 4968 struct glyph *cursor_glyph; 4969 int x; 4970 HDC hdc; 4971 4972 /* If cursor is out of bounds, don't draw garbage. This can happen 4973 in mini-buffer windows when switching between echo area glyphs 4974 and mini-buffer. */ 4975 cursor_glyph = get_phys_cursor_glyph (w); 4976 if (cursor_glyph == NULL) 4977 return; 4978 4979 /* If on an image, draw like a normal cursor. That's usually better 4980 visible than drawing a bar, esp. if the image is large so that 4981 the bar might not be in the window. */ 4982 if (cursor_glyph->type == IMAGE_GLYPH) 4983 { 4984 struct glyph_row *row; 4985 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos); 4986 draw_phys_cursor_glyph (w, row, DRAW_CURSOR); 4987 } 4988 else 4989 { 4990 COLORREF cursor_color = f->output_data.w32->cursor_pixel; 4991 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id); 4992 4993 /* If the glyph's background equals the color we normally draw 4994 the bar cursor in, the bar cursor in its normal color is 4995 invisible. Use the glyph's foreground color instead in this 4996 case, on the assumption that the glyph's colors are chosen so 4997 that the glyph is legible. */ 4998 if (face->background == cursor_color) 4999 cursor_color = face->foreground; 5000 5001 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x); 5002 5003 if (width < 0) 5004 width = FRAME_CURSOR_WIDTH (f); 5005 width = min (cursor_glyph->pixel_width, width); 5006 5007 w->phys_cursor_width = width; 5008 5009 5010 hdc = get_frame_dc (f); 5011 w32_clip_to_row (w, row, TEXT_AREA, hdc); 5012 5013 if (kind == BAR_CURSOR) 5014 { 5015 w32_fill_area (f, hdc, cursor_color, x, 5016 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y), 5017 width, row->height); 5018 } 5019 else 5020 { 5021 w32_fill_area (f, hdc, cursor_color, x, 5022 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y + 5023 row->height - width), 5024 cursor_glyph->pixel_width, width); 5025 } 5026 5027 w32_set_clip_rectangle (hdc, NULL); 5028 release_frame_dc (f, hdc); 5029 } 5030} 5031 5032 5033/* RIF: Define cursor CURSOR on frame F. */ 5034 5035static void 5036w32_define_frame_cursor (f, cursor) 5037 struct frame *f; 5038 Cursor cursor; 5039{ 5040 w32_define_cursor (FRAME_W32_WINDOW (f), cursor); 5041} 5042 5043 5044/* RIF: Clear area on frame F. */ 5045 5046static void 5047w32_clear_frame_area (f, x, y, width, height) 5048 struct frame *f; 5049 int x, y, width, height; 5050{ 5051 HDC hdc; 5052 5053 hdc = get_frame_dc (f); 5054 w32_clear_area (f, hdc, x, y, width, height); 5055 release_frame_dc (f, hdc); 5056} 5057 5058/* RIF: Draw or clear cursor on window W. */ 5059 5060static void 5061w32_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, active_p) 5062 struct window *w; 5063 struct glyph_row *glyph_row; 5064 int x, y; 5065 int cursor_type, cursor_width; 5066 int on_p, active_p; 5067{ 5068 if (on_p) 5069 { 5070 /* If the user wants to use the system caret, make sure our own 5071 cursor remains invisible. */ 5072 if (w32_use_visible_system_caret) 5073 { 5074 /* Call to erase_phys_cursor here seems to use the 5075 wrong values of w->phys_cursor, as they have been 5076 overwritten before this function was called. */ 5077 if (w->phys_cursor_type != NO_CURSOR) 5078 erase_phys_cursor (w); 5079 5080 cursor_type = w->phys_cursor_type = NO_CURSOR; 5081 w->phys_cursor_width = -1; 5082 } 5083 else 5084 { 5085 w->phys_cursor_type = cursor_type; 5086 } 5087 5088 w->phys_cursor_on_p = 1; 5089 5090 /* If this is the active cursor, we need to track it with the 5091 system caret, so third party software like screen magnifiers 5092 and speech synthesizers can follow the cursor. */ 5093 if (active_p) 5094 { 5095 struct frame *f = XFRAME (WINDOW_FRAME (w)); 5096 HWND hwnd = FRAME_W32_WINDOW (f); 5097 5098 w32_system_caret_x 5099 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x); 5100 w32_system_caret_y 5101 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y) 5102 + glyph_row->ascent - w->phys_cursor_ascent); 5103 5104 /* If the size of the active cursor changed, destroy the old 5105 system caret. */ 5106 if (w32_system_caret_hwnd 5107 && (w32_system_caret_height != w->phys_cursor_height)) 5108 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0); 5109 5110 w32_system_caret_height = w->phys_cursor_height; 5111 5112 /* Move the system caret. */ 5113 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0); 5114 } 5115 5116 if (glyph_row->exact_window_width_line_p 5117 && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA]) 5118 { 5119 glyph_row->cursor_in_fringe_p = 1; 5120 draw_fringe_bitmap (w, glyph_row, 0); 5121 return; 5122 } 5123 5124 switch (cursor_type) 5125 { 5126 case HOLLOW_BOX_CURSOR: 5127 x_draw_hollow_cursor (w, glyph_row); 5128 break; 5129 5130 case FILLED_BOX_CURSOR: 5131 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR); 5132 break; 5133 5134 case BAR_CURSOR: 5135 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR); 5136 break; 5137 5138 case HBAR_CURSOR: 5139 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR); 5140 break; 5141 5142 case NO_CURSOR: 5143 w->phys_cursor_width = 0; 5144 break; 5145 5146 default: 5147 abort (); 5148 } 5149 } 5150} 5151 5152 5153 5154/* Icons. */ 5155 5156int 5157x_bitmap_icon (f, icon) 5158 struct frame *f; 5159 Lisp_Object icon; 5160{ 5161 HANDLE main_icon; 5162 HANDLE small_icon = NULL; 5163 5164 if (FRAME_W32_WINDOW (f) == 0) 5165 return 1; 5166 5167 if (NILP (icon)) 5168 main_icon = LoadIcon (hinst, EMACS_CLASS); 5169 else if (STRINGP (icon)) 5170 { 5171 /* Load the main icon from the named file. */ 5172 main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0, 5173 LR_DEFAULTSIZE | LR_LOADFROMFILE); 5174 /* Try to load a small icon to go with it. */ 5175 small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON, 5176 GetSystemMetrics (SM_CXSMICON), 5177 GetSystemMetrics (SM_CYSMICON), 5178 LR_LOADFROMFILE); 5179 } 5180 else if (SYMBOLP (icon)) 5181 { 5182 LPCTSTR name; 5183 5184 if (EQ (icon, intern ("application"))) 5185 name = (LPCTSTR) IDI_APPLICATION; 5186 else if (EQ (icon, intern ("hand"))) 5187 name = (LPCTSTR) IDI_HAND; 5188 else if (EQ (icon, intern ("question"))) 5189 name = (LPCTSTR) IDI_QUESTION; 5190 else if (EQ (icon, intern ("exclamation"))) 5191 name = (LPCTSTR) IDI_EXCLAMATION; 5192 else if (EQ (icon, intern ("asterisk"))) 5193 name = (LPCTSTR) IDI_ASTERISK; 5194 else if (EQ (icon, intern ("winlogo"))) 5195 name = (LPCTSTR) IDI_WINLOGO; 5196 else 5197 return 1; 5198 5199 main_icon = LoadIcon (NULL, name); 5200 } 5201 else 5202 return 1; 5203 5204 if (main_icon == NULL) 5205 return 1; 5206 5207 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG, 5208 (LPARAM) main_icon); 5209 5210 /* If there is a small icon that goes with it, set that too. */ 5211 if (small_icon) 5212 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL, 5213 (LPARAM) small_icon); 5214 5215 return 0; 5216} 5217 5218 5219/************************************************************************ 5220 Handling X errors 5221 ************************************************************************/ 5222 5223/* Display Error Handling functions not used on W32. Listing them here 5224 helps diff stay in step when comparing w32term.c with xterm.c. 5225 5226x_error_catcher (display, error) 5227x_catch_errors (dpy) 5228x_catch_errors_unwind (old_val) 5229x_check_errors (dpy, format) 5230x_fully_uncatch_errors () 5231x_catching_errors () 5232x_had_errors_p (dpy) 5233x_clear_errors (dpy) 5234x_uncatch_errors (dpy, count) 5235x_trace_wire () 5236x_connection_signal (signalnum) 5237x_connection_closed (dpy, error_message) 5238x_error_quitter (display, error) 5239x_error_handler (display, error) 5240x_io_error_quitter (display) 5241 5242 */ 5243 5244 5245/* Changing the font of the frame. */ 5246 5247/* Give frame F the font named FONTNAME as its default font, and 5248 return the full name of that font. FONTNAME may be a wildcard 5249 pattern; in that case, we choose some font that fits the pattern. 5250 The return value shows which font we chose. */ 5251 5252Lisp_Object 5253x_new_font (f, fontname) 5254 struct frame *f; 5255 register char *fontname; 5256{ 5257 struct font_info *fontp 5258 = FS_LOAD_FONT (f, 0, fontname, -1); 5259 5260 if (!fontp) 5261 return Qnil; 5262 5263 FRAME_FONT (f) = (XFontStruct *) (fontp->font); 5264 FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset; 5265 FRAME_FONTSET (f) = -1; 5266 5267 FRAME_COLUMN_WIDTH (f) = fontp->average_width; 5268 FRAME_SPACE_WIDTH (f) = fontp->space_width; 5269 FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f)); 5270 5271 compute_fringe_widths (f, 1); 5272 5273 /* Compute the scroll bar width in character columns. */ 5274 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0) 5275 { 5276 int wid = FRAME_COLUMN_WIDTH (f); 5277 FRAME_CONFIG_SCROLL_BAR_COLS (f) 5278 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid; 5279 } 5280 else 5281 { 5282 int wid = FRAME_COLUMN_WIDTH (f); 5283 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid; 5284 } 5285 5286 /* Now make the frame display the given font. */ 5287 if (FRAME_W32_WINDOW (f) != 0) 5288 { 5289 if (NILP (tip_frame) || XFRAME (tip_frame) != f) 5290 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f)); 5291 } 5292 5293 return build_string (fontp->full_name); 5294} 5295 5296/* Give frame F the fontset named FONTSETNAME as its default font, and 5297 return the full name of that fontset. FONTSETNAME may be a wildcard 5298 pattern; in that case, we choose some fontset that fits the pattern. 5299 The return value shows which fontset we chose. */ 5300 5301Lisp_Object 5302x_new_fontset (f, fontsetname) 5303 struct frame *f; 5304 char *fontsetname; 5305{ 5306 int fontset = fs_query_fontset (build_string (fontsetname), 0); 5307 Lisp_Object result; 5308 5309 if (fontset < 0) 5310 return Qnil; 5311 5312 if (FRAME_FONTSET (f) == fontset) 5313 /* This fontset is already set in frame F. There's nothing more 5314 to do. */ 5315 return fontset_name (fontset); 5316 5317 result = x_new_font (f, (SDATA (fontset_ascii (fontset)))); 5318 5319 if (!STRINGP (result)) 5320 /* Can't load ASCII font. */ 5321 return Qnil; 5322 5323 /* Since x_new_font doesn't update any fontset information, do it now. */ 5324 FRAME_FONTSET(f) = fontset; 5325 5326 return build_string (fontsetname); 5327} 5328 5329 5330/*********************************************************************** 5331 TODO: W32 Input Methods 5332 ***********************************************************************/ 5333/* Listing missing functions from xterm.c helps diff stay in step. 5334 5335xim_destroy_callback (xim, client_data, call_data) 5336xim_open_dpy (dpyinfo, resource_name) 5337struct xim_inst_t 5338xim_instantiate_callback (display, client_data, call_data) 5339xim_initialize (dpyinfo, resource_name) 5340xim_close_dpy (dpyinfo) 5341 5342 */ 5343 5344 5345/* Calculate the absolute position in frame F 5346 from its current recorded position values and gravity. */ 5347 5348void 5349x_calc_absolute_position (f) 5350 struct frame *f; 5351{ 5352 int flags = f->size_hint_flags; 5353 5354 /* The sum of the widths of the frame's left and right borders, and 5355 the sum of the heights of the frame's top and bottom borders (in 5356 pixels) drawn by Windows. */ 5357 unsigned int left_right_borders_width, top_bottom_borders_height; 5358 5359 /* Try to get the actual values of these two variables. We compute 5360 the border width (height) by subtracting the width (height) of 5361 the frame's client area from the width (height) of the frame's 5362 entire window. */ 5363 WINDOWPLACEMENT wp = { 0 }; 5364 RECT client_rect = { 0 }; 5365 5366 if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp) 5367 && GetClientRect (FRAME_W32_WINDOW (f), &client_rect)) 5368 { 5369 left_right_borders_width = 5370 (wp.rcNormalPosition.right - wp.rcNormalPosition.left) - 5371 (client_rect.right - client_rect.left); 5372 5373 top_bottom_borders_height = 5374 (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) - 5375 (client_rect.bottom - client_rect.top); 5376 } 5377 else 5378 { 5379 /* Use sensible default values. */ 5380 left_right_borders_width = 8; 5381 top_bottom_borders_height = 32; 5382 } 5383 5384 /* Treat negative positions as relative to the rightmost bottommost 5385 position that fits on the screen. */ 5386 if (flags & XNegative) 5387 f->left_pos = (FRAME_W32_DISPLAY_INFO (f)->width 5388 - FRAME_PIXEL_WIDTH (f) 5389 + f->left_pos 5390 - (left_right_borders_width - 1)); 5391 5392 if (flags & YNegative) 5393 f->top_pos = (FRAME_W32_DISPLAY_INFO (f)->height 5394 - FRAME_PIXEL_HEIGHT (f) 5395 + f->top_pos 5396 - (top_bottom_borders_height - 1)); 5397 5398 /* The left_pos and top_pos are now relative to the top and left 5399 screen edges, so the flags should correspond. */ 5400 f->size_hint_flags &= ~ (XNegative | YNegative); 5401} 5402 5403/* CHANGE_GRAVITY is 1 when calling from Fset_frame_position, 5404 to really change the position, and 0 when calling from 5405 x_make_frame_visible (in that case, XOFF and YOFF are the current 5406 position values). It is -1 when calling from x_set_frame_parameters, 5407 which means, do adjust for borders but don't change the gravity. */ 5408 5409void 5410x_set_offset (f, xoff, yoff, change_gravity) 5411 struct frame *f; 5412 register int xoff, yoff; 5413 int change_gravity; 5414{ 5415 int modified_top, modified_left; 5416 5417 if (change_gravity > 0) 5418 { 5419 f->top_pos = yoff; 5420 f->left_pos = xoff; 5421 f->size_hint_flags &= ~ (XNegative | YNegative); 5422 if (xoff < 0) 5423 f->size_hint_flags |= XNegative; 5424 if (yoff < 0) 5425 f->size_hint_flags |= YNegative; 5426 f->win_gravity = NorthWestGravity; 5427 } 5428 x_calc_absolute_position (f); 5429 5430 BLOCK_INPUT; 5431 x_wm_set_size_hint (f, (long) 0, 0); 5432 5433 modified_left = f->left_pos; 5434 modified_top = f->top_pos; 5435 5436 my_set_window_pos (FRAME_W32_WINDOW (f), 5437 NULL, 5438 modified_left, modified_top, 5439 0, 0, 5440 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE); 5441 UNBLOCK_INPUT; 5442} 5443 5444 5445/* Check if we need to resize the frame due to a fullscreen request. 5446 If so needed, resize the frame. */ 5447static void 5448x_check_fullscreen (f) 5449 struct frame *f; 5450{ 5451 if (f->want_fullscreen & FULLSCREEN_BOTH) 5452 { 5453 int width, height, ign; 5454 5455 x_real_positions (f, &f->left_pos, &f->top_pos); 5456 5457 x_fullscreen_adjust (f, &width, &height, &ign, &ign); 5458 5459 /* We do not need to move the window, it shall be taken care of 5460 when setting WM manager hints. */ 5461 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height) 5462 { 5463 change_frame_size (f, height, width, 0, 1, 0); 5464 SET_FRAME_GARBAGED (f); 5465 cancel_mouse_face (f); 5466 5467 /* Wait for the change of frame size to occur */ 5468 f->want_fullscreen |= FULLSCREEN_WAIT; 5469 } 5470 } 5471} 5472 5473/* Call this to change the size of frame F's x-window. 5474 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity 5475 for this size change and subsequent size changes. 5476 Otherwise we leave the window gravity unchanged. */ 5477 5478void 5479x_set_window_size (f, change_gravity, cols, rows) 5480 struct frame *f; 5481 int change_gravity; 5482 int cols, rows; 5483{ 5484 int pixelwidth, pixelheight; 5485 5486 BLOCK_INPUT; 5487 5488 check_frame_size (f, &rows, &cols); 5489 f->scroll_bar_actual_width 5490 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f); 5491 5492 compute_fringe_widths (f, 0); 5493 5494 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols); 5495 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows); 5496 5497 f->win_gravity = NorthWestGravity; 5498 x_wm_set_size_hint (f, (long) 0, 0); 5499 5500 { 5501 RECT rect; 5502 5503 rect.left = rect.top = 0; 5504 rect.right = pixelwidth; 5505 rect.bottom = pixelheight; 5506 5507 AdjustWindowRect(&rect, f->output_data.w32->dwStyle, 5508 FRAME_EXTERNAL_MENU_BAR (f)); 5509 5510 my_set_window_pos (FRAME_W32_WINDOW (f), 5511 NULL, 5512 0, 0, 5513 rect.right - rect.left, 5514 rect.bottom - rect.top, 5515 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE); 5516 } 5517 5518 /* Now, strictly speaking, we can't be sure that this is accurate, 5519 but the window manager will get around to dealing with the size 5520 change request eventually, and we'll hear how it went when the 5521 ConfigureNotify event gets here. 5522 5523 We could just not bother storing any of this information here, 5524 and let the ConfigureNotify event set everything up, but that 5525 might be kind of confusing to the Lisp code, since size changes 5526 wouldn't be reported in the frame parameters until some random 5527 point in the future when the ConfigureNotify event arrives. 5528 5529 We pass 1 for DELAY since we can't run Lisp code inside of 5530 a BLOCK_INPUT. */ 5531 change_frame_size (f, rows, cols, 0, 1, 0); 5532 FRAME_PIXEL_WIDTH (f) = pixelwidth; 5533 FRAME_PIXEL_HEIGHT (f) = pixelheight; 5534 5535 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to 5536 receive in the ConfigureNotify event; if we get what we asked 5537 for, then the event won't cause the screen to become garbaged, so 5538 we have to make sure to do it here. */ 5539 SET_FRAME_GARBAGED (f); 5540 5541 /* If cursor was outside the new size, mark it as off. */ 5542 mark_window_cursors_off (XWINDOW (f->root_window)); 5543 5544 /* Clear out any recollection of where the mouse highlighting was, 5545 since it might be in a place that's outside the new frame size. 5546 Actually checking whether it is outside is a pain in the neck, 5547 so don't try--just let the highlighting be done afresh with new size. */ 5548 cancel_mouse_face (f); 5549 5550 UNBLOCK_INPUT; 5551} 5552 5553/* Mouse warping. */ 5554 5555void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y); 5556 5557void 5558x_set_mouse_position (f, x, y) 5559 struct frame *f; 5560 int x, y; 5561{ 5562 int pix_x, pix_y; 5563 5564 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2; 5565 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2; 5566 5567 if (pix_x < 0) pix_x = 0; 5568 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f); 5569 5570 if (pix_y < 0) pix_y = 0; 5571 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f); 5572 5573 x_set_mouse_pixel_position (f, pix_x, pix_y); 5574} 5575 5576void 5577x_set_mouse_pixel_position (f, pix_x, pix_y) 5578 struct frame *f; 5579 int pix_x, pix_y; 5580{ 5581 RECT rect; 5582 POINT pt; 5583 5584 BLOCK_INPUT; 5585 5586 GetClientRect (FRAME_W32_WINDOW (f), &rect); 5587 pt.x = rect.left + pix_x; 5588 pt.y = rect.top + pix_y; 5589 ClientToScreen (FRAME_W32_WINDOW (f), &pt); 5590 5591 SetCursorPos (pt.x, pt.y); 5592 5593 UNBLOCK_INPUT; 5594} 5595 5596 5597/* focus shifting, raising and lowering. */ 5598 5599void 5600x_focus_on_frame (f) 5601 struct frame *f; 5602{ 5603 struct w32_display_info *dpyinfo = &one_w32_display_info; 5604 5605 /* Give input focus to frame. */ 5606 BLOCK_INPUT; 5607#if 0 5608 /* Try not to change its Z-order if possible. */ 5609 if (x_window_to_frame (dpyinfo, GetForegroundWindow ())) 5610 my_set_focus (f, FRAME_W32_WINDOW (f)); 5611 else 5612#endif 5613 my_set_foreground_window (FRAME_W32_WINDOW (f)); 5614 UNBLOCK_INPUT; 5615} 5616 5617void 5618x_unfocus_frame (f) 5619 struct frame *f; 5620{ 5621} 5622 5623/* Raise frame F. */ 5624void 5625x_raise_frame (f) 5626 struct frame *f; 5627{ 5628 BLOCK_INPUT; 5629 5630 /* Strictly speaking, raise-frame should only change the frame's Z 5631 order, leaving input focus unchanged. This is reasonable behaviour 5632 on X where the usual policy is point-to-focus. However, this 5633 behaviour would be very odd on Windows where the usual policy is 5634 click-to-focus. 5635 5636 On X, if the mouse happens to be over the raised frame, it gets 5637 input focus anyway (so the window with focus will never be 5638 completely obscured) - if not, then just moving the mouse over it 5639 is sufficient to give it focus. On Windows, the user must actually 5640 click on the frame (preferrably the title bar so as not to move 5641 point), which is more awkward. Also, no other Windows program 5642 raises a window to the top but leaves another window (possibly now 5643 completely obscured) with input focus. 5644 5645 Because there is a system setting on Windows that allows the user 5646 to choose the point to focus policy, we make the strict semantics 5647 optional, but by default we grab focus when raising. */ 5648 5649 if (NILP (Vw32_grab_focus_on_raise)) 5650 { 5651 /* The obvious call to my_set_window_pos doesn't work if Emacs is 5652 not already the foreground application: the frame is raised 5653 above all other frames belonging to us, but not above the 5654 current top window. To achieve that, we have to resort to this 5655 more cumbersome method. */ 5656 5657 HDWP handle = BeginDeferWindowPos (2); 5658 if (handle) 5659 { 5660 DeferWindowPos (handle, 5661 FRAME_W32_WINDOW (f), 5662 HWND_TOP, 5663 0, 0, 0, 0, 5664 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); 5665 5666 DeferWindowPos (handle, 5667 GetForegroundWindow (), 5668 FRAME_W32_WINDOW (f), 5669 0, 0, 0, 0, 5670 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); 5671 5672 EndDeferWindowPos (handle); 5673 } 5674 } 5675 else 5676 { 5677 my_set_foreground_window (FRAME_W32_WINDOW (f)); 5678 } 5679 5680 UNBLOCK_INPUT; 5681} 5682 5683/* Lower frame F. */ 5684void 5685x_lower_frame (f) 5686 struct frame *f; 5687{ 5688 BLOCK_INPUT; 5689 my_set_window_pos (FRAME_W32_WINDOW (f), 5690 HWND_BOTTOM, 5691 0, 0, 0, 0, 5692 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE); 5693 UNBLOCK_INPUT; 5694} 5695 5696static void 5697w32_frame_raise_lower (f, raise_flag) 5698 FRAME_PTR f; 5699 int raise_flag; 5700{ 5701 if (! FRAME_W32_P (f)) 5702 return; 5703 5704 if (raise_flag) 5705 x_raise_frame (f); 5706 else 5707 x_lower_frame (f); 5708} 5709 5710/* Change of visibility. */ 5711 5712/* This tries to wait until the frame is really visible. 5713 However, if the window manager asks the user where to position 5714 the frame, this will return before the user finishes doing that. 5715 The frame will not actually be visible at that time, 5716 but it will become visible later when the window manager 5717 finishes with it. */ 5718 5719void 5720x_make_frame_visible (f) 5721 struct frame *f; 5722{ 5723 Lisp_Object type; 5724 5725 BLOCK_INPUT; 5726 5727 type = x_icon_type (f); 5728 if (!NILP (type)) 5729 x_bitmap_icon (f, type); 5730 5731 if (! FRAME_VISIBLE_P (f)) 5732 { 5733 /* We test FRAME_GARBAGED_P here to make sure we don't 5734 call x_set_offset a second time 5735 if we get to x_make_frame_visible a second time 5736 before the window gets really visible. */ 5737 if (! FRAME_ICONIFIED_P (f) 5738 && ! f->output_data.w32->asked_for_visible) 5739 { 5740 RECT workarea_rect; 5741 RECT window_rect; 5742 5743 /* Adjust vertical window position in order to avoid being 5744 covered by a task bar placed at the bottom of the desktop. */ 5745 SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea_rect, 0); 5746 GetWindowRect(FRAME_W32_WINDOW(f), &window_rect); 5747 if (window_rect.bottom > workarea_rect.bottom 5748 && window_rect.top > workarea_rect.top) 5749 f->top_pos = max (window_rect.top 5750 - window_rect.bottom + workarea_rect.bottom, 5751 workarea_rect.top); 5752 5753 x_set_offset (f, f->left_pos, f->top_pos, 0); 5754 } 5755 5756 f->output_data.w32->asked_for_visible = 1; 5757 5758/* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */ 5759 my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL); 5760 } 5761 5762 /* Synchronize to ensure Emacs knows the frame is visible 5763 before we do anything else. We do this loop with input not blocked 5764 so that incoming events are handled. */ 5765 { 5766 Lisp_Object frame; 5767 int count; 5768 5769 /* This must come after we set COUNT. */ 5770 UNBLOCK_INPUT; 5771 5772 XSETFRAME (frame, f); 5773 5774 /* Wait until the frame is visible. Process X events until a 5775 MapNotify event has been seen, or until we think we won't get a 5776 MapNotify at all.. */ 5777 for (count = input_signal_count + 10; 5778 input_signal_count < count && !FRAME_VISIBLE_P (f);) 5779 { 5780 /* Force processing of queued events. */ 5781 /* TODO: x_sync equivalent? */ 5782 5783 /* Machines that do polling rather than SIGIO have been observed 5784 to go into a busy-wait here. So we'll fake an alarm signal 5785 to let the handler know that there's something to be read. 5786 We used to raise a real alarm, but it seems that the handler 5787 isn't always enabled here. This is probably a bug. */ 5788 if (input_polling_used ()) 5789 { 5790 /* It could be confusing if a real alarm arrives while processing 5791 the fake one. Turn it off and let the handler reset it. */ 5792 int old_poll_suppress_count = poll_suppress_count; 5793 poll_suppress_count = 1; 5794 poll_for_input_1 (); 5795 poll_suppress_count = old_poll_suppress_count; 5796 } 5797 } 5798 FRAME_SAMPLE_VISIBILITY (f); 5799 } 5800} 5801 5802/* Change from mapped state to withdrawn state. */ 5803 5804/* Make the frame visible (mapped and not iconified). */ 5805 5806x_make_frame_invisible (f) 5807 struct frame *f; 5808{ 5809 /* Don't keep the highlight on an invisible frame. */ 5810 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f) 5811 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0; 5812 5813 BLOCK_INPUT; 5814 5815 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE); 5816 5817 /* We can't distinguish this from iconification 5818 just by the event that we get from the server. 5819 So we can't win using the usual strategy of letting 5820 FRAME_SAMPLE_VISIBILITY set this. So do it by hand, 5821 and synchronize with the server to make sure we agree. */ 5822 f->visible = 0; 5823 FRAME_ICONIFIED_P (f) = 0; 5824 f->async_visible = 0; 5825 f->async_iconified = 0; 5826 5827 UNBLOCK_INPUT; 5828} 5829 5830/* Change window state from mapped to iconified. */ 5831 5832void 5833x_iconify_frame (f) 5834 struct frame *f; 5835{ 5836 Lisp_Object type; 5837 5838 /* Don't keep the highlight on an invisible frame. */ 5839 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f) 5840 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0; 5841 5842 if (f->async_iconified) 5843 return; 5844 5845 BLOCK_INPUT; 5846 5847 type = x_icon_type (f); 5848 if (!NILP (type)) 5849 x_bitmap_icon (f, type); 5850 5851 /* Simulate the user minimizing the frame. */ 5852 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0); 5853 5854 UNBLOCK_INPUT; 5855} 5856 5857 5858/* Free X resources of frame F. */ 5859 5860void 5861x_free_frame_resources (f) 5862 struct frame *f; 5863{ 5864 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 5865 5866 BLOCK_INPUT; 5867 5868 if (FRAME_W32_WINDOW (f)) 5869 my_destroy_window (f, FRAME_W32_WINDOW (f)); 5870 5871 free_frame_menubar (f); 5872 5873 unload_color (f, f->output_data.x->foreground_pixel); 5874 unload_color (f, f->output_data.x->background_pixel); 5875 unload_color (f, f->output_data.w32->cursor_pixel); 5876 unload_color (f, f->output_data.w32->cursor_foreground_pixel); 5877 unload_color (f, f->output_data.w32->border_pixel); 5878 unload_color (f, f->output_data.w32->mouse_pixel); 5879 if (f->output_data.w32->white_relief.allocated_p) 5880 unload_color (f, f->output_data.w32->white_relief.pixel); 5881 if (f->output_data.w32->black_relief.allocated_p) 5882 unload_color (f, f->output_data.w32->black_relief.pixel); 5883 5884 if (FRAME_FACE_CACHE (f)) 5885 free_frame_faces (f); 5886 5887 xfree (f->output_data.w32); 5888 f->output_data.w32 = NULL; 5889 5890 if (f == dpyinfo->w32_focus_frame) 5891 dpyinfo->w32_focus_frame = 0; 5892 if (f == dpyinfo->w32_focus_event_frame) 5893 dpyinfo->w32_focus_event_frame = 0; 5894 if (f == dpyinfo->x_highlight_frame) 5895 dpyinfo->x_highlight_frame = 0; 5896 5897 if (f == dpyinfo->mouse_face_mouse_frame) 5898 { 5899 dpyinfo->mouse_face_beg_row 5900 = dpyinfo->mouse_face_beg_col = -1; 5901 dpyinfo->mouse_face_end_row 5902 = dpyinfo->mouse_face_end_col = -1; 5903 dpyinfo->mouse_face_window = Qnil; 5904 dpyinfo->mouse_face_deferred_gc = 0; 5905 dpyinfo->mouse_face_mouse_frame = 0; 5906 } 5907 5908 UNBLOCK_INPUT; 5909} 5910 5911 5912/* Destroy the window of frame F. */ 5913 5914x_destroy_window (f) 5915 struct frame *f; 5916{ 5917 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 5918 5919 x_free_frame_resources (f); 5920 5921 dpyinfo->reference_count--; 5922} 5923 5924 5925/* Setting window manager hints. */ 5926 5927/* Set the normal size hints for the window manager, for frame F. 5928 FLAGS is the flags word to use--or 0 meaning preserve the flags 5929 that the window now has. 5930 If USER_POSITION is nonzero, we set the USPosition 5931 flag (this is useful when FLAGS is 0). */ 5932void 5933x_wm_set_size_hint (f, flags, user_position) 5934 struct frame *f; 5935 long flags; 5936 int user_position; 5937{ 5938 Window window = FRAME_W32_WINDOW (f); 5939 5940 enter_crit (); 5941 5942 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f)); 5943 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f)); 5944 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f)); 5945 SetWindowLong (window, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width); 5946 5947 leave_crit (); 5948} 5949 5950/* Window manager things */ 5951void 5952x_wm_set_icon_position (f, icon_x, icon_y) 5953 struct frame *f; 5954 int icon_x, icon_y; 5955{ 5956#if 0 5957 Window window = FRAME_W32_WINDOW (f); 5958 5959 f->display.x->wm_hints.flags |= IconPositionHint; 5960 f->display.x->wm_hints.icon_x = icon_x; 5961 f->display.x->wm_hints.icon_y = icon_y; 5962 5963 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints); 5964#endif 5965} 5966 5967 5968/*********************************************************************** 5969 Fonts 5970 ***********************************************************************/ 5971 5972/* The following functions are listed here to help diff stay in step 5973 with xterm.c. See w32fns.c for definitions. 5974 5975x_get_font_info (f, font_idx) 5976x_list_fonts (f, pattern, size, maxnames) 5977 5978 */ 5979 5980#if GLYPH_DEBUG 5981 5982/* Check that FONT is valid on frame F. It is if it can be found in F's 5983 font table. */ 5984 5985static void 5986x_check_font (f, font) 5987 struct frame *f; 5988 XFontStruct *font; 5989{ 5990 int i; 5991 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 5992 5993 xassert (font != NULL); 5994 5995 for (i = 0; i < dpyinfo->n_fonts; i++) 5996 if (dpyinfo->font_table[i].name 5997 && font == dpyinfo->font_table[i].font) 5998 break; 5999 6000 xassert (i < dpyinfo->n_fonts); 6001} 6002 6003#endif /* GLYPH_DEBUG != 0 */ 6004 6005/* Set *W to the minimum width, *H to the minimum font height of FONT. 6006 Note: There are (broken) X fonts out there with invalid XFontStruct 6007 min_bounds contents. For example, handa@etl.go.jp reports that 6008 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts 6009 have font->min_bounds.width == 0. */ 6010 6011static INLINE void 6012x_font_min_bounds (font, w, h) 6013 XFontStruct *font; 6014 int *w, *h; 6015{ 6016 /* 6017 * TODO: Windows does not appear to offer min bound, only 6018 * average and maximum width, and maximum height. 6019 */ 6020 *h = FONT_HEIGHT (font); 6021 *w = FONT_WIDTH (font); 6022} 6023 6024 6025/* Compute the smallest character width and smallest font height over 6026 all fonts available on frame F. Set the members smallest_char_width 6027 and smallest_font_height in F's x_display_info structure to 6028 the values computed. Value is non-zero if smallest_font_height or 6029 smallest_char_width become smaller than they were before. */ 6030 6031int 6032x_compute_min_glyph_bounds (f) 6033 struct frame *f; 6034{ 6035 int i; 6036 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f); 6037 XFontStruct *font; 6038 int old_width = dpyinfo->smallest_char_width; 6039 int old_height = dpyinfo->smallest_font_height; 6040 6041 dpyinfo->smallest_font_height = 100000; 6042 dpyinfo->smallest_char_width = 100000; 6043 6044 for (i = 0; i < dpyinfo->n_fonts; ++i) 6045 if (dpyinfo->font_table[i].name) 6046 { 6047 struct font_info *fontp = dpyinfo->font_table + i; 6048 int w, h; 6049 6050 font = (XFontStruct *) fontp->font; 6051 xassert (font != (XFontStruct *) ~0); 6052 x_font_min_bounds (font, &w, &h); 6053 6054 dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h); 6055 dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w); 6056 } 6057 6058 xassert (dpyinfo->smallest_char_width > 0 6059 && dpyinfo->smallest_font_height > 0); 6060 6061 return (dpyinfo->n_fonts == 1 6062 || dpyinfo->smallest_char_width < old_width 6063 || dpyinfo->smallest_font_height < old_height); 6064} 6065 6066/* The following functions are listed here to help diff stay in step 6067 with xterm.c. See w32fns.c for definitions. 6068 6069x_load_font (f, fontname, size) 6070x_query_font (f, fontname) 6071x_find_ccl_program (fontp) 6072 6073*/ 6074 6075/*********************************************************************** 6076 Initialization 6077 ***********************************************************************/ 6078 6079static int w32_initialized = 0; 6080 6081void 6082w32_initialize_display_info (display_name) 6083 Lisp_Object display_name; 6084{ 6085 struct w32_display_info *dpyinfo = &one_w32_display_info; 6086 6087 bzero (dpyinfo, sizeof (*dpyinfo)); 6088 6089 /* Put it on w32_display_name_list. */ 6090 w32_display_name_list = Fcons (Fcons (display_name, Qnil), 6091 w32_display_name_list); 6092 dpyinfo->name_list_element = XCAR (w32_display_name_list); 6093 6094 dpyinfo->w32_id_name 6095 = (char *) xmalloc (SCHARS (Vinvocation_name) 6096 + SCHARS (Vsystem_name) 6097 + 2); 6098 sprintf (dpyinfo->w32_id_name, "%s@%s", 6099 SDATA (Vinvocation_name), SDATA (Vsystem_name)); 6100 6101 /* Default Console mode values - overridden when running in GUI mode 6102 with values obtained from system metrics. */ 6103 dpyinfo->resx = 1; 6104 dpyinfo->resy = 1; 6105 dpyinfo->height_in = 1; 6106 dpyinfo->width_in = 1; 6107 dpyinfo->n_planes = 1; 6108 dpyinfo->n_cbits = 4; 6109 dpyinfo->n_fonts = 0; 6110 dpyinfo->smallest_font_height = 1; 6111 dpyinfo->smallest_char_width = 1; 6112 6113 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1; 6114 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1; 6115 dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID; 6116 dpyinfo->mouse_face_window = Qnil; 6117 dpyinfo->mouse_face_overlay = Qnil; 6118 dpyinfo->mouse_face_hidden = 0; 6119 6120 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW); 6121 /* TODO: dpyinfo->gray */ 6122 6123} 6124 6125/* Create an xrdb-style database of resources to supercede registry settings. 6126 The database is just a concatenation of C strings, finished by an additional 6127 \0. The string are submitted to some basic normalization, so 6128 6129 [ *]option[ *]:[ *]value... 6130 6131 becomes 6132 6133 option:value... 6134 6135 but any whitespace following value is not removed. */ 6136 6137static char * 6138w32_make_rdb (xrm_option) 6139 char *xrm_option; 6140{ 6141 char *buffer = xmalloc (strlen (xrm_option) + 2); 6142 char *current = buffer; 6143 char ch; 6144 int in_option = 1; 6145 int before_value = 0; 6146 6147 do { 6148 ch = *xrm_option++; 6149 6150 if (ch == '\n') 6151 { 6152 *current++ = '\0'; 6153 in_option = 1; 6154 before_value = 0; 6155 } 6156 else if (ch != ' ') 6157 { 6158 *current++ = ch; 6159 if (in_option && (ch == ':')) 6160 { 6161 in_option = 0; 6162 before_value = 1; 6163 } 6164 else if (before_value) 6165 { 6166 before_value = 0; 6167 } 6168 } 6169 else if (!(in_option || before_value)) 6170 { 6171 *current++ = ch; 6172 } 6173 } while (ch); 6174 6175 *current = '\0'; 6176 6177 return buffer; 6178} 6179 6180struct w32_display_info * 6181w32_term_init (display_name, xrm_option, resource_name) 6182 Lisp_Object display_name; 6183 char *xrm_option; 6184 char *resource_name; 6185{ 6186 struct w32_display_info *dpyinfo; 6187 HDC hdc; 6188 6189 BLOCK_INPUT; 6190 6191 if (!w32_initialized) 6192 { 6193 w32_initialize (); 6194 w32_initialized = 1; 6195 } 6196 6197 w32_initialize_display_info (display_name); 6198 6199 dpyinfo = &one_w32_display_info; 6200 6201 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL; 6202 6203 /* Put this display on the chain. */ 6204 dpyinfo->next = x_display_list; 6205 x_display_list = dpyinfo; 6206 6207 hdc = GetDC (GetDesktopWindow ()); 6208 6209 dpyinfo->height = GetDeviceCaps (hdc, VERTRES); 6210 dpyinfo->width = GetDeviceCaps (hdc, HORZRES); 6211 dpyinfo->root_window = GetDesktopWindow (); 6212 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES); 6213 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL); 6214 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX); 6215 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY); 6216 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE; 6217 dpyinfo->image_cache = make_image_cache (); 6218 dpyinfo->height_in = dpyinfo->height / dpyinfo->resx; 6219 dpyinfo->width_in = dpyinfo->width / dpyinfo->resy; 6220 ReleaseDC (GetDesktopWindow (), hdc); 6221 6222 /* initialise palette with white and black */ 6223 { 6224 XColor color; 6225 w32_defined_color (0, "white", &color, 1); 6226 w32_defined_color (0, "black", &color, 1); 6227 } 6228 6229 /* Create Fringe Bitmaps and store them for later use. 6230 6231 On W32, bitmaps are all unsigned short, as Windows requires 6232 bitmap data to be Word aligned. For some reason they are 6233 horizontally reflected compared to how they appear on X, so we 6234 need to bitswap and convert to unsigned shorts before creating 6235 the bitmaps. */ 6236 w32_init_fringe (); 6237 6238#ifndef F_SETOWN_BUG 6239#ifdef F_SETOWN 6240#ifdef F_SETOWN_SOCK_NEG 6241 /* stdin is a socket here */ 6242 fcntl (connection, F_SETOWN, -getpid ()); 6243#else /* ! defined (F_SETOWN_SOCK_NEG) */ 6244 fcntl (connection, F_SETOWN, getpid ()); 6245#endif /* ! defined (F_SETOWN_SOCK_NEG) */ 6246#endif /* ! defined (F_SETOWN) */ 6247#endif /* F_SETOWN_BUG */ 6248 6249#ifdef SIGIO 6250 if (interrupt_input) 6251 init_sigio (connection); 6252#endif /* ! defined (SIGIO) */ 6253 6254 UNBLOCK_INPUT; 6255 6256 return dpyinfo; 6257} 6258 6259/* Get rid of display DPYINFO, assuming all frames are already gone. */ 6260 6261void 6262x_delete_display (dpyinfo) 6263 struct w32_display_info *dpyinfo; 6264{ 6265 /* Discard this display from w32_display_name_list and w32_display_list. 6266 We can't use Fdelq because that can quit. */ 6267 if (! NILP (w32_display_name_list) 6268 && EQ (XCAR (w32_display_name_list), dpyinfo->name_list_element)) 6269 w32_display_name_list = XCDR (w32_display_name_list); 6270 else 6271 { 6272 Lisp_Object tail; 6273 6274 tail = w32_display_name_list; 6275 while (CONSP (tail) && CONSP (XCDR (tail))) 6276 { 6277 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element)) 6278 { 6279 XSETCDR (tail, XCDR (XCDR (tail))); 6280 break; 6281 } 6282 tail = XCDR (tail); 6283 } 6284 } 6285 6286 /* free palette table */ 6287 { 6288 struct w32_palette_entry * plist; 6289 6290 plist = dpyinfo->color_list; 6291 while (plist) 6292 { 6293 struct w32_palette_entry * pentry = plist; 6294 plist = plist->next; 6295 xfree (pentry); 6296 } 6297 dpyinfo->color_list = NULL; 6298 if (dpyinfo->palette) 6299 DeleteObject(dpyinfo->palette); 6300 } 6301 xfree (dpyinfo->font_table); 6302 xfree (dpyinfo->w32_id_name); 6303 6304 w32_reset_fringes (); 6305} 6306 6307/* Set up use of W32. */ 6308 6309DWORD WINAPI w32_msg_worker (void * arg); 6310 6311void 6312x_flush (struct frame * f) 6313{ /* Nothing to do */ } 6314 6315extern frame_parm_handler w32_frame_parm_handlers[]; 6316 6317static struct redisplay_interface w32_redisplay_interface = 6318{ 6319 w32_frame_parm_handlers, 6320 x_produce_glyphs, 6321 x_write_glyphs, 6322 x_insert_glyphs, 6323 x_clear_end_of_line, 6324 x_scroll_run, 6325 x_after_update_window_line, 6326 x_update_window_begin, 6327 x_update_window_end, 6328 x_cursor_to, 6329 x_flush, 6330 0, /* flush_display_optional */ 6331 x_clear_window_mouse_face, 6332 w32_get_glyph_overhangs, 6333 x_fix_overlapping_area, 6334 w32_draw_fringe_bitmap, 6335 w32_define_fringe_bitmap, 6336 w32_destroy_fringe_bitmap, 6337 w32_per_char_metric, 6338 w32_encode_char, 6339 NULL, /* w32_compute_glyph_string_overhangs */ 6340 x_draw_glyph_string, 6341 w32_define_frame_cursor, 6342 w32_clear_frame_area, 6343 w32_draw_window_cursor, 6344 w32_draw_vertical_window_border, 6345 w32_shift_glyphs_for_insert 6346}; 6347 6348void 6349w32_initialize () 6350{ 6351 rif = &w32_redisplay_interface; 6352 6353 /* MSVC does not type K&R functions with no arguments correctly, and 6354 so we must explicitly cast them. */ 6355 clear_frame_hook = (void (*)(void)) x_clear_frame; 6356 ring_bell_hook = (void (*)(void)) w32_ring_bell; 6357 update_begin_hook = x_update_begin; 6358 update_end_hook = x_update_end; 6359 6360 read_socket_hook = w32_read_socket; 6361 6362 frame_up_to_date_hook = w32_frame_up_to_date; 6363 6364 mouse_position_hook = w32_mouse_position; 6365 frame_rehighlight_hook = w32_frame_rehighlight; 6366 frame_raise_lower_hook = w32_frame_raise_lower; 6367 set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar; 6368 condemn_scroll_bars_hook = w32_condemn_scroll_bars; 6369 redeem_scroll_bar_hook = w32_redeem_scroll_bar; 6370 judge_scroll_bars_hook = w32_judge_scroll_bars; 6371 6372 scroll_region_ok = 1; /* we'll scroll partial frames */ 6373 char_ins_del_ok = 1; 6374 line_ins_del_ok = 1; /* we'll just blt 'em */ 6375 fast_clear_end_of_line = 1; /* X does this well */ 6376 memory_below_frame = 0; /* we don't remember what scrolls 6377 off the bottom */ 6378 baud_rate = 19200; 6379 6380 w32_system_caret_hwnd = NULL; 6381 w32_system_caret_height = 0; 6382 w32_system_caret_x = 0; 6383 w32_system_caret_y = 0; 6384 6385 /* Initialize w32_use_visible_system_caret based on whether a screen 6386 reader is in use. */ 6387 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0, 6388 &w32_use_visible_system_caret, 0)) 6389 w32_use_visible_system_caret = 0; 6390 6391 last_tool_bar_item = -1; 6392 any_help_event_p = 0; 6393 6394 /* Initialize input mode: interrupt_input off, no flow control, allow 6395 8 bit character input, standard quit char. */ 6396 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil); 6397 6398 /* Create the window thread - it will terminate itself or when the app terminates */ 6399 6400 init_crit (); 6401 6402 dwMainThreadId = GetCurrentThreadId (); 6403 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (), 6404 GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS); 6405 6406 /* Wait for thread to start */ 6407 6408 { 6409 MSG msg; 6410 6411 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE); 6412 6413 hWindowsThread = CreateThread (NULL, 0, 6414 w32_msg_worker, 6415 0, 0, &dwWindowsThreadId); 6416 6417 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE); 6418 } 6419 6420 /* It is desirable that mainThread should have the same notion of 6421 focus window and active window as windowsThread. Unfortunately, the 6422 following call to AttachThreadInput, which should do precisely what 6423 we need, causes major problems when Emacs is linked as a console 6424 program. Unfortunately, we have good reasons for doing that, so 6425 instead we need to send messages to windowsThread to make some API 6426 calls for us (ones that affect, or depend on, the active/focus 6427 window state. */ 6428#ifdef ATTACH_THREADS 6429 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE); 6430#endif 6431 6432 /* Load system settings. */ 6433 { 6434 UINT smoothing_type; 6435 BOOL smoothing_enabled; 6436 6437 /* If using proportional scroll bars, ensure handle is at least 5 pixels; 6438 otherwise use the fixed height. */ 6439 vertical_scroll_bar_min_handle = 5; 6440 6441 /* For either kind of scroll bar, take account of the arrows; these 6442 effectively form the border of the main scroll bar range. */ 6443 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border 6444 = GetSystemMetrics (SM_CYVSCROLL); 6445 6446 /* Constants that are not always defined by the system headers 6447 since they only exist on certain versions of Windows. */ 6448#ifndef SPI_GETFONTSMOOTHING 6449#define SPI_GETFONTSMOOTHING 0x4A 6450#endif 6451#ifndef SPI_GETFONTSMOOTHINGTYPE 6452#define SPI_GETFONTSMOOTHINGTYPE 0x0200A 6453#endif 6454#ifndef FE_FONTSMOOTHINGCLEARTYPE 6455#define FE_FONTSMOOTHINGCLEARTYPE 0x2 6456#endif 6457 6458 /* Determine if Cleartype is in use. Used to enable a hack in 6459 the char metric calculations which adds extra pixels to 6460 compensate for the "sub-pixels" that are not counted by the 6461 system APIs. */ 6462 cleartype_active = 6463 SystemParametersInfo (SPI_GETFONTSMOOTHING, 0, &smoothing_enabled, 0) 6464 && smoothing_enabled 6465 && SystemParametersInfo (SPI_GETFONTSMOOTHINGTYPE, 0, &smoothing_type, 0) 6466 && smoothing_type == FE_FONTSMOOTHINGCLEARTYPE; 6467 } 6468} 6469 6470void 6471syms_of_w32term () 6472{ 6473 staticpro (&w32_display_name_list); 6474 w32_display_name_list = Qnil; 6475 6476 staticpro (&last_mouse_scroll_bar); 6477 last_mouse_scroll_bar = Qnil; 6478 6479 staticpro (&Qvendor_specific_keysyms); 6480 Qvendor_specific_keysyms = intern ("vendor-specific-keysyms"); 6481 6482 DEFVAR_INT ("w32-num-mouse-buttons", 6483 &w32_num_mouse_buttons, 6484 doc: /* Number of physical mouse buttons. */); 6485 w32_num_mouse_buttons = 2; 6486 6487 DEFVAR_LISP ("w32-swap-mouse-buttons", 6488 &Vw32_swap_mouse_buttons, 6489 doc: /* Swap the mapping of middle and right mouse buttons. 6490When nil, middle button is mouse-2 and right button is mouse-3. */); 6491 Vw32_swap_mouse_buttons = Qnil; 6492 6493 DEFVAR_LISP ("w32-grab-focus-on-raise", 6494 &Vw32_grab_focus_on_raise, 6495 doc: /* Raised frame grabs input focus. 6496When t, `raise-frame' grabs input focus as well. This fits well 6497with the normal Windows click-to-focus policy, but might not be 6498desirable when using a point-to-focus policy. */); 6499 Vw32_grab_focus_on_raise = Qt; 6500 6501 DEFVAR_LISP ("w32-capslock-is-shiftlock", 6502 &Vw32_capslock_is_shiftlock, 6503 doc: /* Apply CapsLock state to non character input keys. 6504When nil, CapsLock only affects normal character input keys. */); 6505 Vw32_capslock_is_shiftlock = Qnil; 6506 6507 DEFVAR_LISP ("w32-recognize-altgr", 6508 &Vw32_recognize_altgr, 6509 doc: /* Recognize right-alt and left-ctrl as AltGr. 6510When nil, the right-alt and left-ctrl key combination is 6511interpreted normally. */); 6512 Vw32_recognize_altgr = Qt; 6513 6514 DEFVAR_BOOL ("w32-enable-unicode-output", 6515 &w32_enable_unicode_output, 6516 doc: /* Enable the use of Unicode for text output if non-nil. 6517Unicode output may prevent some third party applications for displaying 6518Far-East Languages on Windows 95/98 from working properly. 6519NT uses Unicode internally anyway, so this flag will probably have no 6520affect on NT machines. */); 6521 w32_enable_unicode_output = 1; 6522 6523 DEFVAR_BOOL ("w32-use-visible-system-caret", 6524 &w32_use_visible_system_caret, 6525 doc: /* Flag to make the system caret visible. 6526When this is non-nil, Emacs will indicate the position of point by 6527using the system caret instead of drawing its own cursor. Some screen 6528reader software does not track the system cursor properly when it is 6529invisible, and gets confused by Emacs drawing its own cursor, so this 6530variable is initialized to t when Emacs detects that screen reader 6531software is running as it starts up. 6532 6533When this variable is set, other variables affecting the appearance of 6534the cursor have no effect. */); 6535 6536 w32_use_visible_system_caret = 0; 6537 6538 /* We don't yet support this, but defining this here avoids whining 6539 from cus-start.el and other places, like "M-x set-variable". */ 6540 DEFVAR_BOOL ("x-use-underline-position-properties", 6541 &x_use_underline_position_properties, 6542 doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties. 6543A value of nil means ignore them. If you encounter fonts with bogus 6544UNDERLINE_POSITION font properties, for example 7x13 on XFree prior 6545to 4.1, set this to nil. 6546 6547NOTE: Not supported on MS-Windows yet. */); 6548 x_use_underline_position_properties = 0; 6549 6550 DEFVAR_BOOL ("x-underline-at-descent-line", 6551 &x_underline_at_descent_line, 6552 doc: /* *Non-nil means to draw the underline at the same place as the descent line. 6553A value of nil means to draw the underline according to the value of the 6554variable `x-use-underline-position-properties', which is usually at the 6555baseline level. The default value is nil. */); 6556 x_underline_at_descent_line = 0; 6557 6558 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars, 6559 doc: /* If not nil, Emacs uses toolkit scroll bars. */); 6560 Vx_toolkit_scroll_bars = Qt; 6561 6562 staticpro (&last_mouse_motion_frame); 6563 last_mouse_motion_frame = Qnil; 6564} 6565 6566/* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646 6567 (do not change this comment) */ 6568