1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
21
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
221
222 #include <config.h>
223 #include <stdio.h>
224 #include <limits.h>
225 #include <setjmp.h>
226
227 #include "lisp.h"
228 #include "keyboard.h"
229 #include "frame.h"
230 #include "window.h"
231 #include "termchar.h"
232 #include "dispextern.h"
233 #include "buffer.h"
234 #include "character.h"
235 #include "charset.h"
236 #include "indent.h"
237 #include "commands.h"
238 #include "keymap.h"
239 #include "macros.h"
240 #include "disptab.h"
241 #include "termhooks.h"
242 #include "intervals.h"
243 #include "coding.h"
244 #include "process.h"
245 #include "region-cache.h"
246 #include "font.h"
247 #include "fontset.h"
248 #include "blockinput.h"
249
250 #ifdef HAVE_X_WINDOWS
251 #include "xterm.h"
252 #endif
253 #ifdef WINDOWSNT
254 #include "w32term.h"
255 #endif
256 #ifdef HAVE_NS
257 #include "nsterm.h"
258 #endif
259 #ifdef USE_GTK
260 #include "gtkutil.h"
261 #endif
262
263 #include "font.h"
264
265 #ifndef FRAME_X_OUTPUT
266 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
267 #endif
268
269 #define INFINITY 10000000
270
271 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
272 || defined(HAVE_NS) || defined (USE_GTK)
273 extern void set_frame_menubar P_ ((struct frame *f, int, int));
274 extern int pending_menu_activation;
275 #endif
276
277 extern int interrupt_input;
278 extern int command_loop_level;
279
280 extern Lisp_Object do_mouse_tracking;
281
282 extern int minibuffer_auto_raise;
283 extern Lisp_Object Vminibuffer_list;
284
285 extern Lisp_Object Qface;
286 extern Lisp_Object Qmode_line, Qmode_line_inactive, Qheader_line;
287
288 extern Lisp_Object Voverriding_local_map;
289 extern Lisp_Object Voverriding_local_map_menu_flag;
290 extern Lisp_Object Qmenu_item;
291 extern Lisp_Object Qwhen;
292 extern Lisp_Object Qhelp_echo;
293 extern Lisp_Object Qbefore_string, Qafter_string;
294
295 Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
296 Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
297 Lisp_Object Qwindow_text_change_functions, Vwindow_text_change_functions;
298 Lisp_Object Qredisplay_end_trigger_functions, Vredisplay_end_trigger_functions;
299 Lisp_Object Qinhibit_point_motion_hooks;
300 Lisp_Object QCeval, QCfile, QCdata, QCpropertize;
301 Lisp_Object Qfontified;
302 Lisp_Object Qgrow_only;
303 Lisp_Object Qinhibit_eval_during_redisplay;
304 Lisp_Object Qbuffer_position, Qposition, Qobject;
305 Lisp_Object Qright_to_left, Qleft_to_right;
306
307
308 Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
309
310
311 Lisp_Object Qarrow, Qhand, Qtext;
312
313 Lisp_Object Qrisky_local_variable;
314
315
316 Lisp_Object list_of_error;
317
318
319
320 Lisp_Object Vfontification_functions;
321 Lisp_Object Qfontification_functions;
322
323 324
325 Lisp_Object Vmouse_autoselect_window;
326
327 Lisp_Object Vwrap_prefix, Qwrap_prefix;
328 Lisp_Object Vline_prefix, Qline_prefix;
329
330 331
332
333 int auto_raise_tool_bar_buttons_p;
334
335
336
337 int make_cursor_line_fully_visible_p;
338
339 340 341
342
343 Lisp_Object Vtool_bar_border;
344
345
346
347 Lisp_Object Vtool_bar_button_margin;
348
349
350
351 EMACS_INT tool_bar_button_relief;
352
353 354 355 356
357
358 Lisp_Object Vauto_resize_tool_bars;
359
360
361
362 Lisp_Object Vtool_bar_style;
363
364
365
366 EMACS_INT tool_bar_max_label_size;
367
368 369 370
371
372 int x_stretch_cursor_p;
373
374
375
376 Lisp_Object Vinhibit_redisplay, Qinhibit_redisplay;
377
378
379
380 int inhibit_eval_during_redisplay;
381
382
383
384 Lisp_Object Qdisplay;
385 extern Lisp_Object Qface, Qinvisible, Qwidth;
386
387
388
389 Lisp_Object Vdisplay_pixels_per_inch;
390 Lisp_Object Qspace, QCalign_to, QCrelative_width, QCrelative_height;
391 Lisp_Object Qleft_margin, Qright_margin, Qspace_width, Qraise;
392 Lisp_Object Qslice;
393 Lisp_Object Qcenter;
394 Lisp_Object Qmargin, Qpointer;
395 Lisp_Object Qline_height;
396 extern Lisp_Object Qheight;
397 extern Lisp_Object QCwidth, QCheight, QCascent;
398 extern Lisp_Object Qscroll_bar;
399 extern Lisp_Object Qcursor;
400
401
402
403 Lisp_Object Vshow_trailing_whitespace;
404
405
406
407 Lisp_Object Vnobreak_char_display;
408
409 #ifdef HAVE_WINDOW_SYSTEM
410 extern Lisp_Object Voverflow_newline_into_fringe;
411
412 413
414
415 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
416 (!NILP (Voverflow_newline_into_fringe) \
417 && FRAME_WINDOW_P ((IT)->f) \
418 && ((IT)->bidi_it.paragraph_dir == R2L \
419 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
420 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
421 && (IT)->current_x == (IT)->last_visible_x \
422 && (IT)->line_wrap != WORD_WRAP)
423
424 #else
425 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
426 #endif
427
428 429
430
431 #define IT_DISPLAYING_WHITESPACE(it) \
432 (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
433
434 435 436
437
438 Lisp_Object Vvoid_text_area_pointer;
439
440
441
442 Lisp_Object Qtrailing_whitespace;
443
444
445
446 Lisp_Object Qescape_glyph;
447
448
449
450 Lisp_Object Qnobreak_space;
451
452 453
454
455 Lisp_Object Qimage;
456
457
458 Lisp_Object QCmap, QCpointer;
459 Lisp_Object Qrect, Qcircle, Qpoly;
460
461
462 Lisp_Object Qtext, Qboth, Qboth_horiz;
463
464 465
466
467 int noninteractive_need_newline;
468
469
470
471 static int message_log_need_newline;
472
473 474 475
476 static Lisp_Object message_dolog_marker1;
477 static Lisp_Object message_dolog_marker2;
478 static Lisp_Object message_dolog_marker3;
479
480 481 482 483
484
485 static struct text_pos this_line_start_pos;
486
487 488
489
490 static struct text_pos this_line_end_pos;
491
492
493
494 static int this_line_vpos;
495 static int this_line_y;
496 static int this_line_pixel_height;
497
498 499
500
501 static int this_line_start_x;
502
503
504
505 static struct buffer *this_line_buffer;
506
507 508
509
510 Lisp_Object Vtruncate_partial_width_windows;
511
512
513
514 int unibyte_display_via_language_environment;
515
516 517 518
519
520 int multiple_frames;
521
522 Lisp_Object Vglobal_mode_string;
523
524
525 526 527
528
529 Lisp_Object Voverlay_arrow_variable_list;
530
531
532
533 Lisp_Object Voverlay_arrow_position;
534
535
536
537 Lisp_Object Voverlay_arrow_string;
538
539 540 541 542
543
544 Lisp_Object Qlast_arrow_position, Qlast_arrow_string;
545
546 547
548
549 Lisp_Object Qoverlay_arrow_string, Qoverlay_arrow_bitmap;
550
551
552
553 Lisp_Object Vframe_title_format;
554
555
556
557 Lisp_Object Vicon_title_format;
558
559 560 561
562
563 static Lisp_Object Vwindow_size_change_functions;
564
565 Lisp_Object Qmenu_bar_update_hook, Vmenu_bar_update_hook;
566
567
568
569 static int overlay_arrow_seen;
570
571
572
573 int highlight_nonselected_windows;
574
575 576
577
578 static EMACS_INT scroll_step;
579
580 581
582
583 static EMACS_INT scroll_conservatively;
584
585 586 587 588
589
590 EMACS_INT scroll_margin;
591
592 593 594
595
596 int buffer_shared;
597
598
599
600 static Lisp_Object default_invis_vector[3];
601
602 603 604 605 606
607
608 int mode_line_inverse_video;
609
610
611
612 Lisp_Object minibuf_prompt;
613
614 615
616
617 int minibuf_prompt_width;
618
619 620 621
622
623 Lisp_Object echo_area_window;
624
625 626 627 628
629
630 Lisp_Object Vmessage_stack;
631
632 633
634
635 int message_enable_multibyte;
636
637
638
639 int update_mode_lines;
640
641 642
643
644 int windows_or_buffers_changed;
645
646
647
648 int cursor_type_changed;
649
650 651
652
653 int line_number_displayed;
654
655
656
657 Lisp_Object Vline_number_display_limit;
658
659
660
661 static EMACS_INT line_number_display_limit_width;
662
663 664
665
666 Lisp_Object Vmessage_log_max;
667
668
669
670 static Lisp_Object Vmessages_buffer_name;
671
672 673
674
675 Lisp_Object echo_area_buffer[2];
676
677
678
679 static Lisp_Object echo_buffer[2];
680
681
682
683 static Lisp_Object Vwith_echo_area_save_vector;
684
685 686
687
688 static int display_last_displayed_message_p;
689
690 691
692
693 int message_buf_print;
694
695
696
697 Lisp_Object Qinhibit_menubar_update;
698 int inhibit_menubar_update;
699
700 701
702
703 Lisp_Object Vmenu_updating_frame;
704
705 706 707
708
709 Lisp_Object Vmax_mini_window_height;
710
711 712
713
714 int message_truncate_lines;
715 Lisp_Object Qmessage_truncate_lines;
716
717 718
719
720 static int message_cleared_p;
721
722
723 Lisp_Object Vblink_cursor_alist;
724
725 726
727
728 #define MAX_SCRATCH_GLYPHS 100
729 struct glyph_row scratch_glyph_row;
730 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
731
732
733
734 static int last_max_ascent, last_height;
735
736
737
738 int help_echo_showing_p;
739
740 741 742
743
744 int current_mode_line_height, current_header_line_height;
745
746 747 748 749 750
751
752 #define TEXT_PROP_DISTANCE_LIMIT 100
753
754 #if GLYPH_DEBUG
755
756
757
758 int inhibit_try_window_id, inhibit_try_window_reusing;
759 int inhibit_try_cursor_movement;
760
761 762
763
764 int trace_redisplay_p;
765
766 #endif
767
768 #ifdef DEBUG_TRACE_MOVE
769
770 int trace_move;
771
772 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
773 #else
774 #define TRACE_MOVE(x) (void) 0
775 #endif
776
777 778
779
780 int automatic_hscrolling_p;
781 Lisp_Object Qauto_hscroll_mode;
782
783 784
785 EMACS_INT hscroll_margin;
786
787
788 Lisp_Object Vhscroll_step;
789
790 791 792 793
794
795 Lisp_Object Vresize_mini_windows;
796
797
798
799 struct buffer *displayed_buffer;
800
801
802
803 EMACS_INT overline_margin;
804
805 806 807
808
809 EMACS_INT underline_minimum_offset;
810
811
812
813 enum prop_handled
814 {
815 HANDLED_NORMALLY,
816 HANDLED_RECOMPUTE_PROPS,
817 HANDLED_OVERLAY_STRING_CONSUMED,
818 HANDLED_RETURN
819 };
820
821 822
823
824 struct props
825 {
826
827 Lisp_Object *name;
828
829
830 enum prop_idx idx;
831
832 833
834 enum prop_handled (*handler) P_ ((struct it *it));
835 };
836
837 static enum prop_handled handle_face_prop P_ ((struct it *));
838 static enum prop_handled handle_invisible_prop P_ ((struct it *));
839 static enum prop_handled handle_display_prop P_ ((struct it *));
840 static enum prop_handled handle_composition_prop P_ ((struct it *));
841 static enum prop_handled handle_overlay_change P_ ((struct it *));
842 static enum prop_handled handle_fontified_prop P_ ((struct it *));
843
844
845
846 static struct props it_props[] =
847 {
848 {&Qfontified, FONTIFIED_PROP_IDX, handle_fontified_prop},
849 850
851 {&Qface, FACE_PROP_IDX, handle_face_prop},
852 {&Qdisplay, DISPLAY_PROP_IDX, handle_display_prop},
853 {&Qinvisible, INVISIBLE_PROP_IDX, handle_invisible_prop},
854 {&Qcomposition, COMPOSITION_PROP_IDX, handle_composition_prop},
855 {NULL, 0, NULL}
856 };
857
858 859
860
861 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
862
863
864
865 enum move_it_result
866 {
867
868 MOVE_UNDEFINED,
869
870
871 MOVE_POS_MATCH_OR_ZV,
872
873
874 MOVE_X_REACHED,
875
876 877
878 MOVE_LINE_CONTINUED,
879
880 881
882 MOVE_LINE_TRUNCATED,
883
884
885 MOVE_NEWLINE_OR_CR
886 };
887
888 889 890 891
892
893 #define CLEAR_FACE_CACHE_COUNT 500
894 static int clear_face_cache_count;
895
896
897
898 #ifdef HAVE_WINDOW_SYSTEM
899 #define CLEAR_IMAGE_CACHE_COUNT 101
900 static int clear_image_cache_count;
901 #endif
902
903
904
905 int redisplaying_p;
906
907 908 909
910
911 int inhibit_free_realized_faces;
912 Lisp_Object Qinhibit_free_realized_faces;
913
914 915
916
917 Lisp_Object help_echo_string;
918 Lisp_Object help_echo_window;
919 Lisp_Object help_echo_object;
920 int help_echo_pos;
921
922
923
924 Lisp_Object previous_help_echo_string;
925
926
927
928 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
929
930
931
932
933 int display_hourglass_p;
934
935
936 int hourglass_shown_p;
937
938 939
940 struct atimer *hourglass_atimer;
941
942
943 Lisp_Object Vhourglass_delay;
944
945 946
947 #define DEFAULT_HOURGLASS_DELAY 1
948
949
950
951
952 static void setup_for_ellipsis P_ ((struct it *, int));
953 static void mark_window_display_accurate_1 P_ ((struct window *, int));
954 static int single_display_spec_string_p P_ ((Lisp_Object, Lisp_Object));
955 static int display_prop_string_p P_ ((Lisp_Object, Lisp_Object));
956 static int cursor_row_p P_ ((struct window *, struct glyph_row *));
957 static int redisplay_mode_lines P_ ((Lisp_Object, int));
958 static char *decode_mode_spec_coding P_ ((Lisp_Object, char *, int));
959
960 static Lisp_Object get_it_property P_ ((struct it *it, Lisp_Object prop));
961
962 static void handle_line_prefix P_ ((struct it *));
963
964 static void pint2str P_ ((char *, int, int));
965 static void pint2hrstr P_ ((char *, int, int));
966 static struct text_pos run_window_scroll_functions P_ ((Lisp_Object,
967 struct text_pos));
968 static void reconsider_clip_changes P_ ((struct window *, struct buffer *));
969 static int text_outside_line_unchanged_p P_ ((struct window *, int, int));
970 static void store_mode_line_noprop_char P_ ((char));
971 static int store_mode_line_noprop P_ ((const unsigned char *, int, int));
972 static void x_consider_frame_title P_ ((Lisp_Object));
973 static void handle_stop P_ ((struct it *));
974 static void handle_stop_backwards P_ ((struct it *, EMACS_INT));
975 static int tool_bar_lines_needed P_ ((struct frame *, int *));
976 static int single_display_spec_intangible_p P_ ((Lisp_Object));
977 static void ensure_echo_area_buffers P_ ((void));
978 static Lisp_Object unwind_with_echo_area_buffer P_ ((Lisp_Object));
979 static Lisp_Object with_echo_area_buffer_unwind_data P_ ((struct window *));
980 static int with_echo_area_buffer P_ ((struct window *, int,
981 int (*) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT),
982 EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
983 static void clear_garbaged_frames P_ ((void));
984 static int current_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
985 static int truncate_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
986 static int set_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
987 static int display_echo_area P_ ((struct window *));
988 static int display_echo_area_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
989 static int resize_mini_window_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
990 static Lisp_Object unwind_redisplay P_ ((Lisp_Object));
991 static int string_char_and_length P_ ((const unsigned char *, int *));
992 static struct text_pos display_prop_end P_ ((struct it *, Lisp_Object,
993 struct text_pos));
994 static int compute_window_start_on_continuation_line P_ ((struct window *));
995 static Lisp_Object safe_eval_handler P_ ((Lisp_Object));
996 static void insert_left_trunc_glyphs P_ ((struct it *));
997 static struct glyph_row *get_overlay_arrow_glyph_row P_ ((struct window *,
998 Lisp_Object));
999 static void extend_face_to_end_of_line P_ ((struct it *));
1000 static int append_space_for_newline P_ ((struct it *, int));
1001 static int cursor_row_fully_visible_p P_ ((struct window *, int, int));
1002 static int try_scrolling P_ ((Lisp_Object, int, EMACS_INT, EMACS_INT, int, int));
1003 static int try_cursor_movement P_ ((Lisp_Object, struct text_pos, int *));
1004 static int trailing_whitespace_p P_ ((int));
1005 static int message_log_check_duplicate P_ ((int, int, int, int));
1006 static void push_it P_ ((struct it *));
1007 static void pop_it P_ ((struct it *));
1008 static void sync_frame_with_window_matrix_rows P_ ((struct window *));
1009 static void select_frame_for_redisplay P_ ((Lisp_Object));
1010 static void redisplay_internal P_ ((int));
1011 static int echo_area_display P_ ((int));
1012 static void redisplay_windows P_ ((Lisp_Object));
1013 static void redisplay_window P_ ((Lisp_Object, int));
1014 static Lisp_Object redisplay_window_error ();
1015 static Lisp_Object redisplay_window_0 P_ ((Lisp_Object));
1016 static Lisp_Object redisplay_window_1 P_ ((Lisp_Object));
1017 static int update_menu_bar P_ ((struct frame *, int, int));
1018 static int try_window_reusing_current_matrix P_ ((struct window *));
1019 static int try_window_id P_ ((struct window *));
1020 static int display_line P_ ((struct it *));
1021 static int display_mode_lines P_ ((struct window *));
1022 static int display_mode_line P_ ((struct window *, enum face_id, Lisp_Object));
1023 static int display_mode_element P_ ((struct it *, int, int, int, Lisp_Object, Lisp_Object, int));
1024 static int store_mode_line_string P_ ((char *, Lisp_Object, int, int, int, Lisp_Object));
1025 static char *decode_mode_spec P_ ((struct window *, int, int, int,
1026 Lisp_Object *));
1027 static void display_menu_bar P_ ((struct window *));
1028 static int display_count_lines P_ ((int, int, int, int, int *));
1029 static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object,
1030 EMACS_INT, EMACS_INT, struct it *, int, int, int, int));
1031 static void compute_line_metrics P_ ((struct it *));
1032 static void run_redisplay_end_trigger_hook P_ ((struct it *));
1033 static int get_overlay_strings P_ ((struct it *, int));
1034 static int get_overlay_strings_1 P_ ((struct it *, int, int));
1035 static void next_overlay_string P_ ((struct it *));
1036 static void reseat P_ ((struct it *, struct text_pos, int));
1037 static void reseat_1 P_ ((struct it *, struct text_pos, int));
1038 static void back_to_previous_visible_line_start P_ ((struct it *));
1039 void reseat_at_previous_visible_line_start P_ ((struct it *));
1040 static void reseat_at_next_visible_line_start P_ ((struct it *, int));
1041 static int next_element_from_ellipsis P_ ((struct it *));
1042 static int next_element_from_display_vector P_ ((struct it *));
1043 static int next_element_from_string P_ ((struct it *));
1044 static int next_element_from_c_string P_ ((struct it *));
1045 static int next_element_from_buffer P_ ((struct it *));
1046 static int next_element_from_composition P_ ((struct it *));
1047 static int next_element_from_image P_ ((struct it *));
1048 static int next_element_from_stretch P_ ((struct it *));
1049 static void load_overlay_strings P_ ((struct it *, int));
1050 static int init_from_display_pos P_ ((struct it *, struct window *,
1051 struct display_pos *));
1052 static void reseat_to_string P_ ((struct it *, unsigned char *,
1053 Lisp_Object, int, int, int, int));
1054 static enum move_it_result
1055 move_it_in_display_line_to (struct it *, EMACS_INT, int,
1056 enum move_operation_enum);
1057 void move_it_vertically_backward P_ ((struct it *, int));
1058 static void init_to_row_start P_ ((struct it *, struct window *,
1059 struct glyph_row *));
1060 static int init_to_row_end P_ ((struct it *, struct window *,
1061 struct glyph_row *));
1062 static void back_to_previous_line_start P_ ((struct it *));
1063 static int forward_to_next_line_start P_ ((struct it *, int *));
1064 static struct text_pos string_pos_nchars_ahead P_ ((struct text_pos,
1065 Lisp_Object, int));
1066 static struct text_pos string_pos P_ ((int, Lisp_Object));
1067 static struct text_pos c_string_pos P_ ((int, unsigned char *, int));
1068 static int number_of_chars P_ ((unsigned char *, int));
1069 static void compute_stop_pos P_ ((struct it *));
1070 static void compute_string_pos P_ ((struct text_pos *, struct text_pos,
1071 Lisp_Object));
1072 static int face_before_or_after_it_pos P_ ((struct it *, int));
1073 static EMACS_INT next_overlay_change P_ ((EMACS_INT));
1074 static int handle_single_display_spec P_ ((struct it *, Lisp_Object,
1075 Lisp_Object, Lisp_Object,
1076 struct text_pos *, int));
1077 static int underlying_face_id P_ ((struct it *));
1078 static int in_ellipses_for_invisible_text_p P_ ((struct display_pos *,
1079 struct window *));
1080
1081 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
1082 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
1083
1084 #ifdef HAVE_WINDOW_SYSTEM
1085
1086 static void update_tool_bar P_ ((struct frame *, int));
1087 static void build_desired_tool_bar_string P_ ((struct frame *f));
1088 static int redisplay_tool_bar P_ ((struct frame *));
1089 static void display_tool_bar_line P_ ((struct it *, int));
1090 static void notice_overwritten_cursor P_ ((struct window *,
1091 enum glyph_row_area,
1092 int, int, int, int));
1093 static void append_stretch_glyph P_ ((struct it *, Lisp_Object,
1094 int, int, int));
1095
1096
1097
1098 #endif
1099
1100
1101 1102 1103
1104
1105 1106 1107 1108 1109
1110
1111 INLINE int
1112 window_text_bottom_y (w)
1113 struct window *w;
1114 {
1115 int height = WINDOW_TOTAL_HEIGHT (w);
1116
1117 if (WINDOW_WANTS_MODELINE_P (w))
1118 height -= CURRENT_MODE_LINE_HEIGHT (w);
1119 return height;
1120 }
1121
1122 1123 1124
1125
1126 INLINE int
1127 window_box_width (w, area)
1128 struct window *w;
1129 int area;
1130 {
1131 int cols = XFASTINT (w->total_cols);
1132 int pixels = 0;
1133
1134 if (!w->pseudo_window_p)
1135 {
1136 cols -= WINDOW_SCROLL_BAR_COLS (w);
1137
1138 if (area == TEXT_AREA)
1139 {
1140 if (INTEGERP (w->left_margin_cols))
1141 cols -= XFASTINT (w->left_margin_cols);
1142 if (INTEGERP (w->right_margin_cols))
1143 cols -= XFASTINT (w->right_margin_cols);
1144 pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
1145 }
1146 else if (area == LEFT_MARGIN_AREA)
1147 {
1148 cols = (INTEGERP (w->left_margin_cols)
1149 ? XFASTINT (w->left_margin_cols) : 0);
1150 pixels = 0;
1151 }
1152 else if (area == RIGHT_MARGIN_AREA)
1153 {
1154 cols = (INTEGERP (w->right_margin_cols)
1155 ? XFASTINT (w->right_margin_cols) : 0);
1156 pixels = 0;
1157 }
1158 }
1159
1160 return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
1161 }
1162
1163
1164 1165
1166
1167 INLINE int
1168 window_box_height (w)
1169 struct window *w;
1170 {
1171 struct frame *f = XFRAME (w->frame);
1172 int height = WINDOW_TOTAL_HEIGHT (w);
1173
1174 xassert (height >= 0);
1175
1176 1177 1178 1179 1180
1181
1182 if (WINDOW_WANTS_MODELINE_P (w))
1183 {
1184 struct glyph_row *ml_row
1185 = (w->current_matrix && w->current_matrix->rows
1186 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
1187 : 0);
1188 if (ml_row && ml_row->mode_line_p)
1189 height -= ml_row->height;
1190 else
1191 height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
1192 }
1193
1194 if (WINDOW_WANTS_HEADER_LINE_P (w))
1195 {
1196 struct glyph_row *hl_row
1197 = (w->current_matrix && w->current_matrix->rows
1198 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
1199 : 0);
1200 if (hl_row && hl_row->mode_line_p)
1201 height -= hl_row->height;
1202 else
1203 height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
1204 }
1205
1206 1207
1208 return max (0, height);
1209 }
1210
1211 1212 1213
1214
1215 INLINE int
1216 window_box_left_offset (w, area)
1217 struct window *w;
1218 int area;
1219 {
1220 int x;
1221
1222 if (w->pseudo_window_p)
1223 return 0;
1224
1225 x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
1226
1227 if (area == TEXT_AREA)
1228 x += (WINDOW_LEFT_FRINGE_WIDTH (w)
1229 + window_box_width (w, LEFT_MARGIN_AREA));
1230 else if (area == RIGHT_MARGIN_AREA)
1231 x += (WINDOW_LEFT_FRINGE_WIDTH (w)
1232 + window_box_width (w, LEFT_MARGIN_AREA)
1233 + window_box_width (w, TEXT_AREA)
1234 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1235 ? 0
1236 : WINDOW_RIGHT_FRINGE_WIDTH (w)));
1237 else if (area == LEFT_MARGIN_AREA
1238 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1239 x += WINDOW_LEFT_FRINGE_WIDTH (w);
1240
1241 return x;
1242 }
1243
1244
1245 1246 1247
1248
1249 INLINE int
1250 window_box_right_offset (w, area)
1251 struct window *w;
1252 int area;
1253 {
1254 return window_box_left_offset (w, area) + window_box_width (w, area);
1255 }
1256
1257 1258 1259
1260
1261 INLINE int
1262 window_box_left (w, area)
1263 struct window *w;
1264 int area;
1265 {
1266 struct frame *f = XFRAME (w->frame);
1267 int x;
1268
1269 if (w->pseudo_window_p)
1270 return FRAME_INTERNAL_BORDER_WIDTH (f);
1271
1272 x = (WINDOW_LEFT_EDGE_X (w)
1273 + window_box_left_offset (w, area));
1274
1275 return x;
1276 }
1277
1278
1279 1280 1281
1282
1283 INLINE int
1284 window_box_right (w, area)
1285 struct window *w;
1286 int area;
1287 {
1288 return window_box_left (w, area) + window_box_width (w, area);
1289 }
1290
1291 1292 1293 1294 1295 1296
1297
1298 INLINE void
1299 window_box (w, area, box_x, box_y, box_width, box_height)
1300 struct window *w;
1301 int area;
1302 int *box_x, *box_y, *box_width, *box_height;
1303 {
1304 if (box_width)
1305 *box_width = window_box_width (w, area);
1306 if (box_height)
1307 *box_height = window_box_height (w);
1308 if (box_x)
1309 *box_x = window_box_left (w, area);
1310 if (box_y)
1311 {
1312 *box_y = WINDOW_TOP_EDGE_Y (w);
1313 if (WINDOW_WANTS_HEADER_LINE_P (w))
1314 *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
1315 }
1316 }
1317
1318
1319 1320 1321 1322 1323 1324 1325
1326
1327 INLINE void
1328 window_box_edges (w, area, top_left_x, top_left_y,
1329 bottom_right_x, bottom_right_y)
1330 struct window *w;
1331 int area;
1332 int *top_left_x, *top_left_y, *bottom_right_x, *bottom_right_y;
1333 {
1334 window_box (w, area, top_left_x, top_left_y, bottom_right_x,
1335 bottom_right_y);
1336 *bottom_right_x += *top_left_x;
1337 *bottom_right_y += *top_left_y;
1338 }
1339
1340
1341
1342 1343 1344
1345
1346 1347
1348
1349 int
1350 line_bottom_y (it)
1351 struct it *it;
1352 {
1353 int line_height = it->max_ascent + it->max_descent;
1354 int line_top_y = it->current_y;
1355
1356 if (line_height == 0)
1357 {
1358 if (last_height)
1359 line_height = last_height;
1360 else if (IT_CHARPOS (*it) < ZV)
1361 {
1362 move_it_by_lines (it, 1, 1);
1363 line_height = (it->max_ascent || it->max_descent
1364 ? it->max_ascent + it->max_descent
1365 : last_height);
1366 }
1367 else
1368 {
1369 struct glyph_row *row = it->glyph_row;
1370
1371
1372 it->glyph_row = NULL;
1373 it->what = IT_CHARACTER;
1374 it->c = ' ';
1375 it->len = 1;
1376 PRODUCE_GLYPHS (it);
1377 line_height = it->ascent + it->descent;
1378 it->glyph_row = row;
1379 }
1380 }
1381
1382 return line_top_y + line_height;
1383 }
1384
1385
1386 1387 1388 1389 1390
1391
1392 int
1393 pos_visible_p (w, charpos, x, y, rtop, rbot, rowh, vpos)
1394 struct window *w;
1395 int charpos, *x, *y, *rtop, *rbot, *rowh, *vpos;
1396 {
1397 struct it it;
1398 struct text_pos top;
1399 int visible_p = 0;
1400 struct buffer *old_buffer = NULL;
1401
1402 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
1403 return visible_p;
1404
1405 if (XBUFFER (w->buffer) != current_buffer)
1406 {
1407 old_buffer = current_buffer;
1408 set_buffer_internal_1 (XBUFFER (w->buffer));
1409 }
1410
1411 SET_TEXT_POS_FROM_MARKER (top, w->start);
1412
1413
1414 if (WINDOW_WANTS_MODELINE_P (w))
1415 current_mode_line_height
1416 = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
1417 current_buffer->mode_line_format);
1418
1419 if (WINDOW_WANTS_HEADER_LINE_P (w))
1420 current_header_line_height
1421 = display_mode_line (w, HEADER_LINE_FACE_ID,
1422 current_buffer->header_line_format);
1423
1424 start_display (&it, w, top);
1425 move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
1426 (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
1427
1428 if (charpos >= 0 && IT_CHARPOS (it) >= charpos)
1429 {
1430 1431 1432 1433 1434
1435 int top_x = it.current_x;
1436 int top_y = it.current_y;
1437 enum it_method it_method = it.method;
1438
1439 int bottom_y = (last_height = 0, line_bottom_y (&it));
1440 int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
1441
1442 if (top_y < window_top_y)
1443 visible_p = bottom_y > window_top_y;
1444 else if (top_y < it.last_visible_y)
1445 visible_p = 1;
1446 if (visible_p)
1447 {
1448 if (it_method == GET_FROM_DISPLAY_VECTOR)
1449 {
1450 1451
1452 if (charpos < 2 || top.charpos >= charpos)
1453 top_x = it.glyph_row->x;
1454 else
1455 {
1456 struct it it2;
1457 start_display (&it2, w, top);
1458 move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
1459 get_next_display_element (&it2);
1460 PRODUCE_GLYPHS (&it2);
1461 if (ITERATOR_AT_END_OF_LINE_P (&it2)
1462 || it2.current_x > it2.last_visible_x)
1463 top_x = it.glyph_row->x;
1464 else
1465 {
1466 top_x = it2.current_x;
1467 top_y = it2.current_y;
1468 }
1469 }
1470 }
1471
1472 *x = top_x;
1473 *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
1474 *rtop = max (0, window_top_y - top_y);
1475 *rbot = max (0, bottom_y - it.last_visible_y);
1476 *rowh = max (0, (min (bottom_y, it.last_visible_y)
1477 - max (top_y, window_top_y)));
1478 *vpos = it.vpos;
1479 }
1480 }
1481 else
1482 {
1483 struct it it2;
1484
1485 it2 = it;
1486 if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
1487 move_it_by_lines (&it, 1, 0);
1488 if (charpos < IT_CHARPOS (it)
1489 || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
1490 {
1491 visible_p = 1;
1492 move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
1493 *x = it2.current_x;
1494 *y = it2.current_y + it2.max_ascent - it2.ascent;
1495 *rtop = max (0, -it2.current_y);
1496 *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
1497 - it.last_visible_y));
1498 *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
1499 it.last_visible_y)
1500 - max (it2.current_y,
1501 WINDOW_HEADER_LINE_HEIGHT (w))));
1502 *vpos = it2.vpos;
1503 }
1504 }
1505
1506 if (old_buffer)
1507 set_buffer_internal_1 (old_buffer);
1508
1509 current_header_line_height = current_mode_line_height = -1;
1510
1511 if (visible_p && XFASTINT (w->hscroll) > 0)
1512 *x -= XFASTINT (w->hscroll) * WINDOW_FRAME_COLUMN_WIDTH (w);
1513
1514 #if 0
1515
1516 if (visible_p)
1517 fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1518 charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
1519 else
1520 fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
1521 #endif
1522
1523 return visible_p;
1524 }
1525
1526
1527 1528 1529 1530 1531
1532
1533 static INLINE int
1534 string_char_and_length (str, len)
1535 const unsigned char *str;
1536 int *len;
1537 {
1538 int c;
1539
1540 c = STRING_CHAR_AND_LENGTH (str, *len);
1541 if (!CHAR_VALID_P (c, 1))
1542 1543 1544
1545 c = '?';
1546
1547 return c;
1548 }
1549
1550
1551
1552 1553
1554
1555 static struct text_pos
1556 string_pos_nchars_ahead (pos, string, nchars)
1557 struct text_pos pos;
1558 Lisp_Object string;
1559 int nchars;
1560 {
1561 xassert (STRINGP (string) && nchars >= 0);
1562
1563 if (STRING_MULTIBYTE (string))
1564 {
1565 int rest = SBYTES (string) - BYTEPOS (pos);
1566 const unsigned char *p = SDATA (string) + BYTEPOS (pos);
1567 int len;
1568
1569 while (nchars--)
1570 {
1571 string_char_and_length (p, &len);
1572 p += len, rest -= len;
1573 xassert (rest >= 0);
1574 CHARPOS (pos) += 1;
1575 BYTEPOS (pos) += len;
1576 }
1577 }
1578 else
1579 SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
1580
1581 return pos;
1582 }
1583
1584
1585 1586
1587
1588 static INLINE struct text_pos
1589 string_pos (charpos, string)
1590 int charpos;
1591 Lisp_Object string;
1592 {
1593 struct text_pos pos;
1594 xassert (STRINGP (string));
1595 xassert (charpos >= 0);
1596 SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
1597 return pos;
1598 }
1599
1600
1601 1602 1603
1604
1605 static struct text_pos
1606 c_string_pos (charpos, s, multibyte_p)
1607 int charpos;
1608 unsigned char *s;
1609 int multibyte_p;
1610 {
1611 struct text_pos pos;
1612
1613 xassert (s != NULL);
1614 xassert (charpos >= 0);
1615
1616 if (multibyte_p)
1617 {
1618 int rest = strlen (s), len;
1619
1620 SET_TEXT_POS (pos, 0, 0);
1621 while (charpos--)
1622 {
1623 string_char_and_length (s, &len);
1624 s += len, rest -= len;
1625 xassert (rest >= 0);
1626 CHARPOS (pos) += 1;
1627 BYTEPOS (pos) += len;
1628 }
1629 }
1630 else
1631 SET_TEXT_POS (pos, charpos, charpos);
1632
1633 return pos;
1634 }
1635
1636
1637 1638
1639
1640 static int
1641 number_of_chars (s, multibyte_p)
1642 unsigned char *s;
1643 int multibyte_p;
1644 {
1645 int nchars;
1646
1647 if (multibyte_p)
1648 {
1649 int rest = strlen (s), len;
1650 unsigned char *p = (unsigned char *) s;
1651
1652 for (nchars = 0; rest > 0; ++nchars)
1653 {
1654 string_char_and_length (p, &len);
1655 rest -= len, p += len;
1656 }
1657 }
1658 else
1659 nchars = strlen (s);
1660
1661 return nchars;
1662 }
1663
1664
1665 1666 1667
1668
1669 static void
1670 compute_string_pos (newpos, pos, string)
1671 struct text_pos *newpos, pos;
1672 Lisp_Object string;
1673 {
1674 xassert (STRINGP (string));
1675 xassert (CHARPOS (*newpos) >= CHARPOS (pos));
1676
1677 if (STRING_MULTIBYTE (string))
1678 *newpos = string_pos_nchars_ahead (pos, string,
1679 CHARPOS (*newpos) - CHARPOS (pos));
1680 else
1681 BYTEPOS (*newpos) = CHARPOS (*newpos);
1682 }
1683
1684 1685 1686
1687
1688 int
1689 estimate_mode_line_height (f, face_id)
1690 struct frame *f;
1691 enum face_id face_id;
1692 {
1693 #ifdef HAVE_WINDOW_SYSTEM
1694 if (FRAME_WINDOW_P (f))
1695 {
1696 int height = FONT_HEIGHT (FRAME_FONT (f));
1697
1698 1699
1700 if (FRAME_FACE_CACHE (f))
1701 {
1702 struct face *face = FACE_FROM_ID (f, face_id);
1703 if (face)
1704 {
1705 if (face->font)
1706 height = FONT_HEIGHT (face->font);
1707 if (face->box_line_width > 0)
1708 height += 2 * face->box_line_width;
1709 }
1710 }
1711
1712 return height;
1713 }
1714 #endif
1715
1716 return 1;
1717 }
1718
1719 1720 1721 1722
1723
1724 void
1725 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
1726 FRAME_PTR f;
1727 register int pix_x, pix_y;
1728 int *x, *y;
1729 NativeRectangle *bounds;
1730 int noclip;
1731 {
1732
1733 #ifdef HAVE_WINDOW_SYSTEM
1734 if (FRAME_WINDOW_P (f))
1735 {
1736 1737
1738 if (pix_x < 0)
1739 pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
1740 if (pix_y < 0)
1741 pix_y -= FRAME_LINE_HEIGHT (f) - 1;
1742
1743 pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
1744 pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
1745
1746 if (bounds)
1747 STORE_NATIVE_RECT (*bounds,
1748 FRAME_COL_TO_PIXEL_X (f, pix_x),
1749 FRAME_LINE_TO_PIXEL_Y (f, pix_y),
1750 FRAME_COLUMN_WIDTH (f) - 1,
1751 FRAME_LINE_HEIGHT (f) - 1);
1752
1753 if (!noclip)
1754 {
1755 if (pix_x < 0)
1756 pix_x = 0;
1757 else if (pix_x > FRAME_TOTAL_COLS (f))
1758 pix_x = FRAME_TOTAL_COLS (f);
1759
1760 if (pix_y < 0)
1761 pix_y = 0;
1762 else if (pix_y > FRAME_LINES (f))
1763 pix_y = FRAME_LINES (f);
1764 }
1765 }
1766 #endif
1767
1768 *x = pix_x;
1769 *y = pix_y;
1770 }
1771
1772
1773 1774 1775 1776
1777
1778 int
1779 glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
1780 struct window *w;
1781 int hpos, vpos;
1782 int *frame_x, *frame_y;
1783 {
1784 #ifdef HAVE_WINDOW_SYSTEM
1785 if (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))))
1786 {
1787 int success_p;
1788
1789 xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
1790 xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
1791
1792 if (display_completed)
1793 {
1794 struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
1795 struct glyph *glyph = row->glyphs[TEXT_AREA];
1796 struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
1797
1798 hpos = row->x;
1799 vpos = row->y;
1800 while (glyph < end)
1801 {
1802 hpos += glyph->pixel_width;
1803 ++glyph;
1804 }
1805
1806
1807 if (hpos < 0)
1808 hpos = 0;
1809
1810 success_p = 1;
1811 }
1812 else
1813 {
1814 hpos = vpos = 0;
1815 success_p = 0;
1816 }
1817
1818 *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, hpos);
1819 *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, vpos);
1820 return success_p;
1821 }
1822 #endif
1823
1824 *frame_x = hpos;
1825 *frame_y = vpos;
1826 return 1;
1827 }
1828
1829
1830 #ifdef HAVE_WINDOW_SYSTEM
1831
1832 1833 1834 1835 1836 1837 1838
1839
1840 static
1841 struct glyph *
1842 x_y_to_hpos_vpos (w, x, y, hpos, vpos, dx, dy, area)
1843 struct window *w;
1844 int x, y;
1845 int *hpos, *vpos, *dx, *dy, *area;
1846 {
1847 struct glyph *glyph, *end;
1848 struct glyph_row *row = NULL;
1849 int x0, i;
1850
1851
1852 for (i = 0; i < w->current_matrix->nrows; ++i)
1853 {
1854 row = MATRIX_ROW (w->current_matrix, i);
1855 if (!row->enabled_p)
1856 return NULL;
1857 if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
1858 break;
1859 }
1860
1861 *vpos = i;
1862 *hpos = 0;
1863
1864
1865 if (i == w->current_matrix->nrows)
1866 return NULL;
1867
1868
1869 if (w->pseudo_window_p)
1870 {
1871 *area = TEXT_AREA;
1872 x0 = 0;
1873 }
1874 else
1875 {
1876 if (x < window_box_left_offset (w, TEXT_AREA))
1877 {
1878 *area = LEFT_MARGIN_AREA;
1879 x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
1880 }
1881 else if (x < window_box_right_offset (w, TEXT_AREA))
1882 {
1883 *area = TEXT_AREA;
1884 x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
1885 }
1886 else
1887 {
1888 *area = RIGHT_MARGIN_AREA;
1889 x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
1890 }
1891 }
1892
1893
1894 glyph = row->glyphs[*area];
1895 end = glyph + row->used[*area];
1896 x -= x0;
1897 while (glyph < end && x >= glyph->pixel_width)
1898 {
1899 x -= glyph->pixel_width;
1900 ++glyph;
1901 }
1902
1903 if (glyph == end)
1904 return NULL;
1905
1906 if (dx)
1907 {
1908 *dx = x;
1909 *dy = y - (row->y + row->ascent - glyph->ascent);
1910 }
1911
1912 *hpos = glyph - row->glyphs[*area];
1913 return glyph;
1914 }
1915
1916
1917 1918 1919
1920
1921 void
1922 frame_to_window_pixel_xy (w, x, y)
1923 struct window *w;
1924 int *x, *y;
1925 {
1926 if (w->pseudo_window_p)
1927 {
1928 1929
1930 struct frame *f = XFRAME (w->frame);
1931 *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
1932 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1933 }
1934 else
1935 {
1936 *x -= WINDOW_LEFT_EDGE_X (w);
1937 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1938 }
1939 }
1940
1941 1942 1943
1944
1945 int
1946 get_glyph_string_clip_rects (s, rects, n)
1947 struct glyph_string *s;
1948 NativeRectangle *rects;
1949 int n;
1950 {
1951 XRectangle r;
1952
1953 if (n <= 0)
1954 return 0;
1955
1956 if (s->row->full_width_p)
1957 {
1958
1959 r.x = WINDOW_LEFT_EDGE_X (s->w);
1960 r.width = WINDOW_TOTAL_WIDTH (s->w);
1961
1962 1963
1964 if (s->w->pseudo_window_p)
1965 r.height = s->row->visible_height;
1966 else
1967 r.height = s->height;
1968 }
1969 else
1970 {
1971
1972 r.x = window_box_left (s->w, s->area);
1973 r.width = window_box_width (s->w, s->area);
1974 r.height = s->row->visible_height;
1975 }
1976
1977 if (s->clip_head)
1978 if (r.x < s->clip_head->x)
1979 {
1980 if (r.width >= s->clip_head->x - r.x)
1981 r.width -= s->clip_head->x - r.x;
1982 else
1983 r.width = 0;
1984 r.x = s->clip_head->x;
1985 }
1986 if (s->clip_tail)
1987 if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
1988 {
1989 if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
1990 r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
1991 else
1992 r.width = 0;
1993 }
1994
1995 1996 1997
1998 if (s->for_overlaps)
1999 {
2000 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
2001 r.height = window_text_bottom_y (s->w) - r.y;
2002
2003 2004 2005 2006 2007
2008 if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
2009 {
2010 XRectangle rc, r_save = r;
2011
2012 rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
2013 rc.y = s->w->phys_cursor.y;
2014 rc.width = s->w->phys_cursor_width;
2015 rc.height = s->w->phys_cursor_height;
2016
2017 x_intersect_rectangles (&r_save, &rc, &r);
2018 }
2019 }
2020 else
2021 {
2022 2023 2024
2025 if (!s->row->full_width_p
2026 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
2027 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
2028 else
2029 r.y = max (0, s->row->y);
2030 }
2031
2032 r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
2033
2034 2035
2036 if (s->hl == DRAW_CURSOR)
2037 {
2038 struct glyph *glyph = s->first_glyph;
2039 int height, max_y;
2040
2041 if (s->x > r.x)
2042 {
2043 r.width -= s->x - r.x;
2044 r.x = s->x;
2045 }
2046 r.width = min (r.width, glyph->pixel_width);
2047
2048
2049 height = min (glyph->ascent + glyph->descent,
2050 min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
2051 max_y = window_text_bottom_y (s->w) - height;
2052 max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
2053 if (s->ybase - glyph->ascent > max_y)
2054 {
2055 r.y = max_y;
2056 r.height = height;
2057 }
2058 else
2059 {
2060
2061 height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
2062 if (height < r.height)
2063 {
2064 max_y = r.y + r.height;
2065 r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
2066 r.height = min (max_y - r.y, height);
2067 }
2068 }
2069 }
2070
2071 if (s->row->clip)
2072 {
2073 XRectangle r_save = r;
2074
2075 if (! x_intersect_rectangles (&r_save, s->row->clip, &r))
2076 r.width = 0;
2077 }
2078
2079 if ((s->for_overlaps & OVERLAPS_BOTH) == 0
2080 || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
2081 {
2082 #ifdef CONVERT_FROM_XRECT
2083 CONVERT_FROM_XRECT (r, *rects);
2084 #else
2085 *rects = r;
2086 #endif
2087 return 1;
2088 }
2089 else
2090 {
2091 2092 2093 2094
2095 #ifdef CONVERT_FROM_XRECT
2096 XRectangle rs[2];
2097 #else
2098 XRectangle *rs = rects;
2099 #endif
2100 int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
2101
2102 if (s->for_overlaps & OVERLAPS_PRED)
2103 {
2104 rs[i] = r;
2105 if (r.y + r.height > row_y)
2106 {
2107 if (r.y < row_y)
2108 rs[i].height = row_y - r.y;
2109 else
2110 rs[i].height = 0;
2111 }
2112 i++;
2113 }
2114 if (s->for_overlaps & OVERLAPS_SUCC)
2115 {
2116 rs[i] = r;
2117 if (r.y < row_y + s->row->visible_height)
2118 {
2119 if (r.y + r.height > row_y + s->row->visible_height)
2120 {
2121 rs[i].y = row_y + s->row->visible_height;
2122 rs[i].height = r.y + r.height - rs[i].y;
2123 }
2124 else
2125 rs[i].height = 0;
2126 }
2127 i++;
2128 }
2129
2130 n = i;
2131 #ifdef CONVERT_FROM_XRECT
2132 for (i = 0; i < n; i++)
2133 CONVERT_FROM_XRECT (rs[i], rects[i]);
2134 #endif
2135 return n;
2136 }
2137 }
2138
2139 2140
2141
2142 void
2143 get_glyph_string_clip_rect (s, nr)
2144 struct glyph_string *s;
2145 NativeRectangle *nr;
2146 {
2147 get_glyph_string_clip_rects (s, nr, 1);
2148 }
2149
2150
2151 2152 2153 2154
2155
2156 void
2157 get_phys_cursor_geometry (w, row, glyph, xp, yp, heightp)
2158 struct window *w;
2159 struct glyph_row *row;
2160 struct glyph *glyph;
2161 int *xp, *yp, *heightp;
2162 {
2163 struct frame *f = XFRAME (WINDOW_FRAME (w));
2164 int x, y, wd, h, h0, y0;
2165
2166 2167 2168 2169
2170 wd = glyph->pixel_width - 1;
2171 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
2172 wd++;
2173 #endif
2174
2175 x = w->phys_cursor.x;
2176 if (x < 0)
2177 {
2178 wd += x;
2179 x = 0;
2180 }
2181
2182 if (glyph->type == STRETCH_GLYPH
2183 && !x_stretch_cursor_p)
2184 wd = min (FRAME_COLUMN_WIDTH (f), wd);
2185 w->phys_cursor_width = wd;
2186
2187 y = w->phys_cursor.y + row->ascent - glyph->ascent;
2188
2189
2190 h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
2191
2192 h = max (h0, glyph->ascent + glyph->descent);
2193 h0 = min (h0, glyph->ascent + glyph->descent);
2194
2195 y0 = WINDOW_HEADER_LINE_HEIGHT (w);
2196 if (y < y0)
2197 {
2198 h = max (h - (y0 - y) + 1, h0);
2199 y = y0 - 1;
2200 }
2201 else
2202 {
2203 y0 = window_text_bottom_y (w) - h0;
2204 if (y > y0)
2205 {
2206 h += y - y0;
2207 y = y0;
2208 }
2209 }
2210
2211 *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
2212 *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
2213 *heightp = h;
2214 }
2215
2216 2217 2218
2219
2220 void
2221 remember_mouse_glyph (f, gx, gy, rect)
2222 struct frame *f;
2223 int gx, gy;
2224 NativeRectangle *rect;
2225 {
2226 Lisp_Object window;
2227 struct window *w;
2228 struct glyph_row *r, *gr, *end_row;
2229 enum window_part part;
2230 enum glyph_row_area area;
2231 int x, y, width, height;
2232
2233 2234
2235
2236 if (!f->glyphs_initialized_p
2237 || (window = window_from_coordinates (f, gx, gy, &part, &x, &y, 0),
2238 NILP (window)))
2239 {
2240 width = FRAME_SMALLEST_CHAR_WIDTH (f);
2241 height = FRAME_SMALLEST_FONT_HEIGHT (f);
2242 goto virtual_glyph;
2243 }
2244
2245 w = XWINDOW (window);
2246 width = WINDOW_FRAME_COLUMN_WIDTH (w);
2247 height = WINDOW_FRAME_LINE_HEIGHT (w);
2248
2249 r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
2250 end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
2251
2252 if (w->pseudo_window_p)
2253 {
2254 area = TEXT_AREA;
2255 part = ON_MODE_LINE;
2256 goto text_glyph;
2257 }
2258
2259 switch (part)
2260 {
2261 case ON_LEFT_MARGIN:
2262 area = LEFT_MARGIN_AREA;
2263 goto text_glyph;
2264
2265 case ON_RIGHT_MARGIN:
2266 area = RIGHT_MARGIN_AREA;
2267 goto text_glyph;
2268
2269 case ON_HEADER_LINE:
2270 case ON_MODE_LINE:
2271 gr = (part == ON_HEADER_LINE
2272 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
2273 : MATRIX_MODE_LINE_ROW (w->current_matrix));
2274 gy = gr->y;
2275 area = TEXT_AREA;
2276 goto text_glyph_row_found;
2277
2278 case ON_TEXT:
2279 area = TEXT_AREA;
2280
2281 text_glyph:
2282 gr = 0; gy = 0;
2283 for (; r <= end_row && r->enabled_p; ++r)
2284 if (r->y + r->height > y)
2285 {
2286 gr = r; gy = r->y;
2287 break;
2288 }
2289
2290 text_glyph_row_found:
2291 if (gr && gy <= y)
2292 {
2293 struct glyph *g = gr->glyphs[area];
2294 struct glyph *end = g + gr->used[area];
2295
2296 height = gr->height;
2297 for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
2298 if (gx + g->pixel_width > x)
2299 break;
2300
2301 if (g < end)
2302 {
2303 if (g->type == IMAGE_GLYPH)
2304 {
2305 2306
2307 STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
2308 return;
2309 }
2310 width = g->pixel_width;
2311 }
2312 else
2313 {
2314
2315 x -= gx;
2316 gx += (x / width) * width;
2317 }
2318
2319 if (part != ON_MODE_LINE && part != ON_HEADER_LINE)
2320 gx += window_box_left_offset (w, area);
2321 }
2322 else
2323 {
2324
2325 gx = (x / width) * width;
2326 y -= gy;
2327 gy += (y / height) * height;
2328 }
2329 break;
2330
2331 case ON_LEFT_FRINGE:
2332 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2333 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
2334 : window_box_right_offset (w, LEFT_MARGIN_AREA));
2335 width = WINDOW_LEFT_FRINGE_WIDTH (w);
2336 goto row_glyph;
2337
2338 case ON_RIGHT_FRINGE:
2339 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2340 ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
2341 : window_box_right_offset (w, TEXT_AREA));
2342 width = WINDOW_RIGHT_FRINGE_WIDTH (w);
2343 goto row_glyph;
2344
2345 case ON_SCROLL_BAR:
2346 gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
2347 ? 0
2348 : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
2349 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2350 ? WINDOW_RIGHT_FRINGE_WIDTH (w)
2351 : 0)));
2352 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
2353
2354 row_glyph:
2355 gr = 0, gy = 0;
2356 for (; r <= end_row && r->enabled_p; ++r)
2357 if (r->y + r->height > y)
2358 {
2359 gr = r; gy = r->y;
2360 break;
2361 }
2362
2363 if (gr && gy <= y)
2364 height = gr->height;
2365 else
2366 {
2367
2368 y -= gy;
2369 gy += (y / height) * height;
2370 }
2371 break;
2372
2373 default:
2374 ;
2375 virtual_glyph:
2376 2377 2378
2379
2380 2381
2382 if (gx < 0)
2383 gx -= width - 1;
2384 if (gy < 0)
2385 gy -= height - 1;
2386
2387 gx = (gx / width) * width;
2388 gy = (gy / height) * height;
2389
2390 goto store_rect;
2391 }
2392
2393 gx += WINDOW_LEFT_EDGE_X (w);
2394 gy += WINDOW_TOP_EDGE_Y (w);
2395
2396 store_rect:
2397 STORE_NATIVE_RECT (*rect, gx, gy, width, height);
2398
2399
2400 #if 0
2401 #if HAVE_X_WINDOWS
2402 XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2403 f->output_data.x->normal_gc,
2404 gx, gy, width, height);
2405 #endif
2406 #endif
2407 }
2408
2409
2410 #endif
2411
2412
2413 2414 2415
2416
2417
2418
2419 static Lisp_Object
2420 safe_eval_handler (arg)
2421 Lisp_Object arg;
2422 {
2423 add_to_log ("Error during redisplay: %s", arg, Qnil);
2424 return Qnil;
2425 }
2426
2427
2428 2429
2430
2431 2432 2433
2434
2435 Lisp_Object
2436 safe_call (nargs, args)
2437 int nargs;
2438 Lisp_Object *args;
2439 {
2440 Lisp_Object val;
2441
2442 if (inhibit_eval_during_redisplay)
2443 val = Qnil;
2444 else
2445 {
2446 int count = SPECPDL_INDEX ();
2447 struct gcpro gcpro1;
2448
2449 GCPRO1 (args[0]);
2450 gcpro1.nvars = nargs;
2451 specbind (Qinhibit_redisplay, Qt);
2452 2453
2454 val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
2455 safe_eval_handler);
2456 UNGCPRO;
2457 val = unbind_to (count, val);
2458 }
2459
2460 return val;
2461 }
2462
2463
2464 2465
2466
2467 Lisp_Object
2468 safe_call1 (fn, arg)
2469 Lisp_Object fn, arg;
2470 {
2471 Lisp_Object args[2];
2472 args[0] = fn;
2473 args[1] = arg;
2474 return safe_call (2, args);
2475 }
2476
2477 static Lisp_Object Qeval;
2478
2479 Lisp_Object
2480 safe_eval (Lisp_Object sexpr)
2481 {
2482 return safe_call1 (Qeval, sexpr);
2483 }
2484
2485 2486
2487
2488 Lisp_Object
2489 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
2490 {
2491 Lisp_Object args[3];
2492 args[0] = fn;
2493 args[1] = arg1;
2494 args[2] = arg2;
2495 return safe_call (3, args);
2496 }
2497
2498
2499
2500 2501 2502
2503
2504 #if 0
2505
2506 2507
2508
2509 static void
2510 check_it (it)
2511 struct it *it;
2512 {
2513 if (it->method == GET_FROM_STRING)
2514 {
2515 xassert (STRINGP (it->string));
2516 xassert (IT_STRING_CHARPOS (*it) >= 0);
2517 }
2518 else
2519 {
2520 xassert (IT_STRING_CHARPOS (*it) < 0);
2521 if (it->method == GET_FROM_BUFFER)
2522 {
2523
2524 xassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
2525 }
2526 }
2527
2528 if (it->dpvec)
2529 xassert (it->current.dpvec_index >= 0);
2530 else
2531 xassert (it->current.dpvec_index < 0);
2532 }
2533
2534 #define CHECK_IT(IT) check_it ((IT))
2535
2536 #else
2537
2538 #define CHECK_IT(IT) (void) 0
2539
2540 #endif
2541
2542
2543 #if GLYPH_DEBUG
2544
2545 2546
2547
2548 static void
2549 check_window_end (w)
2550 struct window *w;
2551 {
2552 if (!MINI_WINDOW_P (w)
2553 && !NILP (w->window_end_valid))
2554 {
2555 struct glyph_row *row;
2556 xassert ((row = MATRIX_ROW (w->current_matrix,
2557 XFASTINT (w->window_end_vpos)),
2558 !row->enabled_p
2559 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
2560 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
2561 }
2562 }
2563
2564 #define CHECK_WINDOW_END(W) check_window_end ((W))
2565
2566 #else
2567
2568 #define CHECK_WINDOW_END(W) (void) 0
2569
2570 #endif
2571
2572
2573
2574 2575 2576
2577
2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
2596
2597 void
2598 init_iterator (it, w, charpos, bytepos, row, base_face_id)
2599 struct it *it;
2600 struct window *w;
2601 EMACS_INT charpos, bytepos;
2602 struct glyph_row *row;
2603 enum face_id base_face_id;
2604 {
2605 int highlight_region_p;
2606 enum face_id remapped_base_face_id = base_face_id;
2607
2608
2609 xassert (w != NULL && it != NULL);
2610 xassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
2611 && charpos <= ZV));
2612
2613 2614 2615 2616
2617 if (face_change_count && !inhibit_free_realized_faces)
2618 {
2619 face_change_count = 0;
2620 free_all_realized_faces (Qnil);
2621 }
2622
2623
2624 if (! NILP (Vface_remapping_alist))
2625 remapped_base_face_id = lookup_basic_face (XFRAME (w->frame), base_face_id);
2626
2627 2628
2629 if (row == NULL)
2630 {
2631 if (base_face_id == MODE_LINE_FACE_ID
2632 || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
2633 row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
2634 else if (base_face_id == HEADER_LINE_FACE_ID)
2635 row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
2636 }
2637
2638
2639 bzero (it, sizeof *it);
2640 it->current.overlay_string_index = -1;
2641 it->current.dpvec_index = -1;
2642 it->base_face_id = remapped_base_face_id;
2643 it->string = Qnil;
2644 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
2645
2646
2647 XSETWINDOW (it->window, w);
2648 it->w = w;
2649 it->f = XFRAME (w->frame);
2650
2651 it->cmp_it.id = -1;
2652
2653
2654 if (base_face_id == DEFAULT_FACE_ID
2655 && FRAME_WINDOW_P (it->f))
2656 {
2657 if (NATNUMP (current_buffer->extra_line_spacing))
2658 it->extra_line_spacing = XFASTINT (current_buffer->extra_line_spacing);
2659 else if (FLOATP (current_buffer->extra_line_spacing))
2660 it->extra_line_spacing = (XFLOAT_DATA (current_buffer->extra_line_spacing)
2661 * FRAME_LINE_HEIGHT (it->f));
2662 else if (it->f->extra_line_spacing > 0)
2663 it->extra_line_spacing = it->f->extra_line_spacing;
2664 it->max_extra_line_spacing = 0;
2665 }
2666
2667 2668 2669 2670
2671 if (FRAME_FACE_CACHE (it->f) == NULL)
2672 init_frame_faces (it->f);
2673 if (FRAME_FACE_CACHE (it->f)->used == 0)
2674 recompute_basic_faces (it->f);
2675
2676
2677 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
2678 it->space_width = Qnil;
2679 it->font_height = Qnil;
2680 it->override_ascent = -1;
2681
2682
2683 it->ctl_arrow_p = !NILP (current_buffer->ctl_arrow);
2684
2685 2686 2687
2688 it->selective = (INTEGERP (current_buffer->selective_display)
2689 ? XFASTINT (current_buffer->selective_display)
2690 : (!NILP (current_buffer->selective_display)
2691 ? -1 : 0));
2692 it->selective_display_ellipsis_p
2693 = !NILP (current_buffer->selective_display_ellipses);
2694
2695
2696 it->dp = window_display_table (w);
2697
2698
2699 it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
2700
2701 2702 2703 2704
2705 it->bidi_p
2706 = !NILP (current_buffer->bidi_display_reordering) && it->multibyte_p;
2707
2708
2709 highlight_region_p
2710 = (!NILP (Vtransient_mark_mode)
2711 && !NILP (current_buffer->mark_active)
2712 && XMARKER (current_buffer->mark)->buffer != 0);
2713
2714 2715 2716
2717 if (highlight_region_p
2718
2719 && (
2720 highlight_nonselected_windows
2721
2722 || w == XWINDOW (selected_window)
2723 2724
2725 || (MINI_WINDOW_P (XWINDOW (selected_window))
2726 && WINDOWP (minibuf_selected_window)
2727 && w == XWINDOW (minibuf_selected_window))))
2728 {
2729 int charpos = marker_position (current_buffer->mark);
2730 it->region_beg_charpos = min (PT, charpos);
2731 it->region_end_charpos = max (PT, charpos);
2732 }
2733 else
2734 it->region_beg_charpos = it->region_end_charpos = -1;
2735
2736 2737
2738 if (MARKERP (w->redisplay_end_trigger)
2739 && XMARKER (w->redisplay_end_trigger)->buffer != 0)
2740 it->redisplay_end_trigger_charpos
2741 = marker_position (w->redisplay_end_trigger);
2742 else if (INTEGERP (w->redisplay_end_trigger))
2743 it->redisplay_end_trigger_charpos = XINT (w->redisplay_end_trigger);
2744
2745
2746 it->tab_width = XINT (current_buffer->tab_width);
2747 if (it->tab_width <= 0 || it->tab_width > 1000)
2748 it->tab_width = 8;
2749
2750
2751 if (base_face_id != DEFAULT_FACE_ID
2752 || XINT (it->w->hscroll)
2753 || (! WINDOW_FULL_WIDTH_P (it->w)
2754 && ((!NILP (Vtruncate_partial_width_windows)
2755 && !INTEGERP (Vtruncate_partial_width_windows))
2756 || (INTEGERP (Vtruncate_partial_width_windows)
2757 && (WINDOW_TOTAL_COLS (it->w)
2758 < XINT (Vtruncate_partial_width_windows))))))
2759 it->line_wrap = TRUNCATE;
2760 else if (NILP (current_buffer->truncate_lines))
2761 it->line_wrap = NILP (current_buffer->word_wrap)
2762 ? WINDOW_WRAP : WORD_WRAP;
2763 else
2764 it->line_wrap = TRUNCATE;
2765
2766 2767 2768
2769 if (!FRAME_WINDOW_P (it->f))
2770 {
2771 if (it->line_wrap == TRUNCATE)
2772 {
2773
2774 xassert (it->glyph_row == NULL);
2775 produce_special_glyphs (it, IT_TRUNCATION);
2776 it->truncation_pixel_width = it->pixel_width;
2777 }
2778 else
2779 {
2780
2781 xassert (it->glyph_row == NULL);
2782 produce_special_glyphs (it, IT_CONTINUATION);
2783 it->continuation_pixel_width = it->pixel_width;
2784 }
2785
2786 2787
2788 it->pixel_width = it->ascent = it->descent = 0;
2789 it->phys_ascent = it->phys_descent = 0;
2790 }
2791
2792 2793 2794
2795 it->glyph_row = row;
2796 it->area = TEXT_AREA;
2797
2798
2799 if (it->glyph_row)
2800 it->glyph_row->reversed_p = 0;
2801
2802 2803 2804 2805
2806 if (base_face_id != DEFAULT_FACE_ID)
2807 {
2808
2809 it->first_visible_x = 0;
2810 it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
2811 }
2812 else
2813 {
2814 it->first_visible_x
2815 = XFASTINT (it->w->hscroll) * FRAME_COLUMN_WIDTH (it->f);
2816 it->last_visible_x = (it->first_visible_x
2817 + window_box_width (w, TEXT_AREA));
2818
2819 2820 2821 2822
2823 if (!FRAME_WINDOW_P (it->f))
2824 {
2825 if (it->line_wrap == TRUNCATE)
2826 it->last_visible_x -= it->truncation_pixel_width;
2827 else
2828 it->last_visible_x -= it->continuation_pixel_width;
2829 }
2830
2831 it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
2832 it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
2833 }
2834
2835
2836 if (!FRAME_WINDOW_P (it->f)
2837 && !WINDOW_RIGHTMOST_P (it->w))
2838 it->last_visible_x -= 1;
2839
2840 it->last_visible_y = window_text_bottom_y (w);
2841
2842 2843
2844 if (base_face_id != DEFAULT_FACE_ID)
2845 {
2846 struct face *face;
2847
2848 it->face_id = remapped_base_face_id;
2849
2850 2851
2852 face = FACE_FROM_ID (it->f, remapped_base_face_id);
2853 if (face->box != FACE_NO_BOX)
2854 it->start_of_box_run_p = 1;
2855 }
2856
2857 2858
2859 if (it->bidi_p)
2860 {
2861 2862
2863 if (EQ (current_buffer->bidi_paragraph_direction, Qleft_to_right))
2864 it->paragraph_embedding = L2R;
2865 else if (EQ (current_buffer->bidi_paragraph_direction, Qright_to_left))
2866 it->paragraph_embedding = R2L;
2867 else
2868 it->paragraph_embedding = NEUTRAL_DIR;
2869 bidi_init_it (charpos, bytepos, &it->bidi_it);
2870 }
2871
2872 2873
2874 if (charpos >= BUF_BEG (current_buffer))
2875 {
2876 it->end_charpos = ZV;
2877 it->face_id = -1;
2878 IT_CHARPOS (*it) = charpos;
2879
2880
2881 if (bytepos < charpos)
2882 IT_BYTEPOS (*it) = CHAR_TO_BYTE (charpos);
2883 else
2884 IT_BYTEPOS (*it) = bytepos;
2885
2886 it->start = it->current;
2887
2888
2889 reseat (it, it->current.pos, 1);
2890 }
2891
2892 CHECK_IT (it);
2893 }
2894
2895
2896
2897
2898 void
2899 start_display (it, w, pos)
2900 struct it *it;
2901 struct window *w;
2902 struct text_pos pos;
2903 {
2904 struct glyph_row *row;
2905 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
2906
2907 row = w->desired_matrix->rows + first_vpos;
2908 init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
2909 it->first_vpos = first_vpos;
2910
2911 2912
2913 if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
2914 {
2915 int start_at_line_beg_p;
2916 int first_y = it->current_y;
2917
2918 2919
2920 start_at_line_beg_p = (CHARPOS (pos) == BEGV
2921 || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
2922 if (!start_at_line_beg_p)
2923 {
2924 int new_x;
2925
2926 reseat_at_previous_visible_line_start (it);
2927 move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
2928
2929 new_x = it->current_x + it->pixel_width;
2930
2931 2932 2933 2934 2935 2936
2937 if (it->current_x > 0
2938 && it->line_wrap != TRUNCATE
2939 && (
2940 new_x > it->last_visible_x
2941 2942
2943 || (new_x == it->last_visible_x
2944 && FRAME_WINDOW_P (it->f))))
2945 {
2946 if (it->current.dpvec_index >= 0
2947 || it->current.overlay_string_index >= 0)
2948 {
2949 set_iterator_to_next (it, 1);
2950 move_it_in_display_line_to (it, -1, -1, 0);
2951 }
2952
2953 it->continuation_lines_width += it->current_x;
2954 }
2955
2956 2957 2958
2959 it->max_ascent = it->max_descent = 0;
2960 it->max_phys_ascent = it->max_phys_descent = 0;
2961
2962 it->current_y = first_y;
2963 it->vpos = 0;
2964 it->current_x = it->hpos = 0;
2965 }
2966 }
2967 }
2968
2969
2970 2971
2972
2973 static int
2974 in_ellipses_for_invisible_text_p (pos, w)
2975 struct display_pos *pos;
2976 struct window *w;
2977 {
2978 Lisp_Object prop, window;
2979 int ellipses_p = 0;
2980 int charpos = CHARPOS (pos->pos);
2981
2982 2983 2984 2985
2986 if (pos->dpvec_index >= 0
2987 && pos->overlay_string_index < 0
2988 && CHARPOS (pos->string_pos) < 0
2989 && charpos > BEGV
2990 && (XSETWINDOW (window, w),
2991 prop = Fget_char_property (make_number (charpos),
2992 Qinvisible, window),
2993 !TEXT_PROP_MEANS_INVISIBLE (prop)))
2994 {
2995 prop = Fget_char_property (make_number (charpos - 1), Qinvisible,
2996 window);
2997 ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
2998 }
2999
3000 return ellipses_p;
3001 }
3002
3003
3004 3005 3006 3007
3008
3009 static int
3010 init_from_display_pos (it, w, pos)
3011 struct it *it;
3012 struct window *w;
3013 struct display_pos *pos;
3014 {
3015 EMACS_INT charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
3016 int i, overlay_strings_with_newlines = 0;
3017
3018 3019 3020 3021
3022 if (in_ellipses_for_invisible_text_p (pos, w))
3023 {
3024 --charpos;
3025 bytepos = 0;
3026 }
3027
3028 3029 3030 3031 3032 3033 3034 3035 3036
3037 init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
3038
3039 3040 3041
3042 for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
3043 {
3044 const char *s = SDATA (it->overlay_strings[i]);
3045 const char *e = s + SBYTES (it->overlay_strings[i]);
3046
3047 while (s < e && *s != '\n')
3048 ++s;
3049
3050 if (s < e)
3051 {
3052 overlay_strings_with_newlines = 1;
3053 break;
3054 }
3055 }
3056
3057 3058
3059 if (pos->overlay_string_index >= 0)
3060 {
3061 int relative_index;
3062
3063 3064 3065 3066
3067 if (it->method == GET_FROM_IMAGE)
3068 pop_it (it);
3069
3070 3071 3072
3073 if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
3074 {
3075 int n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
3076 it->current.overlay_string_index = 0;
3077 while (n--)
3078 {
3079 load_overlay_strings (it, 0);
3080 it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
3081 }
3082 }
3083
3084 it->current.overlay_string_index = pos->overlay_string_index;
3085 relative_index = (it->current.overlay_string_index
3086 % OVERLAY_STRING_CHUNK_SIZE);
3087 it->string = it->overlay_strings[relative_index];
3088 xassert (STRINGP (it->string));
3089 it->current.string_pos = pos->string_pos;
3090 it->method = GET_FROM_STRING;
3091 }
3092
3093 if (CHARPOS (pos->string_pos) >= 0)
3094 {
3095 3096 3097
3098 it->current.string_pos = pos->string_pos;
3099 xassert (STRINGP (it->string));
3100 }
3101
3102 3103
3104 if (pos->dpvec_index >= 0)
3105 {
3106 if (it->dpvec == NULL)
3107 get_next_display_element (it);
3108 xassert (it->dpvec && it->current.dpvec_index == 0);
3109 it->current.dpvec_index = pos->dpvec_index;
3110 }
3111
3112 CHECK_IT (it);
3113 return !overlay_strings_with_newlines;
3114 }
3115
3116
3117 3118
3119
3120 static void
3121 init_to_row_start (it, w, row)
3122 struct it *it;
3123 struct window *w;
3124 struct glyph_row *row;
3125 {
3126 init_from_display_pos (it, w, &row->start);
3127 it->start = row->start;
3128 it->continuation_lines_width = row->continuation_lines_width;
3129 CHECK_IT (it);
3130 }
3131
3132
3133 3134 3135 3136
3137
3138 static int
3139 init_to_row_end (it, w, row)
3140 struct it *it;
3141 struct window *w;
3142 struct glyph_row *row;
3143 {
3144 int success = 0;
3145
3146 if (init_from_display_pos (it, w, &row->end))
3147 {
3148 if (row->continued_p)
3149 it->continuation_lines_width
3150 = row->continuation_lines_width + row->pixel_width;
3151 CHECK_IT (it);
3152 success = 1;
3153 }
3154
3155 return success;
3156 }
3157
3158
3159
3160
3161 3162 3163
3164
3165 3166 3167
3168
3169 static void
3170 handle_stop (it)
3171 struct it *it;
3172 {
3173 enum prop_handled handled;
3174 int handle_overlay_change_p;
3175 struct props *p;
3176
3177 it->dpvec = NULL;
3178 it->current.dpvec_index = -1;
3179 handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
3180 it->ignore_overlay_strings_at_pos_p = 0;
3181 it->ellipsis_p = 0;
3182
3183
3184 if (it->selective_display_ellipsis_p)
3185 it->saved_face_id = it->face_id;
3186
3187 do
3188 {
3189 handled = HANDLED_NORMALLY;
3190
3191
3192 for (p = it_props; p->handler; ++p)
3193 {
3194 handled = p->handler (it);
3195
3196 if (handled == HANDLED_RECOMPUTE_PROPS)
3197 break;
3198 else if (handled == HANDLED_RETURN)
3199 {
3200 3201
3202 if (!handle_overlay_change_p
3203 || it->sp > 1
3204 || !get_overlay_strings_1 (it, 0, 0))
3205 {
3206 if (it->ellipsis_p)
3207 setup_for_ellipsis (it, 0);
3208 3209 3210 3211 3212
3213 if (STRINGP (it->string) && !SCHARS (it->string))
3214 pop_it (it);
3215 return;
3216 }
3217 else if (STRINGP (it->string) && !SCHARS (it->string))
3218 pop_it (it);
3219 else
3220 {
3221 it->ignore_overlay_strings_at_pos_p = 1;
3222 it->string_from_display_prop_p = 0;
3223 handle_overlay_change_p = 0;
3224 }
3225 handled = HANDLED_RECOMPUTE_PROPS;
3226 break;
3227 }
3228 else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
3229 handle_overlay_change_p = 0;
3230 }
3231
3232 if (handled != HANDLED_RECOMPUTE_PROPS)
3233 {
3234 3235
3236 if (it->method == GET_FROM_DISPLAY_VECTOR)
3237 handle_overlay_change_p = 0;
3238
3239 3240 3241
3242 if (handle_overlay_change_p)
3243 handled = handle_overlay_change (it);
3244 }
3245
3246 if (it->ellipsis_p)
3247 {
3248 setup_for_ellipsis (it, 0);
3249 break;
3250 }
3251 }
3252 while (handled == HANDLED_RECOMPUTE_PROPS);
3253
3254
3255 if (handled == HANDLED_NORMALLY)
3256 compute_stop_pos (it);
3257 }
3258
3259
3260 3261
3262
3263 static void
3264 compute_stop_pos (it)
3265 struct it *it;
3266 {
3267 register INTERVAL iv, next_iv;
3268 Lisp_Object object, limit, position;
3269 EMACS_INT charpos, bytepos;
3270
3271
3272 it->stop_charpos = it->end_charpos;
3273
3274 if (STRINGP (it->string))
3275 {
3276 3277
3278 object = it->string;
3279 limit = Qnil;
3280 charpos = IT_STRING_CHARPOS (*it);
3281 bytepos = IT_STRING_BYTEPOS (*it);
3282 }
3283 else
3284 {
3285 EMACS_INT pos;
3286
3287 3288 3289 3290
3291 charpos = IT_CHARPOS (*it);
3292 bytepos = IT_BYTEPOS (*it);
3293 pos = next_overlay_change (charpos);
3294 if (pos < it->stop_charpos)
3295 it->stop_charpos = pos;
3296
3297 3298
3299 if (it->region_beg_charpos > 0)
3300 {
3301 if (IT_CHARPOS (*it) < it->region_beg_charpos)
3302 it->stop_charpos = min (it->stop_charpos, it->region_beg_charpos);
3303 else if (IT_CHARPOS (*it) < it->region_end_charpos)
3304 it->stop_charpos = min (it->stop_charpos, it->region_end_charpos);
3305 }
3306
3307 3308
3309 XSETBUFFER (object, current_buffer);
3310 limit = make_number (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
3311 }
3312
3313 3314
3315 position = make_number (charpos);
3316 iv = validate_interval_range (object, &position, &position, 0);
3317 if (!NULL_INTERVAL_P (iv))
3318 {
3319 Lisp_Object values_here[LAST_PROP_IDX];
3320 struct props *p;
3321
3322
3323 for (p = it_props; p->handler; ++p)
3324 values_here[p->idx] = textget (iv->plist, *p->name);
3325
3326 3327
3328 for (next_iv = next_interval (iv);
3329 (!NULL_INTERVAL_P (next_iv)
3330 && (NILP (limit)
3331 || XFASTINT (limit) > next_iv->position));
3332 next_iv = next_interval (next_iv))
3333 {
3334 for (p = it_props; p->handler; ++p)
3335 {
3336 Lisp_Object new_value;
3337
3338 new_value = textget (next_iv->plist, *p->name);
3339 if (!EQ (values_here[p->idx], new_value))
3340 break;
3341 }
3342
3343 if (p->handler)
3344 break;
3345 }
3346
3347 if (!NULL_INTERVAL_P (next_iv))
3348 {
3349 if (INTEGERP (limit)
3350 && next_iv->position >= XFASTINT (limit))
3351
3352 it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
3353 else
3354
3355 it->stop_charpos = min (it->stop_charpos, next_iv->position);
3356 }
3357 }
3358
3359 composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
3360 it->stop_charpos, it->string);
3361
3362 xassert (STRINGP (it->string)
3363 || (it->stop_charpos >= BEGV
3364 && it->stop_charpos >= IT_CHARPOS (*it)));
3365 }
3366
3367
3368 3369 3370 3371
3372
3373 static EMACS_INT
3374 next_overlay_change (pos)
3375 EMACS_INT pos;
3376 {
3377 int noverlays;
3378 EMACS_INT endpos;
3379 Lisp_Object *overlays;
3380 int i;
3381
3382
3383 GET_OVERLAYS_AT (pos, overlays, noverlays, &endpos, 1);
3384
3385 3386
3387 for (i = 0; i < noverlays; ++i)
3388 {
3389 Lisp_Object oend;
3390 EMACS_INT oendpos;
3391
3392 oend = OVERLAY_END (overlays[i]);
3393 oendpos = OVERLAY_POSITION (oend);
3394 endpos = min (endpos, oendpos);
3395 }
3396
3397 return endpos;
3398 }
3399
3400
3401
3402 3403 3404
3405
3406 3407 3408
3409
3410 static enum prop_handled
3411 handle_fontified_prop (it)
3412 struct it *it;
3413 {
3414 Lisp_Object prop, pos;
3415 enum prop_handled handled = HANDLED_NORMALLY;
3416
3417 if (!NILP (Vmemory_full))
3418 return handled;
3419
3420 3421 3422 3423
3424 if (!STRINGP (it->string)
3425 && it->s == NULL
3426 && !NILP (Vfontification_functions)
3427 && !NILP (Vrun_hooks)
3428 && (pos = make_number (IT_CHARPOS (*it)),
3429 prop = Fget_char_property (pos, Qfontified, Qnil),
3430 3431
3432 NILP (prop) && IT_CHARPOS (*it) < Z))
3433 {
3434 int count = SPECPDL_INDEX ();
3435 Lisp_Object val;
3436
3437 val = Vfontification_functions;
3438 specbind (Qfontification_functions, Qnil);
3439
3440 if (!CONSP (val) || EQ (XCAR (val), Qlambda))
3441 safe_call1 (val, pos);
3442 else
3443 {
3444 Lisp_Object globals, fn;
3445 struct gcpro gcpro1, gcpro2;
3446
3447 globals = Qnil;
3448 GCPRO2 (val, globals);
3449
3450 for (; CONSP (val); val = XCDR (val))
3451 {
3452 fn = XCAR (val);
3453
3454 if (EQ (fn, Qt))
3455 {
3456 3457 3458 3459 3460
3461 for (globals = Fdefault_value (Qfontification_functions);
3462 CONSP (globals);
3463 globals = XCDR (globals))
3464 {
3465 fn = XCAR (globals);
3466 if (!EQ (fn, Qt))
3467 safe_call1 (fn, pos);
3468 }
3469 }
3470 else
3471 safe_call1 (fn, pos);
3472 }
3473
3474 UNGCPRO;
3475 }
3476
3477 unbind_to (count, Qnil);
3478
3479 3480 3481
3482 if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
3483 handled = HANDLED_RECOMPUTE_PROPS;
3484 }
3485
3486 return handled;
3487 }
3488
3489
3490
3491 3492 3493
3494
3495 3496
3497
3498 static enum prop_handled
3499 handle_face_prop (it)
3500 struct it *it;
3501 {
3502 int new_face_id;
3503 EMACS_INT next_stop;
3504
3505 if (!STRINGP (it->string))
3506 {
3507 new_face_id
3508 = face_at_buffer_position (it->w,
3509 IT_CHARPOS (*it),
3510 it->region_beg_charpos,
3511 it->region_end_charpos,
3512 &next_stop,
3513 (IT_CHARPOS (*it)
3514 + TEXT_PROP_DISTANCE_LIMIT),
3515 0, it->base_face_id);
3516
3517 3518 3519 3520 3521 3522
3523 if (new_face_id != it->face_id)
3524 {
3525 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3526
3527 3528 3529 3530 3531 3532
3533 it->start_of_box_run_p
3534 = (new_face->box != FACE_NO_BOX
3535 && (it->face_id >= 0
3536 || IT_CHARPOS (*it) == BEG
3537 || new_face_id != face_before_it_pos (it)));
3538 it->face_box_p = new_face->box != FACE_NO_BOX;
3539 }
3540 }
3541 else
3542 {
3543 int base_face_id, bufpos;
3544 int i;
3545 Lisp_Object from_overlay
3546 = (it->current.overlay_string_index >= 0
3547 ? it->string_overlays[it->current.overlay_string_index]
3548 : Qnil);
3549
3550 3551 3552 3553 3554 3555
3556 if (! NILP (from_overlay))
3557 for (i = it->sp - 1; i >= 0; i--)
3558 {
3559 if (it->stack[i].current.overlay_string_index >= 0)
3560 from_overlay
3561 = it->string_overlays[it->stack[i].current.overlay_string_index];
3562 else if (! NILP (it->stack[i].from_overlay))
3563 from_overlay = it->stack[i].from_overlay;
3564
3565 if (!NILP (from_overlay))
3566 break;
3567 }
3568
3569 if (! NILP (from_overlay))
3570 {
3571 bufpos = IT_CHARPOS (*it);
3572 3573
3574 base_face_id
3575 = face_for_overlay_string (it->w,
3576 IT_CHARPOS (*it),
3577 it->region_beg_charpos,
3578 it->region_end_charpos,
3579 &next_stop,
3580 (IT_CHARPOS (*it)
3581 + TEXT_PROP_DISTANCE_LIMIT),
3582 0,
3583 from_overlay);
3584 }
3585 else
3586 {
3587 bufpos = 0;
3588
3589 3590 3591 3592 3593
3594 base_face_id = underlying_face_id (it);
3595 }
3596
3597 new_face_id = face_at_string_position (it->w,
3598 it->string,
3599 IT_STRING_CHARPOS (*it),
3600 bufpos,
3601 it->region_beg_charpos,
3602 it->region_end_charpos,
3603 &next_stop,
3604 base_face_id, 0);
3605
3606 3607 3608 3609 3610 3611 3612
3613 if (new_face_id != it->face_id)
3614 {
3615 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3616 struct face *old_face = FACE_FROM_ID (it->f, it->face_id);
3617
3618 3619 3620
3621 it->start_of_box_run_p
3622 = new_face->box && (old_face == NULL || !old_face->box);
3623 it->face_box_p = new_face->box != FACE_NO_BOX;
3624 }
3625 }
3626
3627 it->face_id = new_face_id;
3628 return HANDLED_NORMALLY;
3629 }
3630
3631
3632 3633 3634 3635
3636
3637 static int
3638 underlying_face_id (it)
3639 struct it *it;
3640 {
3641 int face_id = it->base_face_id, i;
3642
3643 xassert (STRINGP (it->string));
3644
3645 for (i = it->sp - 1; i >= 0; --i)
3646 if (NILP (it->stack[i].string))
3647 face_id = it->stack[i].face_id;
3648
3649 return face_id;
3650 }
3651
3652
3653 3654 3655
3656
3657 static int
3658 face_before_or_after_it_pos (it, before_p)
3659 struct it *it;
3660 int before_p;
3661 {
3662 int face_id, limit;
3663 EMACS_INT next_check_charpos;
3664 struct text_pos pos;
3665
3666 xassert (it->s == NULL);
3667
3668 if (STRINGP (it->string))
3669 {
3670 int bufpos, base_face_id;
3671
3672 3673 3674
3675 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
3676 || (IT_STRING_CHARPOS (*it) == 0 && before_p))
3677 return it->face_id;
3678
3679
3680 if (before_p)
3681 pos = string_pos (IT_STRING_CHARPOS (*it) - 1, it->string);
3682 else
3683 3684
3685 pos = (it->what == IT_COMPOSITION
3686 ? string_pos (IT_STRING_CHARPOS (*it)
3687 + it->cmp_it.nchars, it->string)
3688 : string_pos (IT_STRING_CHARPOS (*it) + 1, it->string));
3689
3690 if (it->current.overlay_string_index >= 0)
3691 bufpos = IT_CHARPOS (*it);
3692 else
3693 bufpos = 0;
3694
3695 base_face_id = underlying_face_id (it);
3696
3697
3698 face_id = face_at_string_position (it->w,
3699 it->string,
3700 CHARPOS (pos),
3701 bufpos,
3702 it->region_beg_charpos,
3703 it->region_end_charpos,
3704 &next_check_charpos,
3705 base_face_id, 0);
3706
3707 3708 3709
3710 if (STRING_MULTIBYTE (it->string))
3711 {
3712 const unsigned char *p = SDATA (it->string) + BYTEPOS (pos);
3713 int rest = SBYTES (it->string) - BYTEPOS (pos);
3714 int c, len;
3715 struct face *face = FACE_FROM_ID (it->f, face_id);
3716
3717 c = string_char_and_length (p, &len);
3718 face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), it->string);
3719 }
3720 }
3721 else
3722 {
3723 if ((IT_CHARPOS (*it) >= ZV && !before_p)
3724 || (IT_CHARPOS (*it) <= BEGV && before_p))
3725 return it->face_id;
3726
3727 limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
3728 pos = it->current.pos;
3729
3730 if (before_p)
3731 DEC_TEXT_POS (pos, it->multibyte_p);
3732 else
3733 {
3734 if (it->what == IT_COMPOSITION)
3735 3736
3737 pos.charpos += it->cmp_it.nchars, pos.bytepos += it->len;
3738 else
3739 INC_TEXT_POS (pos, it->multibyte_p);
3740 }
3741
3742
3743 face_id = face_at_buffer_position (it->w,
3744 CHARPOS (pos),
3745 it->region_beg_charpos,
3746 it->region_end_charpos,
3747 &next_check_charpos,
3748 limit, 0, -1);
3749
3750 3751 3752
3753 if (it->multibyte_p)
3754 {
3755 int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
3756 struct face *face = FACE_FROM_ID (it->f, face_id);
3757 face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
3758 }
3759 }
3760
3761 return face_id;
3762 }
3763
3764
3765
3766 3767 3768
3769
3770 3771
3772
3773 static enum prop_handled
3774 handle_invisible_prop (it)
3775 struct it *it;
3776 {
3777 enum prop_handled handled = HANDLED_NORMALLY;
3778
3779 if (STRINGP (it->string))
3780 {
3781 extern Lisp_Object Qinvisible;
3782 Lisp_Object prop, end_charpos, limit, charpos;
3783
3784 3785 3786
3787 charpos = make_number (IT_STRING_CHARPOS (*it));
3788 prop = Fget_text_property (charpos, Qinvisible, it->string);
3789
3790 if (!NILP (prop)
3791 && IT_STRING_CHARPOS (*it) < it->end_charpos)
3792 {
3793 handled = HANDLED_RECOMPUTE_PROPS;
3794
3795 3796 3797 3798
3799 XSETINT (limit, SCHARS (it->string));
3800 end_charpos = Fnext_single_property_change (charpos, Qinvisible,
3801 it->string, limit);
3802
3803 3804 3805
3806 if (INTEGERP (end_charpos)
3807 && XFASTINT (end_charpos) < XFASTINT (limit))
3808 {
3809 struct text_pos old;
3810 old = it->current.string_pos;
3811 IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
3812 compute_string_pos (&it->current.string_pos, old, it->string);
3813 }
3814 else
3815 {
3816 3817 3818
3819 if (it->current.overlay_string_index >= 0)
3820 {
3821 next_overlay_string (it);
3822 3823
3824 handled = HANDLED_OVERLAY_STRING_CONSUMED;
3825 }
3826 else
3827 {
3828 IT_STRING_CHARPOS (*it) = SCHARS (it->string);
3829 IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
3830 }
3831 }
3832 }
3833 }
3834 else
3835 {
3836 int invis_p;
3837 EMACS_INT newpos, next_stop, start_charpos, tem;
3838 Lisp_Object pos, prop, overlay;
3839
3840
3841 tem = start_charpos = IT_CHARPOS (*it);
3842 pos = make_number (tem);
3843 prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
3844 &overlay);
3845 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
3846
3847
3848 if (invis_p && start_charpos < it->end_charpos)
3849 {
3850 3851
3852 int display_ellipsis_p = invis_p == 2;
3853
3854 handled = HANDLED_RECOMPUTE_PROPS;
3855
3856 3857
3858 do
3859 {
3860 3861 3862 3863 3864
3865 newpos = skip_invisible (tem, &next_stop, ZV, it->window);
3866
3867 3868 3869
3870 if (newpos == tem || newpos >= ZV)
3871 invis_p = 0;
3872 else
3873 {
3874 3875 3876 3877 3878 3879
3880 pos = make_number (newpos);
3881 prop = Fget_char_property (pos, Qinvisible, it->window);
3882 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
3883 }
3884
3885 3886
3887 if (invis_p)
3888 tem = next_stop;
3889
3890 3891
3892 if (invis_p == 2)
3893 display_ellipsis_p = 1;
3894 }
3895 while (invis_p);
3896
3897
3898 if (it->bidi_p && newpos < ZV)
3899 {
3900 3901 3902 3903 3904 3905 3906 3907 3908
3909 if (it->bidi_it.first_elt)
3910 {
3911 3912 3913 3914 3915 3916
3917 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
3918 }
3919 do
3920 {
3921 bidi_move_to_visually_next (&it->bidi_it);
3922 }
3923 while (it->stop_charpos <= it->bidi_it.charpos
3924 && it->bidi_it.charpos < newpos);
3925 IT_CHARPOS (*it) = it->bidi_it.charpos;
3926 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
3927 3928 3929 3930
3931 if (IT_CHARPOS (*it) >= newpos)
3932 it->prev_stop = newpos;
3933 }
3934 else
3935 {
3936 IT_CHARPOS (*it) = newpos;
3937 IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
3938 }
3939
3940 3941 3942 3943 3944 3945
3946 if (NILP (overlay)
3947 && get_overlay_strings (it, it->stop_charpos))
3948 {
3949 handled = HANDLED_RECOMPUTE_PROPS;
3950 it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
3951 }
3952 else if (display_ellipsis_p)
3953 {
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965
3966 if (!STRINGP (it->object))
3967 {
3968 it->position.charpos = newpos - 1;
3969 it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
3970 }
3971 it->ellipsis_p = 1;
3972 3973 3974
3975 handled = HANDLED_RETURN;
3976 }
3977 }
3978 }
3979
3980 return handled;
3981 }
3982
3983
3984 3985
3986
3987 static void
3988 setup_for_ellipsis (it, len)
3989 struct it *it;
3990 int len;
3991 {
3992 3993
3994 if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
3995 {
3996 struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
3997 it->dpvec = v->contents;
3998 it->dpend = v->contents + v->size;
3999 }
4000 else
4001 {
4002
4003 it->dpvec = default_invis_vector;
4004 it->dpend = default_invis_vector + 3;
4005 }
4006
4007 it->dpvec_char_len = len;
4008 it->current.dpvec_index = 0;
4009 it->dpvec_face_id = -1;
4010
4011 4012 4013
4014 if (it->saved_face_id < 0 || it->saved_face_id != it->face_id)
4015 it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
4016
4017 it->method = GET_FROM_DISPLAY_VECTOR;
4018 it->ellipsis_p = 1;
4019 }
4020
4021
4022
4023 4024 4025
4026
4027 4028 4029 4030 4031
4032
4033 static enum prop_handled
4034 handle_display_prop (it)
4035 struct it *it;
4036 {
4037 Lisp_Object prop, object, overlay;
4038 struct text_pos *position;
4039
4040 int display_replaced_p = 0;
4041
4042 if (STRINGP (it->string))
4043 {
4044 object = it->string;
4045 position = &it->current.string_pos;
4046 }
4047 else
4048 {
4049 XSETWINDOW (object, it->w);
4050 position = &it->current.pos;
4051 }
4052
4053
4054 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
4055 it->space_width = Qnil;
4056 it->font_height = Qnil;
4057 it->voffset = 0;
4058
4059 4060 4061
4062 if (!it->string_from_display_prop_p)
4063 it->area = TEXT_AREA;
4064
4065 prop = get_char_property_and_overlay (make_number (position->charpos),
4066 Qdisplay, object, &overlay);
4067 if (NILP (prop))
4068 return HANDLED_NORMALLY;
4069 4070
4071
4072 if (!STRINGP (it->string))
4073 object = it->w->buffer;
4074
4075 if (CONSP (prop)
4076
4077 && !EQ (XCAR (prop), Qimage)
4078 && !EQ (XCAR (prop), Qspace)
4079 && !EQ (XCAR (prop), Qwhen)
4080 && !EQ (XCAR (prop), Qslice)
4081 && !EQ (XCAR (prop), Qspace_width)
4082 && !EQ (XCAR (prop), Qheight)
4083 && !EQ (XCAR (prop), Qraise)
4084
4085 && !(CONSP (XCAR (prop)) && EQ (XCAR (XCAR (prop)), Qmargin))
4086 && !EQ (XCAR (prop), Qleft_fringe)
4087 && !EQ (XCAR (prop), Qright_fringe)
4088 && !NILP (XCAR (prop)))
4089 {
4090 for (; CONSP (prop); prop = XCDR (prop))
4091 {
4092 if (handle_single_display_spec (it, XCAR (prop), object, overlay,
4093 position, display_replaced_p))
4094 {
4095 display_replaced_p = 1;
4096 4097
4098 if (STRINGP (object))
4099 break;
4100 }
4101 }
4102 }
4103 else if (VECTORP (prop))
4104 {
4105 int i;
4106 for (i = 0; i < ASIZE (prop); ++i)
4107 if (handle_single_display_spec (it, AREF (prop, i), object, overlay,
4108 position, display_replaced_p))
4109 {
4110 display_replaced_p = 1;
4111 4112
4113 if (STRINGP (object))
4114 break;
4115 }
4116 }
4117 else
4118 {
4119 if (handle_single_display_spec (it, prop, object, overlay,
4120 position, 0))
4121 display_replaced_p = 1;
4122 }
4123
4124 return display_replaced_p ? HANDLED_RETURN : HANDLED_NORMALLY;
4125 }
4126
4127
4128 4129
4130
4131 static struct text_pos
4132 display_prop_end (it, object, start_pos)
4133 struct it *it;
4134 Lisp_Object object;
4135 struct text_pos start_pos;
4136 {
4137 Lisp_Object end;
4138 struct text_pos end_pos;
4139
4140 end = Fnext_single_char_property_change (make_number (CHARPOS (start_pos)),
4141 Qdisplay, object, Qnil);
4142 CHARPOS (end_pos) = XFASTINT (end);
4143 if (STRINGP (object))
4144 compute_string_pos (&end_pos, start_pos, it->string);
4145 else
4146 BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
4147
4148 return end_pos;
4149 }
4150
4151
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167
4168
4169 static int
4170 handle_single_display_spec (it, spec, object, overlay, position,
4171 display_replaced_before_p)
4172 struct it *it;
4173 Lisp_Object spec;
4174 Lisp_Object object;
4175 Lisp_Object overlay;
4176 struct text_pos *position;
4177 int display_replaced_before_p;
4178 {
4179 Lisp_Object form;
4180 Lisp_Object location, value;
4181 struct text_pos start_pos, save_pos;
4182 int valid_p;
4183
4184 4185
4186 form = Qt;
4187 if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
4188 {
4189 spec = XCDR (spec);
4190 if (!CONSP (spec))
4191 return 0;
4192 form = XCAR (spec);
4193 spec = XCDR (spec);
4194 }
4195
4196 if (!NILP (form) && !EQ (form, Qt))
4197 {
4198 int count = SPECPDL_INDEX ();
4199 struct gcpro gcpro1;
4200
4201 4202 4203 4204
4205 specbind (Qobject, object);
4206 specbind (Qposition, make_number (CHARPOS (*position)));
4207 specbind (Qbuffer_position,
4208 make_number (STRINGP (object)
4209 ? IT_CHARPOS (*it) : CHARPOS (*position)));
4210 GCPRO1 (form);
4211 form = safe_eval (form);
4212 UNGCPRO;
4213 unbind_to (count, Qnil);
4214 }
4215
4216 if (NILP (form))
4217 return 0;
4218
4219
4220 if (CONSP (spec)
4221 && EQ (XCAR (spec), Qheight)
4222 && CONSP (XCDR (spec)))
4223 {
4224 if (!FRAME_WINDOW_P (it->f))
4225 return 0;
4226
4227 it->font_height = XCAR (XCDR (spec));
4228 if (!NILP (it->font_height))
4229 {
4230 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4231 int new_height = -1;
4232
4233 if (CONSP (it->font_height)
4234 && (EQ (XCAR (it->font_height), Qplus)
4235 || EQ (XCAR (it->font_height), Qminus))
4236 && CONSP (XCDR (it->font_height))
4237 && INTEGERP (XCAR (XCDR (it->font_height))))
4238 {
4239
4240 int steps = XINT (XCAR (XCDR (it->font_height)));
4241 if (EQ (XCAR (it->font_height), Qplus))
4242 steps = - steps;
4243 it->face_id = smaller_face (it->f, it->face_id, steps);
4244 }
4245 else if (FUNCTIONP (it->font_height))
4246 {
4247 4248
4249 Lisp_Object height;
4250 height = safe_call1 (it->font_height,
4251 face->lface[LFACE_HEIGHT_INDEX]);
4252 if (NUMBERP (height))
4253 new_height = XFLOATINT (height);
4254 }
4255 else if (NUMBERP (it->font_height))
4256 {
4257
4258 struct face *face;
4259
4260 face = FACE_FROM_ID (it->f,
4261 lookup_basic_face (it->f, DEFAULT_FACE_ID));
4262 new_height = (XFLOATINT (it->font_height)
4263 * XINT (face->lface[LFACE_HEIGHT_INDEX]));
4264 }
4265 else
4266 {
4267 4268
4269 int count = SPECPDL_INDEX ();
4270
4271 specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
4272 value = safe_eval (it->font_height);
4273 unbind_to (count, Qnil);
4274
4275 if (NUMBERP (value))
4276 new_height = XFLOATINT (value);
4277 }
4278
4279 if (new_height > 0)
4280 it->face_id = face_with_height (it->f, it->face_id, new_height);
4281 }
4282
4283 return 0;
4284 }
4285
4286
4287 if (CONSP (spec)
4288 && EQ (XCAR (spec), Qspace_width)
4289 && CONSP (XCDR (spec)))
4290 {
4291 if (!FRAME_WINDOW_P (it->f))
4292 return 0;
4293
4294 value = XCAR (XCDR (spec));
4295 if (NUMBERP (value) && XFLOATINT (value) > 0)
4296 it->space_width = value;
4297
4298 return 0;
4299 }
4300
4301
4302 if (CONSP (spec)
4303 && EQ (XCAR (spec), Qslice))
4304 {
4305 Lisp_Object tem;
4306
4307 if (!FRAME_WINDOW_P (it->f))
4308 return 0;
4309
4310 if (tem = XCDR (spec), CONSP (tem))
4311 {
4312 it->slice.x = XCAR (tem);
4313 if (tem = XCDR (tem), CONSP (tem))
4314 {
4315 it->slice.y = XCAR (tem);
4316 if (tem = XCDR (tem), CONSP (tem))
4317 {
4318 it->slice.width = XCAR (tem);
4319 if (tem = XCDR (tem), CONSP (tem))
4320 it->slice.height = XCAR (tem);
4321 }
4322 }
4323 }
4324
4325 return 0;
4326 }
4327
4328
4329 if (CONSP (spec)
4330 && EQ (XCAR (spec), Qraise)
4331 && CONSP (XCDR (spec)))
4332 {
4333 if (!FRAME_WINDOW_P (it->f))
4334 return 0;
4335
4336 #ifdef HAVE_WINDOW_SYSTEM
4337 value = XCAR (XCDR (spec));
4338 if (NUMBERP (value))
4339 {
4340 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4341 it->voffset = - (XFLOATINT (value)
4342 * (FONT_HEIGHT (face->font)));
4343 }
4344 #endif
4345
4346 return 0;
4347 }
4348
4349 4350
4351 if (it->string_from_display_prop_p)
4352 return 0;
4353
4354 4355
4356 start_pos = *position;
4357 *position = display_prop_end (it, object, start_pos);
4358 value = Qnil;
4359
4360 4361
4362 it->stop_charpos = position->charpos;
4363
4364 4365
4366 if (CONSP (spec)
4367 && (EQ (XCAR (spec), Qleft_fringe)
4368 || EQ (XCAR (spec), Qright_fringe))
4369 && CONSP (XCDR (spec)))
4370 {
4371 int face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);
4372 int fringe_bitmap;
4373
4374 if (!FRAME_WINDOW_P (it->f))
4375 4376
4377 return 0;
4378
4379 #ifdef HAVE_WINDOW_SYSTEM
4380 value = XCAR (XCDR (spec));
4381 if (!SYMBOLP (value)
4382 || !(fringe_bitmap = lookup_fringe_bitmap (value)))
4383 4384
4385 return 0;
4386
4387 if (CONSP (XCDR (XCDR (spec))))
4388 {
4389 Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
4390 int face_id2 = lookup_derived_face (it->f, face_name,
4391 FRINGE_FACE_ID, 0);
4392 if (face_id2 >= 0)
4393 face_id = face_id2;
4394 }
4395
4396 4397
4398
4399 save_pos = it->position;
4400 it->position = *position;
4401 push_it (it);
4402 it->position = save_pos;
4403
4404 it->area = TEXT_AREA;
4405 it->what = IT_IMAGE;
4406 it->image_id = -1;
4407 it->position = start_pos;
4408 it->object = NILP (object) ? it->w->buffer : object;
4409 it->method = GET_FROM_IMAGE;
4410 it->from_overlay = Qnil;
4411 it->face_id = face_id;
4412
4413 4414 4415
4416 *position = start_pos;
4417
4418 if (EQ (XCAR (spec), Qleft_fringe))
4419 {
4420 it->left_user_fringe_bitmap = fringe_bitmap;
4421 it->left_user_fringe_face_id = face_id;
4422 }
4423 else
4424 {
4425 it->right_user_fringe_bitmap = fringe_bitmap;
4426 it->right_user_fringe_face_id = face_id;
4427 }
4428 #endif
4429 return 1;
4430 }
4431
4432 4433 4434
4435 location = Qunbound;
4436 if (CONSP (spec) && CONSP (XCAR (spec)))
4437 {
4438 Lisp_Object tem;
4439
4440 value = XCDR (spec);
4441 if (CONSP (value))
4442 value = XCAR (value);
4443
4444 tem = XCAR (spec);
4445 if (EQ (XCAR (tem), Qmargin)
4446 && (tem = XCDR (tem),
4447 tem = CONSP (tem) ? XCAR (tem) : Qnil,
4448 (NILP (tem)
4449 || EQ (tem, Qleft_margin)
4450 || EQ (tem, Qright_margin))))
4451 location = tem;
4452 }
4453
4454 if (EQ (location, Qunbound))
4455 {
4456 location = Qnil;
4457 value = spec;
4458 }
4459
4460 4461 4462 4463 4464 4465
4466
4467 valid_p = (STRINGP (value)
4468 #ifdef HAVE_WINDOW_SYSTEM
4469 || (FRAME_WINDOW_P (it->f) && valid_image_p (value))
4470 #endif
4471 || (CONSP (value) && EQ (XCAR (value), Qspace)));
4472
4473 if (valid_p && !display_replaced_before_p)
4474 {
4475 4476
4477 save_pos = it->position;
4478 it->position = *position;
4479 push_it (it);
4480 it->position = save_pos;
4481 it->from_overlay = overlay;
4482
4483 if (NILP (location))
4484 it->area = TEXT_AREA;
4485 else if (EQ (location, Qleft_margin))
4486 it->area = LEFT_MARGIN_AREA;
4487 else
4488 it->area = RIGHT_MARGIN_AREA;
4489
4490 if (STRINGP (value))
4491 {
4492 it->string = value;
4493 it->multibyte_p = STRING_MULTIBYTE (it->string);
4494 it->current.overlay_string_index = -1;
4495 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
4496 it->end_charpos = it->string_nchars = SCHARS (it->string);
4497 it->method = GET_FROM_STRING;
4498 it->stop_charpos = 0;
4499 it->string_from_display_prop_p = 1;
4500 4501 4502
4503 if (BUFFERP (object))
4504 *position = start_pos;
4505 }
4506 else if (CONSP (value) && EQ (XCAR (value), Qspace))
4507 {
4508 it->method = GET_FROM_STRETCH;
4509 it->object = value;
4510 *position = it->position = start_pos;
4511 }
4512 #ifdef HAVE_WINDOW_SYSTEM
4513 else
4514 {
4515 it->what = IT_IMAGE;
4516 it->image_id = lookup_image (it->f, value);
4517 it->position = start_pos;
4518 it->object = NILP (object) ? it->w->buffer : object;
4519 it->method = GET_FROM_IMAGE;
4520
4521 4522 4523
4524 *position = start_pos;
4525 }
4526 #endif
4527
4528 return 1;
4529 }
4530
4531 4532
4533 *position = start_pos;
4534 return 0;
4535 }
4536
4537
4538 4539
4540
4541 static int
4542 single_display_spec_intangible_p (prop)
4543 Lisp_Object prop;
4544 {
4545
4546 if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
4547 {
4548 prop = XCDR (prop);
4549 if (!CONSP (prop))
4550 return 0;
4551 prop = XCDR (prop);
4552 }
4553
4554 if (STRINGP (prop))
4555 return 1;
4556
4557 if (!CONSP (prop))
4558 return 0;
4559
4560 4561
4562 if (EQ (XCAR (prop), Qmargin))
4563 {
4564 prop = XCDR (prop);
4565 if (!CONSP (prop))
4566 return 0;
4567
4568 prop = XCDR (prop);
4569 if (!CONSP (prop)
4570 || EQ (XCAR (prop), Qleft_margin)
4571 || EQ (XCAR (prop), Qright_margin))
4572 return 0;
4573 }
4574
4575 return (CONSP (prop)
4576 && (EQ (XCAR (prop), Qimage)
4577 || EQ (XCAR (prop), Qspace)));
4578 }
4579
4580
4581 4582
4583
4584 int
4585 display_prop_intangible_p (prop)
4586 Lisp_Object prop;
4587 {
4588 if (CONSP (prop)
4589 && CONSP (XCAR (prop))
4590 && !EQ (Qmargin, XCAR (XCAR (prop))))
4591 {
4592
4593 while (CONSP (prop))
4594 {
4595 if (single_display_spec_intangible_p (XCAR (prop)))
4596 return 1;
4597 prop = XCDR (prop);
4598 }
4599 }
4600 else if (VECTORP (prop))
4601 {
4602
4603 int i;
4604 for (i = 0; i < ASIZE (prop); ++i)
4605 if (single_display_spec_intangible_p (AREF (prop, i)))
4606 return 1;
4607 }
4608 else
4609 return single_display_spec_intangible_p (prop);
4610
4611 return 0;
4612 }
4613
4614
4615
4616
4617 static int
4618 single_display_spec_string_p (prop, string)
4619 Lisp_Object prop, string;
4620 {
4621 if (EQ (string, prop))
4622 return 1;
4623
4624
4625 if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
4626 {
4627 prop = XCDR (prop);
4628 if (!CONSP (prop))
4629 return 0;
4630 prop = XCDR (prop);
4631 }
4632
4633 if (CONSP (prop))
4634
4635 if (EQ (XCAR (prop), Qmargin))
4636 {
4637 prop = XCDR (prop);
4638 if (!CONSP (prop))
4639 return 0;
4640
4641 prop = XCDR (prop);
4642 if (!CONSP (prop))
4643 return 0;
4644 }
4645
4646 return CONSP (prop) && EQ (XCAR (prop), string);
4647 }
4648
4649
4650
4651
4652 static int
4653 display_prop_string_p (prop, string)
4654 Lisp_Object prop, string;
4655 {
4656 if (CONSP (prop)
4657 && CONSP (XCAR (prop))
4658 && !EQ (Qmargin, XCAR (XCAR (prop))))
4659 {
4660
4661 while (CONSP (prop))
4662 {
4663 if (single_display_spec_string_p (XCAR (prop), string))
4664 return 1;
4665 prop = XCDR (prop);
4666 }
4667 }
4668 else if (VECTORP (prop))
4669 {
4670
4671 int i;
4672 for (i = 0; i < ASIZE (prop); ++i)
4673 if (single_display_spec_string_p (AREF (prop, i), string))
4674 return 1;
4675 }
4676 else
4677 return single_display_spec_string_p (prop, string);
4678
4679 return 0;
4680 }
4681
4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
4693
4694 static EMACS_INT
4695 string_buffer_position_lim (w, string, from, to, back_p)
4696 struct window *w;
4697 Lisp_Object string;
4698 EMACS_INT from, to;
4699 int back_p;
4700 {
4701 Lisp_Object limit, prop, pos;
4702 int found = 0;
4703
4704 pos = make_number (from);
4705
4706 if (!back_p)
4707 {
4708 limit = make_number (min (to, ZV));
4709 while (!found && !EQ (pos, limit))
4710 {
4711 prop = Fget_char_property (pos, Qdisplay, Qnil);
4712 if (!NILP (prop) && display_prop_string_p (prop, string))
4713 found = 1;
4714 else
4715 pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
4716 limit);
4717 }
4718 }
4719 else
4720 {
4721 limit = make_number (max (to, BEGV));
4722 while (!found && !EQ (pos, limit))
4723 {
4724 prop = Fget_char_property (pos, Qdisplay, Qnil);
4725 if (!NILP (prop) && display_prop_string_p (prop, string))
4726 found = 1;
4727 else
4728 pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
4729 limit);
4730 }
4731 }
4732
4733 return found ? XINT (pos) : 0;
4734 }
4735
4736 4737 4738 4739 4740 4741 4742 4743 4744 4745
4746
4747 EMACS_INT
4748 string_buffer_position (w, string, around_charpos)
4749 struct window *w;
4750 Lisp_Object string;
4751 EMACS_INT around_charpos;
4752 {
4753 Lisp_Object limit, prop, pos;
4754 const int MAX_DISTANCE = 1000;
4755 EMACS_INT found = string_buffer_position_lim (w, string, around_charpos,
4756 around_charpos + MAX_DISTANCE,
4757 0);
4758
4759 if (!found)
4760 found = string_buffer_position_lim (w, string, around_charpos,
4761 around_charpos - MAX_DISTANCE, 1);
4762 return found;
4763 }
4764
4765
4766
4767 4768 4769
4770
4771 4772
4773
4774 static enum prop_handled
4775 handle_composition_prop (it)
4776 struct it *it;
4777 {
4778 Lisp_Object prop, string;
4779 EMACS_INT pos, pos_byte, start, end;
4780
4781 if (STRINGP (it->string))
4782 {
4783 unsigned char *s;
4784
4785 pos = IT_STRING_CHARPOS (*it);
4786 pos_byte = IT_STRING_BYTEPOS (*it);
4787 string = it->string;
4788 s = SDATA (string) + pos_byte;
4789 it->c = STRING_CHAR (s);
4790 }
4791 else
4792 {
4793 pos = IT_CHARPOS (*it);
4794 pos_byte = IT_BYTEPOS (*it);
4795 string = Qnil;
4796 it->c = FETCH_CHAR (pos_byte);
4797 }
4798
4799 4800 4801
4802 if (find_composition (pos, -1, &start, &end, &prop, string)
4803 && COMPOSITION_VALID_P (start, end, prop)
4804 && (STRINGP (it->string) || (PT <= start || PT >= end)))
4805 {
4806 if (start != pos)
4807 {
4808 if (STRINGP (it->string))
4809 pos_byte = string_char_to_byte (it->string, start);
4810 else
4811 pos_byte = CHAR_TO_BYTE (start);
4812 }
4813 it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
4814 prop, string);
4815
4816 if (it->cmp_it.id >= 0)
4817 {
4818 it->cmp_it.ch = -1;
4819 it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
4820 it->cmp_it.nglyphs = -1;
4821 }
4822 }
4823
4824 return HANDLED_NORMALLY;
4825 }
4826
4827
4828
4829 4830 4831
4832
4833 4834
4835
4836 struct overlay_entry
4837 {
4838 Lisp_Object overlay;
4839 Lisp_Object string;
4840 int priority;
4841 int after_string_p;
4842 };
4843
4844
4845 4846
4847
4848 static enum prop_handled
4849 handle_overlay_change (it)
4850 struct it *it;
4851 {
4852 if (!STRINGP (it->string) && get_overlay_strings (it, 0))
4853 return HANDLED_RECOMPUTE_PROPS;
4854 else
4855 return HANDLED_NORMALLY;
4856 }
4857
4858
4859 4860 4861 4862 4863 4864
4865
4866 static void
4867 next_overlay_string (it)
4868 struct it *it;
4869 {
4870 ++it->current.overlay_string_index;
4871 if (it->current.overlay_string_index == it->n_overlay_strings)
4872 {
4873 4874 4875
4876
4877 it->ellipsis_p = (it->stack[it->sp - 1].display_ellipsis_p != 0);
4878 pop_it (it);
4879 xassert (it->sp > 0
4880 || (NILP (it->string)
4881 && it->method == GET_FROM_BUFFER
4882 && it->stop_charpos >= BEGV
4883 && it->stop_charpos <= it->end_charpos));
4884 it->current.overlay_string_index = -1;
4885 it->n_overlay_strings = 0;
4886
4887 4888 4889
4890 if (NILP (it->string) && IT_CHARPOS (*it) >= it->end_charpos)
4891 it->overlay_strings_at_end_processed_p = 1;
4892 }
4893 else
4894 {
4895 4896 4897 4898
4899 int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
4900
4901 if (it->current.overlay_string_index && i == 0)
4902 load_overlay_strings (it, 0);
4903
4904 4905
4906 it->string = it->overlay_strings[i];
4907 it->multibyte_p = STRING_MULTIBYTE (it->string);
4908 SET_TEXT_POS (it->current.string_pos, 0, 0);
4909 it->method = GET_FROM_STRING;
4910 it->stop_charpos = 0;
4911 if (it->cmp_it.stop_pos >= 0)
4912 it->cmp_it.stop_pos = 0;
4913 }
4914
4915 CHECK_IT (it);
4916 }
4917
4918
4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932
4933
4934
4935 static int
4936 compare_overlay_entries (e1, e2)
4937 void *e1, *e2;
4938 {
4939 struct overlay_entry *entry1 = (struct overlay_entry *) e1;
4940 struct overlay_entry *entry2 = (struct overlay_entry *) e2;
4941 int result;
4942
4943 if (entry1->after_string_p != entry2->after_string_p)
4944 {
4945 4946
4947 if (EQ (entry1->overlay, entry2->overlay))
4948 result = entry1->after_string_p ? 1 : -1;
4949 else
4950 result = entry1->after_string_p ? -1 : 1;
4951 }
4952 else if (entry1->after_string_p)
4953
4954 result = entry2->priority - entry1->priority;
4955 else
4956
4957 result = entry1->priority - entry2->priority;
4958
4959 return result;
4960 }
4961
4962
4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985
4986
4987 static void
4988 load_overlay_strings (it, charpos)
4989 struct it *it;
4990 int charpos;
4991 {
4992 extern Lisp_Object Qwindow, Qpriority;
4993 Lisp_Object overlay, window, str, invisible;
4994 struct Lisp_Overlay *ov;
4995 int start, end;
4996 int size = 20;
4997 int n = 0, i, j, invis_p;
4998 struct overlay_entry *entries
4999 = (struct overlay_entry *) alloca (size * sizeof *entries);
5000
5001 if (charpos <= 0)
5002 charpos = IT_CHARPOS (*it);
5003
5004 5005 5006 5007
5008 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5009 do \
5010 { \
5011 Lisp_Object priority; \
5012 \
5013 if (n == size) \
5014 { \
5015 int new_size = 2 * size; \
5016 struct overlay_entry *old = entries; \
5017 entries = \
5018 (struct overlay_entry *) alloca (new_size \
5019 * sizeof *entries); \
5020 bcopy (old, entries, size * sizeof *entries); \
5021 size = new_size; \
5022 } \
5023 \
5024 entries[n].string = (STRING); \
5025 entries[n].overlay = (OVERLAY); \
5026 priority = Foverlay_get ((OVERLAY), Qpriority); \
5027 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5028 entries[n].after_string_p = (AFTER_P); \
5029 ++n; \
5030 } \
5031 while (0)
5032
5033
5034 for (ov = current_buffer->overlays_before; ov; ov = ov->next)
5035 {
5036 XSETMISC (overlay, ov);
5037 xassert (OVERLAYP (overlay));
5038 start = OVERLAY_POSITION (OVERLAY_START (overlay));
5039 end = OVERLAY_POSITION (OVERLAY_END (overlay));
5040
5041 if (end < charpos)
5042 break;
5043
5044 5045
5046 if (end != charpos && start != charpos)
5047 continue;
5048
5049
5050 window = Foverlay_get (overlay, Qwindow);
5051 if (WINDOWP (window) && XWINDOW (window) != it->w)
5052 continue;
5053
5054 5055 5056
5057 invisible = Foverlay_get (overlay, Qinvisible);
5058 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5059
5060
5061 if ((start == charpos || (end == charpos && invis_p))
5062 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5063 && SCHARS (str))
5064 RECORD_OVERLAY_STRING (overlay, str, 0);
5065
5066
5067 if ((end == charpos || (start == charpos && invis_p))
5068 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5069 && SCHARS (str))
5070 RECORD_OVERLAY_STRING (overlay, str, 1);
5071 }
5072
5073
5074 for (ov = current_buffer->overlays_after; ov; ov = ov->next)
5075 {
5076 XSETMISC (overlay, ov);
5077 xassert (OVERLAYP (overlay));
5078 start = OVERLAY_POSITION (OVERLAY_START (overlay));
5079 end = OVERLAY_POSITION (OVERLAY_END (overlay));
5080
5081 if (start > charpos)
5082 break;
5083
5084 5085
5086 if (end != charpos && start != charpos)
5087 continue;
5088
5089
5090 window = Foverlay_get (overlay, Qwindow);
5091 if (WINDOWP (window) && XWINDOW (window) != it->w)
5092 continue;
5093
5094 5095
5096 invisible = Foverlay_get (overlay, Qinvisible);
5097 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5098
5099
5100 if ((start == charpos || (end == charpos && invis_p))
5101 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5102 && SCHARS (str))
5103 RECORD_OVERLAY_STRING (overlay, str, 0);
5104
5105
5106 if ((end == charpos || (start == charpos && invis_p))
5107 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5108 && SCHARS (str))
5109 RECORD_OVERLAY_STRING (overlay, str, 1);
5110 }
5111
5112 #undef RECORD_OVERLAY_STRING
5113
5114
5115 if (n > 1)
5116 qsort (entries, n, sizeof *entries, compare_overlay_entries);
5117
5118
5119 it->n_overlay_strings = n;
5120
5121 5122 5123
5124 i = 0;
5125 j = it->current.overlay_string_index;
5126 while (i < OVERLAY_STRING_CHUNK_SIZE && j < n)
5127 {
5128 it->overlay_strings[i] = entries[j].string;
5129 it->string_overlays[i++] = entries[j++].overlay;
5130 }
5131
5132 CHECK_IT (it);
5133 }
5134
5135
5136 5137 5138
5139
5140 static int
5141 get_overlay_strings_1 (it, charpos, compute_stop_p)
5142 struct it *it;
5143 int charpos;
5144 int compute_stop_p;
5145 {
5146 5147 5148 5149 5150 5151 5152
5153 it->current.overlay_string_index = 0;
5154 load_overlay_strings (it, charpos);
5155
5156 5157 5158
5159 if (it->n_overlay_strings)
5160 {
5161 5162 5163
5164 if (compute_stop_p)
5165 compute_stop_pos (it);
5166 xassert (it->face_id >= 0);
5167
5168 5169
5170 xassert (!compute_stop_p || it->sp == 0);
5171
5172 5173
5174 if (!STRINGP (it->string) || SCHARS (it->string))
5175 push_it (it);
5176
5177 5178
5179 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
5180 it->string = it->overlay_strings[0];
5181 it->from_overlay = Qnil;
5182 it->stop_charpos = 0;
5183 xassert (STRINGP (it->string));
5184 it->end_charpos = SCHARS (it->string);
5185 it->multibyte_p = STRING_MULTIBYTE (it->string);
5186 it->method = GET_FROM_STRING;
5187 return 1;
5188 }
5189
5190 it->current.overlay_string_index = -1;
5191 return 0;
5192 }
5193
5194 static int
5195 get_overlay_strings (it, charpos)
5196 struct it *it;
5197 int charpos;
5198 {
5199 it->string = Qnil;
5200 it->method = GET_FROM_BUFFER;
5201
5202 (void) get_overlay_strings_1 (it, charpos, 1);
5203
5204 CHECK_IT (it);
5205
5206
5207 return STRINGP (it->string);
5208 }
5209
5210
5211
5212 5213 5214
5215
5216 5217 5218 5219
5220
5221 static void
5222 push_it (it)
5223 struct it *it;
5224 {
5225 struct iterator_stack_entry *p;
5226
5227 xassert (it->sp < IT_STACK_SIZE);
5228 p = it->stack + it->sp;
5229
5230 p->stop_charpos = it->stop_charpos;
5231 p->prev_stop = it->prev_stop;
5232 p->base_level_stop = it->base_level_stop;
5233 p->cmp_it = it->cmp_it;
5234 xassert (it->face_id >= 0);
5235 p->face_id = it->face_id;
5236 p->string = it->string;
5237 p->method = it->method;
5238 p->from_overlay = it->from_overlay;
5239 switch (p->method)
5240 {
5241 case GET_FROM_IMAGE:
5242 p->u.image.object = it->object;
5243 p->u.image.image_id = it->image_id;
5244 p->u.image.slice = it->slice;
5245 break;
5246 case GET_FROM_STRETCH:
5247 p->u.stretch.object = it->object;
5248 break;
5249 }
5250 p->position = it->position;
5251 p->current = it->current;
5252 p->end_charpos = it->end_charpos;
5253 p->string_nchars = it->string_nchars;
5254 p->area = it->area;
5255 p->multibyte_p = it->multibyte_p;
5256 p->avoid_cursor_p = it->avoid_cursor_p;
5257 p->space_width = it->space_width;
5258 p->font_height = it->font_height;
5259 p->voffset = it->voffset;
5260 p->string_from_display_prop_p = it->string_from_display_prop_p;
5261 p->display_ellipsis_p = 0;
5262 p->line_wrap = it->line_wrap;
5263 ++it->sp;
5264 }
5265
5266 static void
5267 iterate_out_of_display_property (it)
5268 struct it *it;
5269 {
5270 5271 5272
5273 if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
5274 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
5275
5276 while (it->bidi_it.charpos >= BEGV
5277 && it->prev_stop <= it->bidi_it.charpos
5278 && it->bidi_it.charpos < CHARPOS (it->position))
5279 bidi_move_to_visually_next (&it->bidi_it);
5280 5281
5282 if (it->bidi_it.charpos > CHARPOS (it->position))
5283 it->prev_stop = CHARPOS (it->position);
5284 5285
5286 if (it->bidi_it.charpos != CHARPOS (it->position))
5287 {
5288 SET_TEXT_POS (it->position,
5289 it->bidi_it.charpos, it->bidi_it.bytepos);
5290 it->current.pos = it->position;
5291 }
5292 }
5293
5294 5295 5296 5297 5298
5299
5300 static void
5301 pop_it (it)
5302 struct it *it;
5303 {
5304 struct iterator_stack_entry *p;
5305
5306 xassert (it->sp > 0);
5307 --it->sp;
5308 p = it->stack + it->sp;
5309 it->stop_charpos = p->stop_charpos;
5310 it->prev_stop = p->prev_stop;
5311 it->base_level_stop = p->base_level_stop;
5312 it->cmp_it = p->cmp_it;
5313 it->face_id = p->face_id;
5314 it->current = p->current;
5315 it->position = p->position;
5316 it->string = p->string;
5317 it->from_overlay = p->from_overlay;
5318 if (NILP (it->string))
5319 SET_TEXT_POS (it->current.string_pos, -1, -1);
5320 it->method = p->method;
5321 switch (it->method)
5322 {
5323 case GET_FROM_IMAGE:
5324 it->image_id = p->u.image.image_id;
5325 it->object = p->u.image.object;
5326 it->slice = p->u.image.slice;
5327 break;
5328 case GET_FROM_STRETCH:
5329 it->object = p->u.comp.object;
5330 break;
5331 case GET_FROM_BUFFER:
5332 it->object = it->w->buffer;
5333 if (it->bidi_p)
5334 {
5335 5336 5337 5338 5339 5340 5341 5342
5343 iterate_out_of_display_property (it);
5344 }
5345 break;
5346 case GET_FROM_STRING:
5347 it->object = it->string;
5348 break;
5349 case GET_FROM_DISPLAY_VECTOR:
5350 if (it->s)
5351 it->method = GET_FROM_C_STRING;
5352 else if (STRINGP (it->string))
5353 it->method = GET_FROM_STRING;
5354 else
5355 {
5356 it->method = GET_FROM_BUFFER;
5357 it->object = it->w->buffer;
5358 }
5359 }
5360 it->end_charpos = p->end_charpos;
5361 it->string_nchars = p->string_nchars;
5362 it->area = p->area;
5363 it->multibyte_p = p->multibyte_p;
5364 it->avoid_cursor_p = p->avoid_cursor_p;
5365 it->space_width = p->space_width;
5366 it->font_height = p->font_height;
5367 it->voffset = p->voffset;
5368 it->string_from_display_prop_p = p->string_from_display_prop_p;
5369 it->line_wrap = p->line_wrap;
5370 }
5371
5372
5373
5374 5375 5376
5377
5378
5379
5380 static void
5381 back_to_previous_line_start (it)
5382 struct it *it;
5383 {
5384 IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
5385 IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
5386 }
5387
5388
5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405
5406
5407 static int
5408 forward_to_next_line_start (it, skipped_p)
5409 struct it *it;
5410 int *skipped_p;
5411 {
5412 int old_selective, newline_found_p, n;
5413 const int MAX_NEWLINE_DISTANCE = 500;
5414
5415 5416
5417 if (it->what == IT_CHARACTER
5418 && it->c == '\n'
5419 && CHARPOS (it->position) == IT_CHARPOS (*it))
5420 {
5421 set_iterator_to_next (it, 0);
5422 it->c = 0;
5423 return 1;
5424 }
5425
5426 5427 5428 5429
5430 old_selective = it->selective;
5431 it->selective = 0;
5432
5433 5434
5435 for (n = newline_found_p = 0;
5436 !newline_found_p && n < MAX_NEWLINE_DISTANCE;
5437 n += STRINGP (it->string) ? 0 : 1)
5438 {
5439 if (!get_next_display_element (it))
5440 return 0;
5441 newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
5442 set_iterator_to_next (it, 0);
5443 }
5444
5445 5446
5447 if (!newline_found_p)
5448 {
5449 int start = IT_CHARPOS (*it);
5450 int limit = find_next_newline_no_quit (start, 1);
5451 Lisp_Object pos;
5452
5453 xassert (!STRINGP (it->string));
5454
5455 5456 5457
5458 if (it->stop_charpos >= limit
5459 || ((pos = Fnext_single_property_change (make_number (start),
5460 Qdisplay,
5461 Qnil, make_number (limit)),
5462 NILP (pos))
5463 && next_overlay_change (start) == ZV))
5464 {
5465 IT_CHARPOS (*it) = limit;
5466 IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
5467 *skipped_p = newline_found_p = 1;
5468 }
5469 else
5470 {
5471 while (get_next_display_element (it)
5472 && !newline_found_p)
5473 {
5474 newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
5475 set_iterator_to_next (it, 0);
5476 }
5477 }
5478 }
5479
5480 it->selective = old_selective;
5481 return newline_found_p;
5482 }
5483
5484
5485 5486 5487 5488
5489
5490 static void
5491 back_to_previous_visible_line_start (it)
5492 struct it *it;
5493 {
5494 while (IT_CHARPOS (*it) > BEGV)
5495 {
5496 back_to_previous_line_start (it);
5497
5498 if (IT_CHARPOS (*it) <= BEGV)
5499 break;
5500
5501 5502
5503 if (it->selective > 0
5504 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5505 (double) it->selective))
5506 continue;
5507
5508
5509 {
5510 Lisp_Object prop;
5511 prop = Fget_char_property (make_number (IT_CHARPOS (*it) - 1),
5512 Qinvisible, it->window);
5513 if (TEXT_PROP_MEANS_INVISIBLE (prop))
5514 continue;
5515 }
5516
5517 if (IT_CHARPOS (*it) <= BEGV)
5518 break;
5519
5520 {
5521 struct it it2;
5522 int pos;
5523 EMACS_INT beg, end;
5524 Lisp_Object val, overlay;
5525
5526
5527 if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
5528 && beg < IT_CHARPOS (*it))
5529 goto replaced;
5530
5531 5532
5533 it2 = *it;
5534 pos = --IT_CHARPOS (it2);
5535 --IT_BYTEPOS (it2);
5536 it2.sp = 0;
5537 it2.string_from_display_prop_p = 0;
5538 if (handle_display_prop (&it2) == HANDLED_RETURN
5539 && !NILP (val = get_char_property_and_overlay
5540 (make_number (pos), Qdisplay, Qnil, &overlay))
5541 && (OVERLAYP (overlay)
5542 ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
5543 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
5544 goto replaced;
5545
5546
5547 break;
5548
5549 replaced:
5550 if (beg < BEGV)
5551 beg = BEGV;
5552 IT_CHARPOS (*it) = beg;
5553 IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
5554 }
5555 }
5556
5557 it->continuation_lines_width = 0;
5558
5559 xassert (IT_CHARPOS (*it) >= BEGV);
5560 xassert (IT_CHARPOS (*it) == BEGV
5561 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5562 CHECK_IT (it);
5563 }
5564
5565
5566 5567 5568 5569
5570
5571 void
5572 reseat_at_previous_visible_line_start (it)
5573 struct it *it;
5574 {
5575 back_to_previous_visible_line_start (it);
5576 reseat (it, it->current.pos, 1);
5577 CHECK_IT (it);
5578 }
5579
5580
5581 5582 5583 5584 5585 5586
5587
5588 static void
5589 reseat_at_next_visible_line_start (it, on_newline_p)
5590 struct it *it;
5591 int on_newline_p;
5592 {
5593 int newline_found_p, skipped_p = 0;
5594
5595 newline_found_p = forward_to_next_line_start (it, &skipped_p);
5596
5597 5598
5599 if (it->selective > 0)
5600 while (IT_CHARPOS (*it) < ZV
5601 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5602 (double) it->selective))
5603 {
5604 xassert (IT_BYTEPOS (*it) == BEGV
5605 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5606 newline_found_p = forward_to_next_line_start (it, &skipped_p);
5607 }
5608
5609
5610 if (on_newline_p && newline_found_p)
5611 {
5612 if (STRINGP (it->string))
5613 {
5614 if (IT_STRING_CHARPOS (*it) > 0)
5615 {
5616 --IT_STRING_CHARPOS (*it);
5617 --IT_STRING_BYTEPOS (*it);
5618 }
5619 }
5620 else if (IT_CHARPOS (*it) > BEGV)
5621 {
5622 --IT_CHARPOS (*it);
5623 --IT_BYTEPOS (*it);
5624 reseat (it, it->current.pos, 0);
5625 }
5626 }
5627 else if (skipped_p)
5628 reseat (it, it->current.pos, 0);
5629
5630 CHECK_IT (it);
5631 }
5632
5633
5634
5635 5636 5637
5638
5639 5640 5641 5642
5643
5644 static void
5645 reseat (it, pos, force_p)
5646 struct it *it;
5647 struct text_pos pos;
5648 int force_p;
5649 {
5650 int original_pos = IT_CHARPOS (*it);
5651
5652 reseat_1 (it, pos, 0);
5653
5654 5655
5656 if (force_p
5657 || CHARPOS (pos) > it->stop_charpos
5658 || CHARPOS (pos) < original_pos)
5659 {
5660 if (it->bidi_p)
5661 {
5662 5663
5664 if (CHARPOS (pos) < it->prev_stop)
5665 {
5666 handle_stop_backwards (it, BEGV);
5667 if (CHARPOS (pos) < it->base_level_stop)
5668 it->base_level_stop = 0;
5669 }
5670 else if (CHARPOS (pos) > it->stop_charpos
5671 && it->stop_charpos >= BEGV)
5672 handle_stop_backwards (it, it->stop_charpos);
5673 else
5674 handle_stop (it);
5675 }
5676 else
5677 {
5678 handle_stop (it);
5679 it->prev_stop = it->base_level_stop = 0;
5680 }
5681
5682 }
5683
5684 CHECK_IT (it);
5685 }
5686
5687
5688 5689
5690
5691 static void
5692 reseat_1 (it, pos, set_stop_p)
5693 struct it *it;
5694 struct text_pos pos;
5695 int set_stop_p;
5696 {
5697
5698 xassert (it->s == NULL);
5699
5700
5701 xassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
5702
5703 it->current.pos = it->position = pos;
5704 it->end_charpos = ZV;
5705 it->dpvec = NULL;
5706 it->current.dpvec_index = -1;
5707 it->current.overlay_string_index = -1;
5708 IT_STRING_CHARPOS (*it) = -1;
5709 IT_STRING_BYTEPOS (*it) = -1;
5710 it->string = Qnil;
5711 it->string_from_display_prop_p = 0;
5712 it->method = GET_FROM_BUFFER;
5713 it->object = it->w->buffer;
5714 it->area = TEXT_AREA;
5715 it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
5716 it->sp = 0;
5717 it->string_from_display_prop_p = 0;
5718 it->face_before_selective_p = 0;
5719 if (it->bidi_p)
5720 it->bidi_it.first_elt = 1;
5721
5722 if (set_stop_p)
5723 {
5724 it->stop_charpos = CHARPOS (pos);
5725 it->base_level_stop = CHARPOS (pos);
5726 }
5727 }
5728
5729
5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746
5747
5748 static void
5749 reseat_to_string (it, s, string, charpos, precision, field_width, multibyte)
5750 struct it *it;
5751 unsigned char *s;
5752 Lisp_Object string;
5753 int charpos;
5754 int precision, field_width, multibyte;
5755 {
5756
5757 it->region_beg_charpos = it->region_end_charpos = -1;
5758
5759
5760 it->stop_charpos = -1;
5761
5762
5763 bzero (&it->current, sizeof it->current);
5764 it->current.overlay_string_index = -1;
5765 it->current.dpvec_index = -1;
5766 xassert (charpos >= 0);
5767
5768 5769
5770 if (multibyte >= 0)
5771 it->multibyte_p = multibyte > 0;
5772
5773 if (s == NULL)
5774 {
5775 xassert (STRINGP (string));
5776 it->string = string;
5777 it->s = NULL;
5778 it->end_charpos = it->string_nchars = SCHARS (string);
5779 it->method = GET_FROM_STRING;
5780 it->current.string_pos = string_pos (charpos, string);
5781 }
5782 else
5783 {
5784 it->s = s;
5785 it->string = Qnil;
5786
5787 5788
5789 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
5790 if (it->multibyte_p)
5791 {
5792 it->current.pos = c_string_pos (charpos, s, 1);
5793 it->end_charpos = it->string_nchars = number_of_chars (s, 1);
5794 }
5795 else
5796 {
5797 IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
5798 it->end_charpos = it->string_nchars = strlen (s);
5799 }
5800
5801 it->method = GET_FROM_C_STRING;
5802 }
5803
5804 5805
5806 if (precision > 0 && it->end_charpos - charpos > precision)
5807 it->end_charpos = it->string_nchars = charpos + precision;
5808
5809 5810 5811 5812
5813 if (field_width < 0)
5814 field_width = INFINITY;
5815 if (field_width > it->end_charpos - charpos)
5816 it->end_charpos = charpos + field_width;
5817
5818
5819 if (DISP_TABLE_P (Vstandard_display_table))
5820 it->dp = XCHAR_TABLE (Vstandard_display_table);
5821
5822 it->stop_charpos = charpos;
5823 if (s == NULL && it->multibyte_p)
5824 {
5825 EMACS_INT endpos = SCHARS (it->string);
5826 if (endpos > it->end_charpos)
5827 endpos = it->end_charpos;
5828 composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
5829 it->string);
5830 }
5831 CHECK_IT (it);
5832 }
5833
5834
5835
5836 5837 5838
5839
5840
5841
5842 static int (* get_next_element[NUM_IT_METHODS]) P_ ((struct it *it)) =
5843 {
5844 next_element_from_buffer,
5845 next_element_from_display_vector,
5846 next_element_from_string,
5847 next_element_from_c_string,
5848 next_element_from_image,
5849 next_element_from_stretch
5850 };
5851
5852 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
5853
5854
5855 5856
5857
5858 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
5859 ((IT)->cmp_it.id >= 0 \
5860 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
5861 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
5862 END_CHARPOS, (IT)->w, \
5863 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
5864 (IT)->string)))
5865
5866
5867 5868 5869
5870
5871 static struct frame *last_escape_glyph_frame = NULL;
5872 static unsigned last_escape_glyph_face_id = (1 << FACE_ID_BITS);
5873 static int last_escape_glyph_merged_face_id = 0;
5874
5875 int
5876 get_next_display_element (it)
5877 struct it *it;
5878 {
5879 5880 5881 5882
5883 int success_p;
5884
5885 get_next:
5886 success_p = GET_NEXT_DISPLAY_ELEMENT (it);
5887
5888 if (it->what == IT_CHARACTER)
5889 {
5890 5891 5892
5893 5894
5895 if (it->bidi_p && it->bidi_it.type == STRONG_R)
5896 it->c = bidi_mirror_char (it->c);
5897 5898 5899 5900 5901 5902 5903 5904 5905
5906 if (success_p && it->dpvec == NULL)
5907 {
5908 Lisp_Object dv;
5909 struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
5910 enum { char_is_other = 0, char_is_nbsp, char_is_soft_hyphen }
5911 nbsp_or_shy = char_is_other;
5912 int decoded = it->c;
5913
5914 if (it->dp
5915 && (dv = DISP_CHAR_VECTOR (it->dp, it->c),
5916 VECTORP (dv)))
5917 {
5918 struct Lisp_Vector *v = XVECTOR (dv);
5919
5920 5921 5922
5923 if (v->size)
5924 {
5925 it->dpvec_char_len = it->len;
5926 it->dpvec = v->contents;
5927 it->dpend = v->contents + v->size;
5928 it->current.dpvec_index = 0;
5929 it->dpvec_face_id = -1;
5930 it->saved_face_id = it->face_id;
5931 it->method = GET_FROM_DISPLAY_VECTOR;
5932 it->ellipsis_p = 0;
5933 }
5934 else
5935 {
5936 set_iterator_to_next (it, 0);
5937 }
5938 goto get_next;
5939 }
5940
5941 if (unibyte_display_via_language_environment
5942 && !ASCII_CHAR_P (it->c))
5943 decoded = DECODE_CHAR (unibyte, it->c);
5944
5945 if (it->c >= 0x80 && ! NILP (Vnobreak_char_display))
5946 {
5947 if (it->multibyte_p)
5948 nbsp_or_shy = (it->c == 0xA0 ? char_is_nbsp
5949 : it->c == 0xAD ? char_is_soft_hyphen
5950 : char_is_other);
5951 else if (unibyte_display_via_language_environment)
5952 nbsp_or_shy = (decoded == 0xA0 ? char_is_nbsp
5953 : decoded == 0xAD ? char_is_soft_hyphen
5954 : char_is_other);
5955 }
5956
5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968
5969 if ((it->c < ' '
5970 ? (it->area != TEXT_AREA
5971
5972 || (it->c != '\t'
5973 && it->glyph_row
5974 && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
5975 || (it->c != '\n' && it->c != '\t'))
5976 : (nbsp_or_shy
5977 || (it->multibyte_p
5978 ? ! CHAR_PRINTABLE_P (it->c)
5979 : (! unibyte_display_via_language_environment
5980 ? it->c >= 0x80
5981 : (decoded >= 0x80 && decoded < 0xA0))))))
5982 {
5983 5984 5985 5986 5987
5988 Lisp_Object gc;
5989 int ctl_len;
5990 int face_id, lface_id = 0 ;
5991 int escape_glyph;
5992
5993
5994
5995 if (it->c < 128 && it->ctl_arrow_p)
5996 {
5997 int g;
5998
5999 g = '^';
6000
6001 if (it->dp
6002 && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc))
6003 && GLYPH_CODE_CHAR_VALID_P (gc))
6004 {
6005 g = GLYPH_CODE_CHAR (gc);
6006 lface_id = GLYPH_CODE_FACE (gc);
6007 }
6008 if (lface_id)
6009 {
6010 face_id = merge_faces (it->f, Qt, lface_id, it->face_id);
6011 }
6012 else if (it->f == last_escape_glyph_frame
6013 && it->face_id == last_escape_glyph_face_id)
6014 {
6015 face_id = last_escape_glyph_merged_face_id;
6016 }
6017 else
6018 {
6019
6020 face_id = merge_faces (it->f, Qescape_glyph, 0,
6021 it->face_id);
6022 last_escape_glyph_frame = it->f;
6023 last_escape_glyph_face_id = it->face_id;
6024 last_escape_glyph_merged_face_id = face_id;
6025 }
6026
6027 XSETINT (it->ctl_chars[0], g);
6028 XSETINT (it->ctl_chars[1], it->c ^ 0100);
6029 ctl_len = 2;
6030 goto display_control;
6031 }
6032
6033 6034
6035
6036 if (EQ (Vnobreak_char_display, Qt)
6037 && nbsp_or_shy == char_is_nbsp)
6038 {
6039
6040 face_id = merge_faces (it->f, Qnobreak_space, 0,
6041 it->face_id);
6042
6043 it->c = ' ';
6044 XSETINT (it->ctl_chars[0], ' ');
6045 ctl_len = 1;
6046 goto display_control;
6047 }
6048
6049
6050
6051
6052 escape_glyph = '\\';
6053
6054 if (it->dp
6055 && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc))
6056 && GLYPH_CODE_CHAR_VALID_P (gc))
6057 {
6058 escape_glyph = GLYPH_CODE_CHAR (gc);
6059 lface_id = GLYPH_CODE_FACE (gc);
6060 }
6061 if (lface_id)
6062 {
6063 6064
6065 face_id = merge_faces (it->f, Qt, lface_id,
6066 it->face_id);
6067 }
6068 else if (it->f == last_escape_glyph_frame
6069 && it->face_id == last_escape_glyph_face_id)
6070 {
6071 face_id = last_escape_glyph_merged_face_id;
6072 }
6073 else
6074 {
6075
6076 face_id = merge_faces (it->f, Qescape_glyph, 0,
6077 it->face_id);
6078 last_escape_glyph_frame = it->f;
6079 last_escape_glyph_face_id = it->face_id;
6080 last_escape_glyph_merged_face_id = face_id;
6081 }
6082
6083 6084
6085
6086 if (EQ (Vnobreak_char_display, Qt)
6087 && nbsp_or_shy == char_is_soft_hyphen)
6088 {
6089 it->c = '-';
6090 XSETINT (it->ctl_chars[0], '-');
6091 ctl_len = 1;
6092 goto display_control;
6093 }
6094
6095 6096
6097
6098 if (nbsp_or_shy)
6099 {
6100 XSETINT (it->ctl_chars[0], escape_glyph);
6101 it->c = (nbsp_or_shy == char_is_nbsp ? ' ' : '-');
6102 XSETINT (it->ctl_chars[1], it->c);
6103 ctl_len = 2;
6104 goto display_control;
6105 }
6106
6107 {
6108 unsigned char str[MAX_MULTIBYTE_LENGTH];
6109 int len;
6110 int i;
6111
6112
6113 if (CHAR_BYTE8_P (it->c))
6114 {
6115 str[0] = CHAR_TO_BYTE8 (it->c);
6116 len = 1;
6117 }
6118 else if (it->c < 256)
6119 {
6120 str[0] = it->c;
6121 len = 1;
6122 }
6123 else
6124 {
6125 6126 6127 6128
6129 str[0] = it->c;
6130 str[1] = it->c >> 8;
6131 str[2] = it->c >> 16;
6132 str[3] = it->c >> 24;
6133 len = 4;
6134 }
6135
6136 for (i = 0; i < len; i++)
6137 {
6138 int g;
6139 XSETINT (it->ctl_chars[i * 4], escape_glyph);
6140 6141
6142 g = ((str[i] >> 6) & 7) + '0';
6143 XSETINT (it->ctl_chars[i * 4 + 1], g);
6144 g = ((str[i] >> 3) & 7) + '0';
6145 XSETINT (it->ctl_chars[i * 4 + 2], g);
6146 g = (str[i] & 7) + '0';
6147 XSETINT (it->ctl_chars[i * 4 + 3], g);
6148 }
6149 ctl_len = len * 4;
6150 }
6151
6152 display_control:
6153
6154 it->dpvec_char_len = it->len;
6155 it->dpvec = it->ctl_chars;
6156 it->dpend = it->dpvec + ctl_len;
6157 it->current.dpvec_index = 0;
6158 it->dpvec_face_id = face_id;
6159 it->saved_face_id = it->face_id;
6160 it->method = GET_FROM_DISPLAY_VECTOR;
6161 it->ellipsis_p = 0;
6162 goto get_next;
6163 }
6164 }
6165 }
6166
6167 #ifdef HAVE_WINDOW_SYSTEM
6168 6169
6170 if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
6171 && it->multibyte_p
6172 && success_p
6173 && FRAME_WINDOW_P (it->f))
6174 {
6175 struct face *face = FACE_FROM_ID (it->f, it->face_id);
6176
6177 if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
6178 {
6179
6180 Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
6181
6182 it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
6183 }
6184 else
6185 {
6186 int pos = (it->s ? -1
6187 : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
6188 : IT_CHARPOS (*it));
6189
6190 it->face_id = FACE_FOR_CHAR (it->f, face, it->c, pos, it->string);
6191 }
6192 }
6193 #endif
6194
6195 6196
6197 if (it->face_box_p
6198 && it->s == NULL)
6199 {
6200 if (it->method == GET_FROM_STRING && it->sp)
6201 {
6202 int face_id = underlying_face_id (it);
6203 struct face *face = FACE_FROM_ID (it->f, face_id);
6204
6205 if (face)
6206 {
6207 if (face->box == FACE_NO_BOX)
6208 {
6209 6210
6211 int string_face_id = face_after_it_pos (it);
6212 it->end_of_box_run_p
6213 = (FACE_FROM_ID (it->f, string_face_id)->box
6214 == FACE_NO_BOX);
6215 }
6216 6217 6218
6219 else if ((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
6220 && (it->current.overlay_string_index
6221 == it->n_overlay_strings - 1))
6222 {
6223 EMACS_INT ignore;
6224 int next_face_id;
6225 struct text_pos pos = it->current.pos;
6226 INC_TEXT_POS (pos, it->multibyte_p);
6227
6228 next_face_id = face_at_buffer_position
6229 (it->w, CHARPOS (pos), it->region_beg_charpos,
6230 it->region_end_charpos, &ignore,
6231 (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT), 0,
6232 -1);
6233 it->end_of_box_run_p
6234 = (FACE_FROM_ID (it->f, next_face_id)->box
6235 == FACE_NO_BOX);
6236 }
6237 }
6238 }
6239 else
6240 {
6241 int face_id = face_after_it_pos (it);
6242 it->end_of_box_run_p
6243 = (face_id != it->face_id
6244 && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX);
6245 }
6246 }
6247
6248
6249 return success_p;
6250 }
6251
6252
6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266
6267
6268 void
6269 set_iterator_to_next (it, reseat_p)
6270 struct it *it;
6271 int reseat_p;
6272 {
6273 6274 6275
6276 it->start_of_box_run_p = it->end_of_box_run_p = 0;
6277
6278 switch (it->method)
6279 {
6280 case GET_FROM_BUFFER:
6281 6282 6283
6284 if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
6285 reseat_at_next_visible_line_start (it, 0);
6286 else if (it->cmp_it.id >= 0)
6287 {
6288
6289 int i;
6290
6291 if (! it->bidi_p)
6292 {
6293 IT_CHARPOS (*it) += it->cmp_it.nchars;
6294 IT_BYTEPOS (*it) += it->cmp_it.nbytes;
6295 if (it->cmp_it.to < it->cmp_it.nglyphs)
6296 {
6297 it->cmp_it.from = it->cmp_it.to;
6298 }
6299 else
6300 {
6301 it->cmp_it.id = -1;
6302 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6303 IT_BYTEPOS (*it),
6304 it->stop_charpos, Qnil);
6305 }
6306 }
6307 else if (! it->cmp_it.reversed_p)
6308 {
6309
6310 6311 6312
6313 for (i = 0; i < it->cmp_it.nchars; i++)
6314 bidi_move_to_visually_next (&it->bidi_it);
6315 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6316 IT_CHARPOS (*it) = it->bidi_it.charpos;
6317
6318 if (it->cmp_it.to < it->cmp_it.nglyphs)
6319 {
6320
6321 it->cmp_it.from = it->cmp_it.to;
6322 }
6323 else
6324 {
6325 6326
6327 EMACS_INT stop = it->stop_charpos;
6328 if (it->bidi_it.scan_dir < 0)
6329 6330
6331 stop = -1;
6332 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6333 IT_BYTEPOS (*it), stop, Qnil);
6334 }
6335 }
6336 else
6337 {
6338
6339 6340 6341
6342 for (i = 0; i < it->cmp_it.nchars; i++)
6343 bidi_move_to_visually_next (&it->bidi_it);
6344 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6345 IT_CHARPOS (*it) = it->bidi_it.charpos;
6346 if (it->cmp_it.from > 0)
6347 {
6348
6349 it->cmp_it.to = it->cmp_it.from;
6350 }
6351 else
6352 {
6353 6354
6355 EMACS_INT stop = it->stop_charpos;
6356 if (it->bidi_it.scan_dir < 0)
6357 6358
6359 stop = -1;
6360 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6361 IT_BYTEPOS (*it), stop, Qnil);
6362 }
6363 }
6364 }
6365 else
6366 {
6367 xassert (it->len != 0);
6368
6369 if (!it->bidi_p)
6370 {
6371 IT_BYTEPOS (*it) += it->len;
6372 IT_CHARPOS (*it) += 1;
6373 }
6374 else
6375 {
6376 int prev_scan_dir = it->bidi_it.scan_dir;
6377 6378
6379 if (it->bidi_it.new_paragraph)
6380 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
6381 bidi_move_to_visually_next (&it->bidi_it);
6382 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6383 IT_CHARPOS (*it) = it->bidi_it.charpos;
6384 if (prev_scan_dir != it->bidi_it.scan_dir)
6385 {
6386 6387
6388 EMACS_INT stop = it->stop_charpos;
6389 if (it->bidi_it.scan_dir < 0)
6390 stop = -1;
6391 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6392 IT_BYTEPOS (*it), stop, Qnil);
6393 }
6394 }
6395 xassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
6396 }
6397 break;
6398
6399 case GET_FROM_C_STRING:
6400
6401 IT_BYTEPOS (*it) += it->len;
6402 IT_CHARPOS (*it) += 1;
6403 break;
6404
6405 case GET_FROM_DISPLAY_VECTOR:
6406 6407 6408 6409
6410 ++it->current.dpvec_index;
6411
6412 6413
6414 it->face_id = it->saved_face_id;
6415
6416 if (it->dpvec + it->current.dpvec_index == it->dpend)
6417 {
6418 int recheck_faces = it->ellipsis_p;
6419
6420 if (it->s)
6421 it->method = GET_FROM_C_STRING;
6422 else if (STRINGP (it->string))
6423 it->method = GET_FROM_STRING;
6424 else
6425 {
6426 it->method = GET_FROM_BUFFER;
6427 it->object = it->w->buffer;
6428 }
6429
6430 it->dpvec = NULL;
6431 it->current.dpvec_index = -1;
6432
6433
6434 if (it->dpvec_char_len < 0)
6435 reseat_at_next_visible_line_start (it, 1);
6436 else if (it->dpvec_char_len > 0)
6437 {
6438 if (it->method == GET_FROM_STRING
6439 && it->n_overlay_strings > 0)
6440 it->ignore_overlay_strings_at_pos_p = 1;
6441 it->len = it->dpvec_char_len;
6442 set_iterator_to_next (it, reseat_p);
6443 }
6444
6445
6446 if (recheck_faces)
6447 it->stop_charpos = IT_CHARPOS (*it);
6448 }
6449 break;
6450
6451 case GET_FROM_STRING:
6452
6453 xassert (it->s == NULL && STRINGP (it->string));
6454 if (it->cmp_it.id >= 0)
6455 {
6456 IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
6457 IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
6458 if (it->cmp_it.to < it->cmp_it.nglyphs)
6459 it->cmp_it.from = it->cmp_it.to;
6460 else
6461 {
6462 it->cmp_it.id = -1;
6463 composition_compute_stop_pos (&it->cmp_it,
6464 IT_STRING_CHARPOS (*it),
6465 IT_STRING_BYTEPOS (*it),
6466 it->stop_charpos, it->string);
6467 }
6468 }
6469 else
6470 {
6471 IT_STRING_BYTEPOS (*it) += it->len;
6472 IT_STRING_CHARPOS (*it) += 1;
6473 }
6474
6475 consider_string_end:
6476
6477 if (it->current.overlay_string_index >= 0)
6478 {
6479 6480
6481 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
6482 {
6483 it->ellipsis_p = 0;
6484 next_overlay_string (it);
6485 if (it->ellipsis_p)
6486 setup_for_ellipsis (it, 0);
6487 }
6488 }
6489 else
6490 {
6491 6492 6493 6494
6495 if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
6496 && it->sp > 0)
6497 {
6498 pop_it (it);
6499 if (it->method == GET_FROM_STRING)
6500 goto consider_string_end;
6501 }
6502 }
6503 break;
6504
6505 case GET_FROM_IMAGE:
6506 case GET_FROM_STRETCH:
6507 6508 6509
6510 xassert (it->sp > 0);
6511 pop_it (it);
6512 if (it->method == GET_FROM_STRING)
6513 goto consider_string_end;
6514 break;
6515
6516 default:
6517
6518 abort ();
6519 }
6520
6521 xassert (it->method != GET_FROM_STRING
6522 || (STRINGP (it->string)
6523 && IT_STRING_CHARPOS (*it) >= 0));
6524 }
6525
6526 6527 6528 6529 6530 6531 6532 6533
6534
6535 static int
6536 next_element_from_display_vector (it)
6537 struct it *it;
6538 {
6539 Lisp_Object gc;
6540
6541
6542 xassert (it->dpvec && it->current.dpvec_index >= 0);
6543
6544 it->face_id = it->saved_face_id;
6545
6546 6547
6548 gc = it->dpvec[it->current.dpvec_index];
6549
6550 if (GLYPH_CODE_P (gc) && GLYPH_CODE_CHAR_VALID_P (gc))
6551 {
6552 it->c = GLYPH_CODE_CHAR (gc);
6553 it->len = CHAR_BYTES (it->c);
6554
6555 6556 6557
6558 if (it->dpvec_face_id >= 0)
6559 it->face_id = it->dpvec_face_id;
6560 else
6561 {
6562 int lface_id = GLYPH_CODE_FACE (gc);
6563 if (lface_id > 0)
6564 it->face_id = merge_faces (it->f, Qt, lface_id,
6565 it->saved_face_id);
6566 }
6567 }
6568 else
6569
6570 it->c = ' ', it->len = 1;
6571
6572 6573 6574
6575 it->what = IT_CHARACTER;
6576 return 1;
6577 }
6578
6579
6580 6581 6582 6583
6584
6585 static int
6586 next_element_from_string (it)
6587 struct it *it;
6588 {
6589 struct text_pos position;
6590
6591 xassert (STRINGP (it->string));
6592 xassert (IT_STRING_CHARPOS (*it) >= 0);
6593 position = it->current.string_pos;
6594
6595
6596 if (IT_STRING_CHARPOS (*it) < it->end_charpos
6597 && IT_STRING_CHARPOS (*it) == it->stop_charpos)
6598 {
6599 handle_stop (it);
6600
6601 6602
6603 return GET_NEXT_DISPLAY_ELEMENT (it);
6604 }
6605
6606 if (it->current.overlay_string_index >= 0)
6607 {
6608 6609 6610
6611 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
6612 {
6613 it->what = IT_EOB;
6614 return 0;
6615 }
6616 else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
6617 IT_STRING_BYTEPOS (*it), SCHARS (it->string))
6618 && next_element_from_composition (it))
6619 {
6620 return 1;
6621 }
6622 else if (STRING_MULTIBYTE (it->string))
6623 {
6624 int remaining = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
6625 const unsigned char *s = (SDATA (it->string)
6626 + IT_STRING_BYTEPOS (*it));
6627 it->c = string_char_and_length (s, &it->len);
6628 }
6629 else
6630 {
6631 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
6632 it->len = 1;
6633 }
6634 }
6635 else
6636 {
6637 6638 6639 6640
6641 if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
6642 {
6643 it->what = IT_EOB;
6644 return 0;
6645 }
6646 else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
6647 {
6648
6649 it->c = ' ', it->len = 1;
6650 CHARPOS (position) = BYTEPOS (position) = -1;
6651 }
6652 else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
6653 IT_STRING_BYTEPOS (*it), it->string_nchars)
6654 && next_element_from_composition (it))
6655 {
6656 return 1;
6657 }
6658 else if (STRING_MULTIBYTE (it->string))
6659 {
6660 int maxlen = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
6661 const unsigned char *s = (SDATA (it->string)
6662 + IT_STRING_BYTEPOS (*it));
6663 it->c = string_char_and_length (s, &it->len);
6664 }
6665 else
6666 {
6667 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
6668 it->len = 1;
6669 }
6670 }
6671
6672
6673 it->what = IT_CHARACTER;
6674 it->object = it->string;
6675 it->position = position;
6676 return 1;
6677 }
6678
6679
6680 6681 6682 6683 6684 6685
6686
6687 static int
6688 next_element_from_c_string (it)
6689 struct it *it;
6690 {
6691 int success_p = 1;
6692
6693 xassert (it->s);
6694 it->what = IT_CHARACTER;
6695 BYTEPOS (it->position) = CHARPOS (it->position) = 0;
6696 it->object = Qnil;
6697
6698 6699 6700
6701 if (IT_CHARPOS (*it) >= it->end_charpos)
6702 {
6703
6704 it->what = IT_EOB;
6705 success_p = 0;
6706 }
6707 else if (IT_CHARPOS (*it) >= it->string_nchars)
6708 {
6709
6710 it->c = ' ', it->len = 1;
6711 BYTEPOS (it->position) = CHARPOS (it->position) = -1;
6712 }
6713 else if (it->multibyte_p)
6714 {
6715 6716 6717
6718 int maxlen = strlen (it->s) - IT_BYTEPOS (*it);
6719 it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
6720 }
6721 else
6722 it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
6723
6724 return success_p;
6725 }
6726
6727
6728 6729 6730 6731
6732
6733 static int
6734 next_element_from_ellipsis (it)
6735 struct it *it;
6736 {
6737 if (it->selective_display_ellipsis_p)
6738 setup_for_ellipsis (it, it->len);
6739 else
6740 {
6741 6742 6743 6744
6745 it->saved_face_id = it->face_id;
6746 it->method = GET_FROM_BUFFER;
6747 it->object = it->w->buffer;
6748 reseat_at_next_visible_line_start (it, 1);
6749 it->face_before_selective_p = 1;
6750 }
6751
6752 return GET_NEXT_DISPLAY_ELEMENT (it);
6753 }
6754
6755
6756 6757 6758
6759
6760
6761 static int
6762 next_element_from_image (it)
6763 struct it *it;
6764 {
6765 it->what = IT_IMAGE;
6766 return 1;
6767 }
6768
6769
6770 6771 6772
6773
6774 static int
6775 next_element_from_stretch (it)
6776 struct it *it;
6777 {
6778 it->what = IT_STRETCH;
6779 return 1;
6780 }
6781
6782 6783 6784 6785 6786 6787 6788
6789
6790 static void
6791 handle_stop_backwards (it, charpos)
6792 struct it *it;
6793 EMACS_INT charpos;
6794 {
6795 EMACS_INT where_we_are = IT_CHARPOS (*it);
6796 struct display_pos save_current = it->current;
6797 struct text_pos save_position = it->position;
6798 struct text_pos pos1;
6799 EMACS_INT next_stop;
6800
6801
6802 it->bidi_p = 0;
6803 do
6804 {
6805 it->prev_stop = charpos;
6806 SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
6807 reseat_1 (it, pos1, 0);
6808 compute_stop_pos (it);
6809
6810 if (it->stop_charpos <= it->prev_stop)
6811 abort ();
6812 charpos = it->stop_charpos;
6813 }
6814 while (charpos <= where_we_are);
6815
6816 next_stop = it->stop_charpos;
6817 it->stop_charpos = it->prev_stop;
6818 it->bidi_p = 1;
6819 it->current = save_current;
6820 it->position = save_position;
6821 handle_stop (it);
6822 it->stop_charpos = next_stop;
6823 }
6824
6825 6826 6827 6828
6829
6830 static int
6831 next_element_from_buffer (it)
6832 struct it *it;
6833 {
6834 int success_p = 1;
6835
6836 xassert (IT_CHARPOS (*it) >= BEGV);
6837
6838 6839 6840 6841
6842 if (it->bidi_p && it->bidi_it.first_elt)
6843 {
6844 it->bidi_it.charpos = IT_CHARPOS (*it);
6845 it->bidi_it.bytepos = IT_BYTEPOS (*it);
6846 if (it->bidi_it.bytepos == ZV_BYTE)
6847 {
6848 6849 6850
6851 it->bidi_it.first_elt = 0;
6852 }
6853 else if (it->bidi_it.bytepos == BEGV_BYTE
6854
6855 || FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
6856 || FETCH_CHAR (it->bidi_it.bytepos) == '\n')
6857 {
6858 6859
6860 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
6861 bidi_move_to_visually_next (&it->bidi_it);
6862 }
6863 else
6864 {
6865 int orig_bytepos = IT_BYTEPOS (*it);
6866
6867 6868 6869
6870 IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it), -1);
6871 IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
6872 it->bidi_it.charpos = IT_CHARPOS (*it);
6873 it->bidi_it.bytepos = IT_BYTEPOS (*it);
6874 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
6875 do
6876 {
6877 6878
6879 bidi_move_to_visually_next (&it->bidi_it);
6880 }
6881 while (it->bidi_it.bytepos != orig_bytepos
6882 && it->bidi_it.bytepos < ZV_BYTE);
6883 }
6884
6885 it->bidi_it.first_elt = 0;
6886
6887 IT_CHARPOS (*it) = it->bidi_it.charpos;
6888 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6889 SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
6890 {
6891 EMACS_INT stop = it->stop_charpos;
6892 if (it->bidi_it.scan_dir < 0)
6893 stop = -1;
6894 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6895 IT_BYTEPOS (*it), stop, Qnil);
6896 }
6897 }
6898
6899 if (IT_CHARPOS (*it) >= it->stop_charpos)
6900 {
6901 if (IT_CHARPOS (*it) >= it->end_charpos)
6902 {
6903 int overlay_strings_follow_p;
6904
6905 6906
6907 if (it->overlay_strings_at_end_processed_p)
6908 overlay_strings_follow_p = 0;
6909 else
6910 {
6911 it->overlay_strings_at_end_processed_p = 1;
6912 overlay_strings_follow_p = get_overlay_strings (it, 0);
6913 }
6914
6915 if (overlay_strings_follow_p)
6916 success_p = GET_NEXT_DISPLAY_ELEMENT (it);
6917 else
6918 {
6919 it->what = IT_EOB;
6920 it->position = it->current.pos;
6921 success_p = 0;
6922 }
6923 }
6924 else if (!(!it->bidi_p
6925 || BIDI_AT_BASE_LEVEL (it->bidi_it)
6926 || IT_CHARPOS (*it) == it->stop_charpos))
6927 {
6928 6929 6930 6931 6932 6933
6934 handle_stop_backwards (it, it->stop_charpos);
6935 return GET_NEXT_DISPLAY_ELEMENT (it);
6936 }
6937 else
6938 {
6939 if (it->bidi_p)
6940 {
6941 6942
6943 it->prev_stop = it->stop_charpos;
6944 6945 6946
6947 if (BIDI_AT_BASE_LEVEL (it->bidi_it))
6948 it->base_level_stop = it->stop_charpos;
6949 }
6950 handle_stop (it);
6951 return GET_NEXT_DISPLAY_ELEMENT (it);
6952 }
6953 }
6954 else if (it->bidi_p
6955 6956 6957 6958
6959 && !BIDI_AT_BASE_LEVEL (it->bidi_it)
6960 && IT_CHARPOS (*it) < it->prev_stop)
6961 {
6962 if (it->base_level_stop <= 0)
6963 it->base_level_stop = BEGV;
6964 if (IT_CHARPOS (*it) < it->base_level_stop)
6965 abort ();
6966 handle_stop_backwards (it, it->base_level_stop);
6967 return GET_NEXT_DISPLAY_ELEMENT (it);
6968 }
6969 else
6970 {
6971 6972
6973 unsigned char *p;
6974 EMACS_INT stop;
6975
6976 6977
6978 if (it->redisplay_end_trigger_charpos
6979 && it->glyph_row
6980 && IT_CHARPOS (*it) >= it->redisplay_end_trigger_charpos)
6981 run_redisplay_end_trigger_hook (it);
6982
6983 stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
6984 if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
6985 stop)
6986 && next_element_from_composition (it))
6987 {
6988 return 1;
6989 }
6990
6991
6992 p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
6993 if (it->multibyte_p && !ASCII_BYTE_P (*p))
6994 it->c = STRING_CHAR_AND_LENGTH (p, it->len);
6995 else
6996 it->c = *p, it->len = 1;
6997
6998
6999 it->what = IT_CHARACTER;
7000 it->object = it->w->buffer;
7001 it->position = it->current.pos;
7002
7003 7004
7005 if (it->selective)
7006 {
7007 if (it->c == '\n')
7008 {
7009 7010
7011 if (it->selective > 0
7012 && IT_CHARPOS (*it) + 1 < ZV
7013 && indented_beyond_p (IT_CHARPOS (*it) + 1,
7014 IT_BYTEPOS (*it) + 1,
7015 (double) it->selective))
7016 {
7017 success_p = next_element_from_ellipsis (it);
7018 it->dpvec_char_len = -1;
7019 }
7020 }
7021 else if (it->c == '\r' && it->selective == -1)
7022 {
7023 7024 7025
7026 success_p = next_element_from_ellipsis (it);
7027 it->dpvec_char_len = -1;
7028 }
7029 }
7030 }
7031
7032
7033 xassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
7034 return success_p;
7035 }
7036
7037
7038
7039
7040 static void
7041 run_redisplay_end_trigger_hook (it)
7042 struct it *it;
7043 {
7044 Lisp_Object args[3];
7045
7046 7047
7048 xassert (it->glyph_row);
7049
7050
7051 args[0] = Qredisplay_end_trigger_functions;
7052 args[1] = it->window;
7053 XSETINT (args[2], it->redisplay_end_trigger_charpos);
7054 it->redisplay_end_trigger_charpos = 0;
7055
7056 7057
7058 it->w->redisplay_end_trigger = Qnil;
7059 Frun_hook_with_args (3, args);
7060
7061
7062 handle_face_prop (it);
7063 }
7064
7065
7066 7067 7068 7069
7070
7071 static int
7072 next_element_from_composition (it)
7073 struct it *it;
7074 {
7075 it->what = IT_COMPOSITION;
7076 it->len = it->cmp_it.nbytes;
7077 if (STRINGP (it->string))
7078 {
7079 if (it->c < 0)
7080 {
7081 IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
7082 IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
7083 return 0;
7084 }
7085 it->position = it->current.string_pos;
7086 it->object = it->string;
7087 it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
7088 IT_STRING_BYTEPOS (*it), it->string);
7089 }
7090 else
7091 {
7092 if (it->c < 0)
7093 {
7094 IT_CHARPOS (*it) += it->cmp_it.nchars;
7095 IT_BYTEPOS (*it) += it->cmp_it.nbytes;
7096 if (it->bidi_p)
7097 {
7098 if (it->bidi_it.new_paragraph)
7099 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
7100 7101
7102 while (it->bidi_it.charpos < IT_CHARPOS (*it))
7103 bidi_move_to_visually_next (&it->bidi_it);
7104 }
7105 return 0;
7106 }
7107 it->position = it->current.pos;
7108 it->object = it->w->buffer;
7109 it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
7110 IT_BYTEPOS (*it), Qnil);
7111 }
7112 return 1;
7113 }
7114
7115
7116
7117 7118 7119
7120
7121 7122
7123
7124 #define IT_POS_VALID_AFTER_MOVE_P(it) \
7125 ((it)->method == GET_FROM_STRING \
7126 ? IT_STRING_CHARPOS (*it) == 0 \
7127 : 1)
7128
7129
7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161
7162
7163 static enum move_it_result
7164 move_it_in_display_line_to (struct it *it,
7165 EMACS_INT to_charpos, int to_x,
7166 enum move_operation_enum op)
7167 {
7168 enum move_it_result result = MOVE_UNDEFINED;
7169 struct glyph_row *saved_glyph_row;
7170 struct it wrap_it, atpos_it, atx_it;
7171 int may_wrap = 0;
7172 enum it_method prev_method = it->method;
7173 EMACS_INT prev_pos = IT_CHARPOS (*it);
7174
7175
7176 saved_glyph_row = it->glyph_row;
7177 it->glyph_row = NULL;
7178
7179 7180 7181 7182 7183
7184 wrap_it.sp = -1;
7185 atpos_it.sp = -1;
7186 atx_it.sp = -1;
7187
7188 #define BUFFER_POS_REACHED_P() \
7189 ((op & MOVE_TO_POS) != 0 \
7190 && BUFFERP (it->object) \
7191 && (IT_CHARPOS (*it) == to_charpos \
7192 || (!it->bidi_p && IT_CHARPOS (*it) > to_charpos)) \
7193 && (it->method == GET_FROM_BUFFER \
7194 || (it->method == GET_FROM_DISPLAY_VECTOR \
7195 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
7196
7197
7198 if (it->hpos == 0 && it->method == GET_FROM_BUFFER
7199 && it->current_y < it->last_visible_y)
7200 handle_line_prefix (it);
7201
7202 while (1)
7203 {
7204 int x, i, ascent = 0, descent = 0;
7205
7206
7207 #define IT_RESET_X_ASCENT_DESCENT(IT) \
7208 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
7209 (IT)->max_descent = descent)
7210
7211 7212
7213 if ((op & MOVE_TO_POS) != 0
7214 && BUFFERP (it->object)
7215 && it->method == GET_FROM_BUFFER
7216 && ((!it->bidi_p && IT_CHARPOS (*it) > to_charpos)
7217 || (it->bidi_p
7218 && (prev_method == GET_FROM_IMAGE
7219 || prev_method == GET_FROM_STRETCH)
7220
7221 && ((prev_pos < to_charpos
7222 && IT_CHARPOS (*it) > to_charpos)
7223
7224 || (prev_pos > to_charpos
7225 && IT_CHARPOS (*it) < to_charpos)))))
7226 {
7227 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
7228 {
7229 result = MOVE_POS_MATCH_OR_ZV;
7230 break;
7231 }
7232 else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
7233 7234 7235
7236 atpos_it = *it;
7237 }
7238
7239 prev_method = it->method;
7240 if (it->method == GET_FROM_BUFFER)
7241 prev_pos = IT_CHARPOS (*it);
7242 7243 7244 7245
7246 if (!get_next_display_element (it))
7247 {
7248 result = MOVE_POS_MATCH_OR_ZV;
7249 break;
7250 }
7251
7252 if (it->line_wrap == TRUNCATE)
7253 {
7254 if (BUFFER_POS_REACHED_P ())
7255 {
7256 result = MOVE_POS_MATCH_OR_ZV;
7257 break;
7258 }
7259 }
7260 else
7261 {
7262 if (it->line_wrap == WORD_WRAP)
7263 {
7264 if (IT_DISPLAYING_WHITESPACE (it))
7265 may_wrap = 1;
7266 else if (may_wrap)
7267 {
7268 7269 7270
7271 if (atpos_it.sp >= 0)
7272 {
7273 *it = atpos_it;
7274 result = MOVE_POS_MATCH_OR_ZV;
7275 goto done;
7276 }
7277 if (atx_it.sp >= 0)
7278 {
7279 *it = atx_it;
7280 result = MOVE_X_REACHED;
7281 goto done;
7282 }
7283
7284 wrap_it = *it;
7285 may_wrap = 0;
7286 }
7287 }
7288 }
7289
7290 7291
7292 ascent = it->max_ascent;
7293 descent = it->max_descent;
7294
7295 7296 7297 7298
7299 x = it->current_x;
7300
7301 PRODUCE_GLYPHS (it);
7302
7303 if (it->area != TEXT_AREA)
7304 {
7305 set_iterator_to_next (it, 1);
7306 continue;
7307 }
7308
7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326
7327 if (it->nglyphs)
7328 {
7329 7330
7331 int single_glyph_width = it->pixel_width / it->nglyphs;
7332 int new_x;
7333 int x_before_this_char = x;
7334 int hpos_before_this_char = it->hpos;
7335
7336 for (i = 0; i < it->nglyphs; ++i, x = new_x)
7337 {
7338 new_x = x + single_glyph_width;
7339
7340
7341 if ((op & MOVE_TO_X) && new_x > to_x)
7342 {
7343 if (BUFFER_POS_REACHED_P ())
7344 {
7345 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
7346 goto buffer_pos_reached;
7347 if (atpos_it.sp < 0)
7348 {
7349 atpos_it = *it;
7350 IT_RESET_X_ASCENT_DESCENT (&atpos_it);
7351 }
7352 }
7353 else
7354 {
7355 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
7356 {
7357 it->current_x = x;
7358 result = MOVE_X_REACHED;
7359 break;
7360 }
7361 if (atx_it.sp < 0)
7362 {
7363 atx_it = *it;
7364 IT_RESET_X_ASCENT_DESCENT (&atx_it);
7365 }
7366 }
7367 }
7368
7369 if (
7370 it->line_wrap != TRUNCATE
7371 && (
7372 new_x > it->last_visible_x
7373 7374
7375 || (new_x == it->last_visible_x
7376 && FRAME_WINDOW_P (it->f))))
7377 {
7378 if ( 7379
7380 it->hpos == 0
7381 || (new_x == it->last_visible_x
7382 && FRAME_WINDOW_P (it->f)))
7383 {
7384 ++it->hpos;
7385 it->current_x = new_x;
7386
7387 7388
7389 if (i == it->nglyphs - 1)
7390 {
7391 7392 7393
7394 if (BUFFER_POS_REACHED_P ())
7395 {
7396 if (it->line_wrap != WORD_WRAP
7397 || wrap_it.sp < 0)
7398 {
7399 it->hpos = hpos_before_this_char;
7400 it->current_x = x_before_this_char;
7401 result = MOVE_POS_MATCH_OR_ZV;
7402 break;
7403 }
7404 if (it->line_wrap == WORD_WRAP
7405 && atpos_it.sp < 0)
7406 {
7407 atpos_it = *it;
7408 atpos_it.current_x = x_before_this_char;
7409 atpos_it.hpos = hpos_before_this_char;
7410 }
7411 }
7412
7413 set_iterator_to_next (it, 1);
7414 7415 7416 7417 7418 7419
7420 if (!FRAME_WINDOW_P (it->f)
7421 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
7422 {
7423 if (!get_next_display_element (it))
7424 {
7425 result = MOVE_POS_MATCH_OR_ZV;
7426 break;
7427 }
7428 if (BUFFER_POS_REACHED_P ())
7429 {
7430 if (ITERATOR_AT_END_OF_LINE_P (it))
7431 result = MOVE_POS_MATCH_OR_ZV;
7432 else
7433 result = MOVE_LINE_CONTINUED;
7434 break;
7435 }
7436 if (ITERATOR_AT_END_OF_LINE_P (it))
7437 {
7438 result = MOVE_NEWLINE_OR_CR;
7439 break;
7440 }
7441 }
7442 }
7443 }
7444 else
7445 IT_RESET_X_ASCENT_DESCENT (it);
7446
7447 if (wrap_it.sp >= 0)
7448 {
7449 *it = wrap_it;
7450 atpos_it.sp = -1;
7451 atx_it.sp = -1;
7452 }
7453
7454 TRACE_MOVE ((stderr, "move_it_in: continued at %d\n",
7455 IT_CHARPOS (*it)));
7456 result = MOVE_LINE_CONTINUED;
7457 break;
7458 }
7459
7460 if (BUFFER_POS_REACHED_P ())
7461 {
7462 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
7463 goto buffer_pos_reached;
7464 if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
7465 {
7466 atpos_it = *it;
7467 IT_RESET_X_ASCENT_DESCENT (&atpos_it);
7468 }
7469 }
7470
7471 if (new_x > it->first_visible_x)
7472 {
7473 7474
7475 ++it->hpos;
7476 }
7477 }
7478
7479 if (result != MOVE_UNDEFINED)
7480 break;
7481 }
7482 else if (BUFFER_POS_REACHED_P ())
7483 {
7484 buffer_pos_reached:
7485 IT_RESET_X_ASCENT_DESCENT (it);
7486 result = MOVE_POS_MATCH_OR_ZV;
7487 break;
7488 }
7489 else if ((op & MOVE_TO_X) && it->current_x >= to_x)
7490 {
7491 7492 7493 7494
7495 xassert (it->nglyphs == 0);
7496 result = MOVE_X_REACHED;
7497 break;
7498 }
7499
7500
7501 if (ITERATOR_AT_END_OF_LINE_P (it))
7502 {
7503 result = MOVE_NEWLINE_OR_CR;
7504 break;
7505 }
7506
7507 if (it->method == GET_FROM_BUFFER)
7508 prev_pos = IT_CHARPOS (*it);
7509 7510
7511 set_iterator_to_next (it, 1);
7512
7513 7514
7515 if (it->line_wrap == TRUNCATE
7516 && it->current_x >= it->last_visible_x)
7517 {
7518 if (!FRAME_WINDOW_P (it->f)
7519 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
7520 {
7521 if (!get_next_display_element (it)
7522 || BUFFER_POS_REACHED_P ())
7523 {
7524 result = MOVE_POS_MATCH_OR_ZV;
7525 break;
7526 }
7527 if (ITERATOR_AT_END_OF_LINE_P (it))
7528 {
7529 result = MOVE_NEWLINE_OR_CR;
7530 break;
7531 }
7532 }
7533 result = MOVE_LINE_TRUNCATED;
7534 break;
7535 }
7536 #undef IT_RESET_X_ASCENT_DESCENT
7537 }
7538
7539 #undef BUFFER_POS_REACHED_P
7540
7541 7542
7543 if (atpos_it.sp >= 0)
7544 *it = atpos_it;
7545 else if (atx_it.sp >= 0)
7546 *it = atx_it;
7547
7548 done:
7549
7550 7551
7552 it->glyph_row = saved_glyph_row;
7553 return result;
7554 }
7555
7556
7557 void
7558 move_it_in_display_line (struct it *it,
7559 EMACS_INT to_charpos, int to_x,
7560 enum move_operation_enum op)
7561 {
7562 if (it->line_wrap == WORD_WRAP
7563 && (op & MOVE_TO_X))
7564 {
7565 struct it save_it = *it;
7566 int skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
7567 7568 7569 7570
7571 if (skip == MOVE_LINE_CONTINUED)
7572 {
7573 int prev_x = max (it->current_x - 1, 0);
7574 *it = save_it;
7575 move_it_in_display_line_to
7576 (it, -1, prev_x, MOVE_TO_X);
7577 }
7578 }
7579 else
7580 move_it_in_display_line_to (it, to_charpos, to_x, op);
7581 }
7582
7583
7584 7585 7586 7587 7588 7589 7590 7591 7592 7593
7594
7595 void
7596 move_it_to (it, to_charpos, to_x, to_y, to_vpos, op)
7597 struct it *it;
7598 int to_charpos, to_x, to_y, to_vpos;
7599 int op;
7600 {
7601 enum move_it_result skip, skip2 = MOVE_X_REACHED;
7602 int line_height, line_start_x = 0, reached = 0;
7603
7604 for (;;)
7605 {
7606 if (op & MOVE_TO_VPOS)
7607 {
7608 7609
7610 if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
7611 {
7612 if (it->vpos == to_vpos)
7613 {
7614 reached = 1;
7615 break;
7616 }
7617 else
7618 skip = move_it_in_display_line_to (it, -1, -1, 0);
7619 }
7620 else
7621 {
7622 7623
7624 if (it->vpos == to_vpos)
7625 {
7626 reached = 2;
7627 break;
7628 }
7629
7630 skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
7631
7632 if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
7633 {
7634 reached = 3;
7635 break;
7636 }
7637 else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
7638 {
7639
7640 skip = move_it_in_display_line_to (it, to_charpos,
7641 -1, MOVE_TO_POS);
7642 if (skip == MOVE_POS_MATCH_OR_ZV)
7643 {
7644 reached = 4;
7645 break;
7646 }
7647 }
7648 }
7649 }
7650 else if (op & MOVE_TO_Y)
7651 {
7652 struct it it_backup;
7653
7654 if (it->line_wrap == WORD_WRAP)
7655 it_backup = *it;
7656
7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668
7669 skip = move_it_in_display_line_to
7670 (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
7671 (MOVE_TO_X | (op & MOVE_TO_POS)));
7672
7673
7674 if (skip == MOVE_POS_MATCH_OR_ZV)
7675 reached = 5;
7676 else if (skip == MOVE_X_REACHED)
7677 {
7678 7679 7680 7681
7682 line_height = it->max_ascent + it->max_descent;
7683 if (to_y >= it->current_y
7684 && to_y < it->current_y + line_height)
7685 {
7686 reached = 6;
7687 break;
7688 }
7689 it_backup = *it;
7690 TRACE_MOVE ((stderr, "move_it: from %d\n", IT_CHARPOS (*it)));
7691 skip2 = move_it_in_display_line_to (it, to_charpos, -1,
7692 op & MOVE_TO_POS);
7693 TRACE_MOVE ((stderr, "move_it: to %d\n", IT_CHARPOS (*it)));
7694 line_height = it->max_ascent + it->max_descent;
7695 TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
7696
7697 if (to_y >= it->current_y
7698 && to_y < it->current_y + line_height)
7699 {
7700 7701 7702
7703 *it = it_backup;
7704 reached = 6;
7705 }
7706 else
7707 {
7708 skip = skip2;
7709 if (skip == MOVE_POS_MATCH_OR_ZV)
7710 reached = 7;
7711 }
7712 }
7713 else
7714 {
7715
7716 line_height = it->max_ascent + it->max_descent;
7717 TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
7718
7719 if (to_y >= it->current_y
7720 && to_y < it->current_y + line_height)
7721 {
7722 7723 7724 7725
7726 if (skip == MOVE_LINE_CONTINUED
7727 && it->line_wrap == WORD_WRAP)
7728 {
7729 int prev_x = max (it->current_x - 1, 0);
7730 *it = it_backup;
7731 skip = move_it_in_display_line_to
7732 (it, -1, prev_x, MOVE_TO_X);
7733 }
7734 reached = 6;
7735 }
7736 }
7737
7738 if (reached)
7739 break;
7740 }
7741 else if (BUFFERP (it->object)
7742 && (it->method == GET_FROM_BUFFER
7743 || it->method == GET_FROM_STRETCH)
7744 && IT_CHARPOS (*it) >= to_charpos)
7745 skip = MOVE_POS_MATCH_OR_ZV;
7746 else
7747 skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
7748
7749 switch (skip)
7750 {
7751 case MOVE_POS_MATCH_OR_ZV:
7752 reached = 8;
7753 goto out;
7754
7755 case MOVE_NEWLINE_OR_CR:
7756 set_iterator_to_next (it, 1);
7757 it->continuation_lines_width = 0;
7758 break;
7759
7760 case MOVE_LINE_TRUNCATED:
7761 it->continuation_lines_width = 0;
7762 reseat_at_next_visible_line_start (it, 0);
7763 if ((op & MOVE_TO_POS) != 0
7764 && IT_CHARPOS (*it) > to_charpos)
7765 {
7766 reached = 9;
7767 goto out;
7768 }
7769 break;
7770
7771 case MOVE_LINE_CONTINUED:
7772 7773 7774 7775
7776 if (it->c == '\t')
7777 {
7778 it->continuation_lines_width += it->last_visible_x;
7779 7780 7781
7782 if (it->current_x != it->last_visible_x
7783 && (op & MOVE_TO_VPOS)
7784 && !(op & (MOVE_TO_X | MOVE_TO_POS)))
7785 {
7786 line_start_x = it->current_x + it->pixel_width
7787 - it->last_visible_x;
7788 set_iterator_to_next (it, 0);
7789 }
7790 }
7791 else
7792 it->continuation_lines_width += it->current_x;
7793 break;
7794
7795 default:
7796 abort ();
7797 }
7798
7799
7800 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
7801 it->current_x = line_start_x;
7802 line_start_x = 0;
7803 it->hpos = 0;
7804 it->current_y += it->max_ascent + it->max_descent;
7805 ++it->vpos;
7806 last_height = it->max_ascent + it->max_descent;
7807 last_max_ascent = it->max_ascent;
7808 it->max_ascent = it->max_descent = 0;
7809 }
7810
7811 out:
7812
7813 7814 7815 7816 7817
7818 if (!FRAME_WINDOW_P (it->f)
7819 && op & MOVE_TO_POS
7820 && IT_CHARPOS (*it) == to_charpos
7821 && it->what == IT_CHARACTER
7822 && it->nglyphs > 1
7823 && it->line_wrap == WINDOW_WRAP
7824 && it->current_x == it->last_visible_x - 1
7825 && it->c != '\n'
7826 && it->c != '\t'
7827 && it->vpos < XFASTINT (it->w->window_end_vpos))
7828 {
7829 it->continuation_lines_width += it->current_x;
7830 it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
7831 it->current_y += it->max_ascent + it->max_descent;
7832 ++it->vpos;
7833 last_height = it->max_ascent + it->max_descent;
7834 last_max_ascent = it->max_ascent;
7835 }
7836
7837 TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
7838 }
7839
7840
7841 7842 7843 7844 7845 7846 7847
7848
7849 void
7850 move_it_vertically_backward (it, dy)
7851 struct it *it;
7852 int dy;
7853 {
7854 int nlines, h;
7855 struct it it2, it3;
7856 int start_pos;
7857
7858 move_further_back:
7859 xassert (dy >= 0);
7860
7861 start_pos = IT_CHARPOS (*it);
7862
7863
7864 nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
7865
7866
7867 while (nlines-- && IT_CHARPOS (*it) > BEGV)
7868 back_to_previous_visible_line_start (it);
7869
7870 7871 7872 7873
7874 reseat_1 (it, it->current.pos, 1);
7875
7876
7877 it->current_x = it->hpos = 0;
7878 it->continuation_lines_width = 0;
7879
7880 7881 7882 7883
7884 it2 = *it;
7885 it2.max_ascent = it2.max_descent = 0;
7886 do
7887 {
7888 move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
7889 MOVE_TO_POS | MOVE_TO_VPOS);
7890 }
7891 while (!IT_POS_VALID_AFTER_MOVE_P (&it2));
7892 xassert (IT_CHARPOS (*it) >= BEGV);
7893 it3 = it2;
7894
7895 move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
7896 xassert (IT_CHARPOS (*it) >= BEGV);
7897 7898
7899 h = it2.current_y - it->current_y;
7900
7901 nlines = it2.vpos - it->vpos;
7902
7903 7904
7905 it->vpos -= nlines;
7906 it->current_y -= h;
7907
7908 if (dy == 0)
7909 {
7910 7911
7912 if (nlines > 0)
7913 move_it_by_lines (it, nlines, 1);
7914 }
7915 else
7916 {
7917 7918
7919 int target_y = it->current_y + h - dy;
7920 int y0 = it3.current_y;
7921 int y1 = line_bottom_y (&it3);
7922 int line_height = y1 - y0;
7923
7924 7925
7926 if (target_y < it->current_y
7927 7928 7929 7930
7931 && (it->current_y - target_y
7932 > min (window_box_height (it->w), line_height * 2 / 3))
7933 && IT_CHARPOS (*it) > BEGV)
7934 {
7935 TRACE_MOVE ((stderr, " not far enough -> move_vert %d\n",
7936 target_y - it->current_y));
7937 dy = it->current_y - target_y;
7938 goto move_further_back;
7939 }
7940 else if (target_y >= it->current_y + line_height
7941 && IT_CHARPOS (*it) < ZV)
7942 {
7943 7944 7945 7946 7947 7948 7949
7950
7951 if (!FRAME_WINDOW_P (it->f))
7952 move_it_vertically (it, target_y - (it->current_y + line_height));
7953 else
7954 {
7955 do
7956 {
7957 move_it_by_lines (it, 1, 1);
7958 }
7959 while (target_y >= line_bottom_y (it) && IT_CHARPOS (*it) < ZV);
7960 }
7961 }
7962 }
7963 }
7964
7965
7966 7967 7968
7969
7970 void
7971 move_it_vertically (it, dy)
7972 struct it *it;
7973 int dy;
7974 {
7975 if (dy <= 0)
7976 move_it_vertically_backward (it, -dy);
7977 else
7978 {
7979 TRACE_MOVE ((stderr, "move_it_v: from %d, %d\n", IT_CHARPOS (*it), dy));
7980 move_it_to (it, ZV, -1, it->current_y + dy, -1,
7981 MOVE_TO_POS | MOVE_TO_Y);
7982 TRACE_MOVE ((stderr, "move_it_v: to %d\n", IT_CHARPOS (*it)));
7983
7984 7985
7986 if (IT_CHARPOS (*it) == ZV
7987 && ZV > BEGV
7988 && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
7989 move_it_by_lines (it, 0, 0);
7990 }
7991 }
7992
7993
7994
7995
7996 void
7997 move_it_past_eol (it)
7998 struct it *it;
7999 {
8000 enum move_it_result rc;
8001
8002 rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
8003 if (rc == MOVE_NEWLINE_OR_CR)
8004 set_iterator_to_next (it, 0);
8005 }
8006
8007
8008 8009 8010 8011 8012 8013 8014 8015
8016
8017 void
8018 move_it_by_lines (it, dvpos, need_y_p)
8019 struct it *it;
8020 int dvpos, need_y_p;
8021 {
8022 struct position pos;
8023
8024 8025 8026
8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037
8038
8039 if (dvpos == 0)
8040 {
8041
8042 move_it_vertically_backward (it, 0);
8043 xassert (it->current_x == 0 && it->hpos == 0);
8044
8045 last_height = 0;
8046 }
8047 else if (dvpos > 0)
8048 {
8049 move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
8050 if (!IT_POS_VALID_AFTER_MOVE_P (it))
8051 move_it_to (it, IT_CHARPOS (*it) + 1, -1, -1, -1, MOVE_TO_POS);
8052 }
8053 else
8054 {
8055 struct it it2;
8056 int start_charpos, i;
8057
8058 8059 8060
8061 dvpos += it->vpos;
8062 move_it_vertically_backward (it, 0);
8063 dvpos -= it->vpos;
8064
8065
8066 start_charpos = IT_CHARPOS (*it);
8067 for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > BEGV; --i)
8068 back_to_previous_visible_line_start (it);
8069 reseat (it, it->current.pos, 1);
8070
8071
8072 while (!IT_POS_VALID_AFTER_MOVE_P (it))
8073 {
8074
8075 dvpos += it->vpos;
8076 move_it_vertically_backward (it, 0);
8077 dvpos -= it->vpos;
8078 if (IT_POS_VALID_AFTER_MOVE_P (it))
8079 break;
8080 8081
8082 back_to_previous_visible_line_start (it);
8083 reseat (it, it->current.pos, 1);
8084 dvpos--;
8085 }
8086
8087 it->current_x = it->hpos = 0;
8088
8089 8090
8091 it2 = *it;
8092 it2.vpos = it2.current_y = 0;
8093 move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
8094 it->vpos -= it2.vpos;
8095 it->current_y -= it2.current_y;
8096 it->current_x = it->hpos = 0;
8097
8098
8099 if (it2.vpos > -dvpos)
8100 {
8101 int delta = it2.vpos + dvpos;
8102 it2 = *it;
8103 move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
8104
8105 if (IT_CHARPOS (*it) >= start_charpos)
8106 *it = it2;
8107 }
8108 }
8109 }
8110
8111
8112
8113 int
8114 in_display_vector_p (it)
8115 struct it *it;
8116 {
8117 return (it->method == GET_FROM_DISPLAY_VECTOR
8118 && it->current.dpvec_index > 0
8119 && it->dpvec + it->current.dpvec_index != it->dpend);
8120 }
8121
8122
8123 8124 8125
8126
8127
8128 8129
8130
8131 void
8132 add_to_log (format, arg1, arg2)
8133 char *format;
8134 Lisp_Object arg1, arg2;
8135 {
8136 Lisp_Object args[3];
8137 Lisp_Object msg, fmt;
8138 char *buffer;
8139 int len;
8140 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
8141 USE_SAFE_ALLOCA;
8142
8143 8144 8145
8146 if (handling_signal)
8147 return;
8148
8149 fmt = msg = Qnil;
8150 GCPRO4 (fmt, msg, arg1, arg2);
8151
8152 args[0] = fmt = build_string (format);
8153 args[1] = arg1;
8154 args[2] = arg2;
8155 msg = Fformat (3, args);
8156
8157 len = SBYTES (msg) + 1;
8158 SAFE_ALLOCA (buffer, char *, len);
8159 bcopy (SDATA (msg), buffer, len);
8160
8161 message_dolog (buffer, len - 1, 1, 0);
8162 SAFE_FREE ();
8163
8164 UNGCPRO;
8165 }
8166
8167
8168
8169
8170 void
8171 message_log_maybe_newline ()
8172 {
8173 if (message_log_need_newline)
8174 message_dolog ("", 0, 1, 0);
8175 }
8176
8177
8178 8179 8180 8181 8182 8183 8184 8185
8186
8187 void
8188 message_dolog (m, nbytes, nlflag, multibyte)
8189 const char *m;
8190 int nbytes, nlflag, multibyte;
8191 {
8192 if (!NILP (Vmemory_full))
8193 return;
8194
8195 if (!NILP (Vmessage_log_max))
8196 {
8197 struct buffer *oldbuf;
8198 Lisp_Object oldpoint, oldbegv, oldzv;
8199 int old_windows_or_buffers_changed = windows_or_buffers_changed;
8200 int point_at_end = 0;
8201 int zv_at_end = 0;
8202 Lisp_Object old_deactivate_mark, tem;
8203 struct gcpro gcpro1;
8204
8205 old_deactivate_mark = Vdeactivate_mark;
8206 oldbuf = current_buffer;
8207 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
8208 current_buffer->undo_list = Qt;
8209
8210 oldpoint = message_dolog_marker1;
8211 set_marker_restricted (oldpoint, make_number (PT), Qnil);
8212 oldbegv = message_dolog_marker2;
8213 set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
8214 oldzv = message_dolog_marker3;
8215 set_marker_restricted (oldzv, make_number (ZV), Qnil);
8216 GCPRO1 (old_deactivate_mark);
8217
8218 if (PT == Z)
8219 point_at_end = 1;
8220 if (ZV == Z)
8221 zv_at_end = 1;
8222
8223 BEGV = BEG;
8224 BEGV_BYTE = BEG_BYTE;
8225 ZV = Z;
8226 ZV_BYTE = Z_BYTE;
8227 TEMP_SET_PT_BOTH (Z, Z_BYTE);
8228
8229 8230
8231 if (multibyte
8232 && NILP (current_buffer->enable_multibyte_characters))
8233 {
8234 int i, c, char_bytes;
8235 unsigned char work[1];
8236
8237 8238
8239 for (i = 0; i < nbytes; i += char_bytes)
8240 {
8241 c = string_char_and_length (m + i, &char_bytes);
8242 work[0] = (ASCII_CHAR_P (c)
8243 ? c
8244 : multibyte_char_to_unibyte (c, Qnil));
8245 insert_1_both (work, 1, 1, 1, 0, 0);
8246 }
8247 }
8248 else if (! multibyte
8249 && ! NILP (current_buffer->enable_multibyte_characters))
8250 {
8251 int i, c, char_bytes;
8252 unsigned char *msg = (unsigned char *) m;
8253 unsigned char str[MAX_MULTIBYTE_LENGTH];
8254 8255
8256 for (i = 0; i < nbytes; i++)
8257 {
8258 c = msg[i];
8259 MAKE_CHAR_MULTIBYTE (c);
8260 char_bytes = CHAR_STRING (c, str);
8261 insert_1_both (str, 1, char_bytes, 1, 0, 0);
8262 }
8263 }
8264 else if (nbytes)
8265 insert_1 (m, nbytes, 1, 0, 0);
8266
8267 if (nlflag)
8268 {
8269 int this_bol, this_bol_byte, prev_bol, prev_bol_byte, dup;
8270 insert_1 ("\n", 1, 1, 0, 0);
8271
8272 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
8273 this_bol = PT;
8274 this_bol_byte = PT_BYTE;
8275
8276 8277
8278 if (this_bol > BEG)
8279 {
8280 scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, 0);
8281 prev_bol = PT;
8282 prev_bol_byte = PT_BYTE;
8283
8284 dup = message_log_check_duplicate (prev_bol, prev_bol_byte,
8285 this_bol, this_bol_byte);
8286 if (dup)
8287 {
8288 del_range_both (prev_bol, prev_bol_byte,
8289 this_bol, this_bol_byte, 0);
8290 if (dup > 1)
8291 {
8292 char dupstr[40];
8293 int duplen;
8294
8295 8296
8297 sprintf (dupstr, " [%d times]", dup);
8298 duplen = strlen (dupstr);
8299 TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
8300 insert_1 (dupstr, duplen, 1, 0, 1);
8301 }
8302 }
8303 }
8304
8305 8306 8307
8308
8309 if (NATNUMP (Vmessage_log_max))
8310 {
8311 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
8312 -XFASTINT (Vmessage_log_max) - 1, 0);
8313 del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
8314 }
8315 }
8316 BEGV = XMARKER (oldbegv)->charpos;
8317 BEGV_BYTE = marker_byte_position (oldbegv);
8318
8319 if (zv_at_end)
8320 {
8321 ZV = Z;
8322 ZV_BYTE = Z_BYTE;
8323 }
8324 else
8325 {
8326 ZV = XMARKER (oldzv)->charpos;
8327 ZV_BYTE = marker_byte_position (oldzv);
8328 }
8329
8330 if (point_at_end)
8331 TEMP_SET_PT_BOTH (Z, Z_BYTE);
8332 else
8333 8334
8335 TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
8336 XMARKER (oldpoint)->bytepos);
8337
8338 UNGCPRO;
8339 unchain_marker (XMARKER (oldpoint));
8340 unchain_marker (XMARKER (oldbegv));
8341 unchain_marker (XMARKER (oldzv));
8342
8343 tem = Fget_buffer_window (Fcurrent_buffer (), Qt);
8344 set_buffer_internal (oldbuf);
8345 if (NILP (tem))
8346 windows_or_buffers_changed = old_windows_or_buffers_changed;
8347 message_log_need_newline = !nlflag;
8348 Vdeactivate_mark = old_deactivate_mark;
8349 }
8350 }
8351
8352
8353 8354 8355 8356 8357
8358
8359 static int
8360 message_log_check_duplicate (prev_bol, prev_bol_byte, this_bol, this_bol_byte)
8361 int prev_bol, this_bol;
8362 int prev_bol_byte, this_bol_byte;
8363 {
8364 int i;
8365 int len = Z_BYTE - 1 - this_bol_byte;
8366 int seen_dots = 0;
8367 unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
8368 unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
8369
8370 for (i = 0; i < len; i++)
8371 {
8372 if (i >= 3 && p1[i-3] == '.' && p1[i-2] == '.' && p1[i-1] == '.')
8373 seen_dots = 1;
8374 if (p1[i] != p2[i])
8375 return seen_dots;
8376 }
8377 p1 += len;
8378 if (*p1 == '\n')
8379 return 2;
8380 if (*p1++ == ' ' && *p1++ == '[')
8381 {
8382 int n = 0;
8383 while (*p1 >= '0' && *p1 <= '9')
8384 n = n * 10 + *p1++ - '0';
8385 if (strncmp (p1, " times]\n", 8) == 0)
8386 return n+1;
8387 }
8388 return 0;
8389 }
8390
8391
8392 8393 8394 8395 8396 8397
8398
8399 void
8400 message2 (m, nbytes, multibyte)
8401 const char *m;
8402 int nbytes;
8403 int multibyte;
8404 {
8405
8406 message_log_maybe_newline ();
8407 if (m)
8408 message_dolog (m, nbytes, 1, multibyte);
8409 message2_nolog (m, nbytes, multibyte);
8410 }
8411
8412
8413
8414
8415 void
8416 message2_nolog (m, nbytes, multibyte)
8417 const char *m;
8418 int nbytes, multibyte;
8419 {
8420 struct frame *sf = SELECTED_FRAME ();
8421 message_enable_multibyte = multibyte;
8422
8423 if (FRAME_INITIAL_P (sf))
8424 {
8425 if (noninteractive_need_newline)
8426 putc ('\n', stderr);
8427 noninteractive_need_newline = 0;
8428 if (m)
8429 fwrite (m, nbytes, 1, stderr);
8430 if (cursor_in_echo_area == 0)
8431 fprintf (stderr, "\n");
8432 fflush (stderr);
8433 }
8434 8435 8436
8437 else if (INTERACTIVE
8438 && sf->glyphs_initialized_p
8439 && FRAME_MESSAGE_BUF (sf))
8440 {
8441 Lisp_Object mini_window;
8442 struct frame *f;
8443
8444 8445
8446 mini_window = FRAME_MINIBUF_WINDOW (sf);
8447 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
8448
8449 FRAME_SAMPLE_VISIBILITY (f);
8450 if (FRAME_VISIBLE_P (sf)
8451 && ! FRAME_VISIBLE_P (f))
8452 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
8453
8454 if (m)
8455 {
8456 set_message (m, Qnil, nbytes, multibyte);
8457 if (minibuffer_auto_raise)
8458 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
8459 }
8460 else
8461 clear_message (1, 1);
8462
8463 do_pending_window_change (0);
8464 echo_area_display (1);
8465 do_pending_window_change (0);
8466 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
8467 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
8468 }
8469 }
8470
8471
8472 8473 8474 8475 8476 8477
8478
8479 void
8480 message3 (m, nbytes, multibyte)
8481 Lisp_Object m;
8482 int nbytes;
8483 int multibyte;
8484 {
8485 struct gcpro gcpro1;
8486
8487 GCPRO1 (m);
8488 clear_message (1,1);
8489 cancel_echoing ();
8490
8491
8492 message_log_maybe_newline ();
8493 if (STRINGP (m))
8494 {
8495 char *buffer;
8496 USE_SAFE_ALLOCA;
8497
8498 SAFE_ALLOCA (buffer, char *, nbytes);
8499 bcopy (SDATA (m), buffer, nbytes);
8500 message_dolog (buffer, nbytes, 1, multibyte);
8501 SAFE_FREE ();
8502 }
8503 message3_nolog (m, nbytes, multibyte);
8504
8505 UNGCPRO;
8506 }
8507
8508
8509 8510 8511 8512
8513
8514 void
8515 message3_nolog (m, nbytes, multibyte)
8516 Lisp_Object m;
8517 int nbytes, multibyte;
8518 {
8519 struct frame *sf = SELECTED_FRAME ();
8520 message_enable_multibyte = multibyte;
8521
8522 if (FRAME_INITIAL_P (sf))
8523 {
8524 if (noninteractive_need_newline)
8525 putc ('\n', stderr);
8526 noninteractive_need_newline = 0;
8527 if (STRINGP (m))
8528 fwrite (SDATA (m), nbytes, 1, stderr);
8529 if (cursor_in_echo_area == 0)
8530 fprintf (stderr, "\n");
8531 fflush (stderr);
8532 }
8533 8534 8535
8536 else if (INTERACTIVE
8537 && sf->glyphs_initialized_p
8538 && FRAME_MESSAGE_BUF (sf))
8539 {
8540 Lisp_Object mini_window;
8541 Lisp_Object frame;
8542 struct frame *f;
8543
8544 8545
8546 mini_window = FRAME_MINIBUF_WINDOW (sf);
8547 frame = XWINDOW (mini_window)->frame;
8548 f = XFRAME (frame);
8549
8550 FRAME_SAMPLE_VISIBILITY (f);
8551 if (FRAME_VISIBLE_P (sf)
8552 && !FRAME_VISIBLE_P (f))
8553 Fmake_frame_visible (frame);
8554
8555 if (STRINGP (m) && SCHARS (m) > 0)
8556 {
8557 set_message (NULL, m, nbytes, multibyte);
8558 if (minibuffer_auto_raise)
8559 Fraise_frame (frame);
8560 8561
8562 echo_message_buffer = Qnil;
8563 }
8564 else
8565 clear_message (1, 1);
8566
8567 do_pending_window_change (0);
8568 echo_area_display (1);
8569 do_pending_window_change (0);
8570 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
8571 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
8572 }
8573 }
8574
8575
8576 8577 8578 8579 8580 8581 8582
8583
8584 void
8585 message1 (m)
8586 char *m;
8587 {
8588 message2 (m, (m ? strlen (m) : 0), 0);
8589 }
8590
8591
8592
8593
8594 void
8595 message1_nolog (m)
8596 char *m;
8597 {
8598 message2_nolog (m, (m ? strlen (m) : 0), 0);
8599 }
8600
8601 8602
8603
8604 void
8605 message_with_string (m, string, log)
8606 char *m;
8607 Lisp_Object string;
8608 int log;
8609 {
8610 CHECK_STRING (string);
8611
8612 if (noninteractive)
8613 {
8614 if (m)
8615 {
8616 if (noninteractive_need_newline)
8617 putc ('\n', stderr);
8618 noninteractive_need_newline = 0;
8619 fprintf (stderr, m, SDATA (string));
8620 if (!cursor_in_echo_area)
8621 fprintf (stderr, "\n");
8622 fflush (stderr);
8623 }
8624 }
8625 else if (INTERACTIVE)
8626 {
8627 8628 8629
8630 Lisp_Object mini_window;
8631 struct frame *f, *sf = SELECTED_FRAME ();
8632
8633 8634
8635 mini_window = FRAME_MINIBUF_WINDOW (sf);
8636 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
8637
8638 8639 8640
8641 if (FRAME_MESSAGE_BUF (f))
8642 {
8643 Lisp_Object args[2], message;
8644 struct gcpro gcpro1, gcpro2;
8645
8646 args[0] = build_string (m);
8647 args[1] = message = string;
8648 GCPRO2 (args[0], message);
8649 gcpro1.nvars = 2;
8650
8651 message = Fformat (2, args);
8652
8653 if (log)
8654 message3 (message, SBYTES (message), STRING_MULTIBYTE (message));
8655 else
8656 message3_nolog (message, SBYTES (message), STRING_MULTIBYTE (message));
8657
8658 UNGCPRO;
8659
8660 8661
8662 message_buf_print = 0;
8663 }
8664 }
8665 }
8666
8667
8668 8669
8670
8671
8672 void
8673 message (m, a1, a2, a3)
8674 char *m;
8675 EMACS_INT a1, a2, a3;
8676 {
8677 if (noninteractive)
8678 {
8679 if (m)
8680 {
8681 if (noninteractive_need_newline)
8682 putc ('\n', stderr);
8683 noninteractive_need_newline = 0;
8684 fprintf (stderr, m, a1, a2, a3);
8685 if (cursor_in_echo_area == 0)
8686 fprintf (stderr, "\n");
8687 fflush (stderr);
8688 }
8689 }
8690 else if (INTERACTIVE)
8691 {
8692 8693 8694
8695 Lisp_Object mini_window;
8696 struct frame *f, *sf = SELECTED_FRAME ();
8697
8698 8699
8700 mini_window = FRAME_MINIBUF_WINDOW (sf);
8701 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
8702
8703 8704 8705 8706
8707 if (FRAME_MESSAGE_BUF (f))
8708 {
8709 if (m)
8710 {
8711 int len;
8712 char *a[3];
8713 a[0] = (char *) a1;
8714 a[1] = (char *) a2;
8715 a[2] = (char *) a3;
8716
8717 len = doprnt (FRAME_MESSAGE_BUF (f),
8718 FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
8719
8720 message2 (FRAME_MESSAGE_BUF (f), len, 0);
8721 }
8722 else
8723 message1 (0);
8724
8725 8726
8727 message_buf_print = 0;
8728 }
8729 }
8730 }
8731
8732
8733
8734
8735 void
8736 message_nolog (m, a1, a2, a3)
8737 char *m;
8738 EMACS_INT a1, a2, a3;
8739 {
8740 Lisp_Object old_log_max;
8741 old_log_max = Vmessage_log_max;
8742 Vmessage_log_max = Qnil;
8743 message (m, a1, a2, a3);
8744 Vmessage_log_max = old_log_max;
8745 }
8746
8747
8748 8749 8750
8751
8752 void
8753 update_echo_area ()
8754 {
8755 if (!NILP (echo_area_buffer[0]))
8756 {
8757 Lisp_Object string;
8758 string = Fcurrent_message ();
8759 message3 (string, SBYTES (string),
8760 !NILP (current_buffer->enable_multibyte_characters));
8761 }
8762 }
8763
8764
8765 8766
8767
8768 static void
8769 ensure_echo_area_buffers ()
8770 {
8771 int i;
8772
8773 for (i = 0; i < 2; ++i)
8774 if (!BUFFERP (echo_buffer[i])
8775 || NILP (XBUFFER (echo_buffer[i])->name))
8776 {
8777 char name[30];
8778 Lisp_Object old_buffer;
8779 int j;
8780
8781 old_buffer = echo_buffer[i];
8782 sprintf (name, " *Echo Area %d*", i);
8783 echo_buffer[i] = Fget_buffer_create (build_string (name));
8784 XBUFFER (echo_buffer[i])->truncate_lines = Qnil;
8785 8786
8787
8788
8789 for (j = 0; j < 2; ++j)
8790 if (EQ (old_buffer, echo_area_buffer[j]))
8791 echo_area_buffer[j] = echo_buffer[i];
8792 }
8793 }
8794
8795
8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810
8811
8812 static int
8813 with_echo_area_buffer (w, which, fn, a1, a2, a3, a4)
8814 struct window *w;
8815 int which;
8816 int (*fn) P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
8817 EMACS_INT a1;
8818 Lisp_Object a2;
8819 EMACS_INT a3, a4;
8820 {
8821 Lisp_Object buffer;
8822 int this_one, the_other, clear_buffer_p, rc;
8823 int count = SPECPDL_INDEX ();
8824
8825
8826 ensure_echo_area_buffers ();
8827
8828 clear_buffer_p = 0;
8829
8830 if (which == 0)
8831 this_one = 0, the_other = 1;
8832 else if (which > 0)
8833 this_one = 1, the_other = 0;
8834 else
8835 {
8836 this_one = 0, the_other = 1;
8837 clear_buffer_p = 1;
8838
8839 8840
8841 if (!NILP (echo_area_buffer[this_one])
8842 && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
8843 echo_area_buffer[this_one] = Qnil;
8844 }
8845
8846 8847
8848 if (NILP (echo_area_buffer[this_one]))
8849 {
8850 echo_area_buffer[this_one]
8851 = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
8852 ? echo_buffer[the_other]
8853 : echo_buffer[this_one]);
8854 clear_buffer_p = 1;
8855 }
8856
8857 buffer = echo_area_buffer[this_one];
8858
8859 8860
8861 if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
8862 cancel_echoing ();
8863
8864 record_unwind_protect (unwind_with_echo_area_buffer,
8865 with_echo_area_buffer_unwind_data (w));
8866
8867 8868 8869 8870 8871 8872 8873
8874 set_buffer_internal_1 (XBUFFER (buffer));
8875 if (w)
8876 {
8877 w->buffer = buffer;
8878 set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
8879 }
8880
8881 current_buffer->undo_list = Qt;
8882 current_buffer->read_only = Qnil;
8883 specbind (Qinhibit_read_only, Qt);
8884 specbind (Qinhibit_modification_hooks, Qt);
8885
8886 if (clear_buffer_p && Z > BEG)
8887 del_range (BEG, Z);
8888
8889 xassert (BEGV >= BEG);
8890 xassert (ZV <= Z && ZV >= BEGV);
8891
8892 rc = fn (a1, a2, a3, a4);
8893
8894 xassert (BEGV >= BEG);
8895 xassert (ZV <= Z && ZV >= BEGV);
8896
8897 unbind_to (count, Qnil);
8898 return rc;
8899 }
8900
8901
8902 8903
8904
8905 static Lisp_Object
8906 with_echo_area_buffer_unwind_data (w)
8907 struct window *w;
8908 {
8909 int i = 0;
8910 Lisp_Object vector, tmp;
8911
8912 8913
8914 vector = Vwith_echo_area_save_vector;
8915 Vwith_echo_area_save_vector = Qnil;
8916
8917 if (NILP (vector))
8918 vector = Fmake_vector (make_number (7), Qnil);
8919
8920 XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
8921 ASET (vector, i, Vdeactivate_mark); ++i;
8922 ASET (vector, i, make_number (windows_or_buffers_changed)); ++i;
8923
8924 if (w)
8925 {
8926 XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
8927 ASET (vector, i, w->buffer); ++i;
8928 ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
8929 ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
8930 }
8931 else
8932 {
8933 int end = i + 4;
8934 for (; i < end; ++i)
8935 ASET (vector, i, Qnil);
8936 }
8937
8938 xassert (i == ASIZE (vector));
8939 return vector;
8940 }
8941
8942
8943 8944
8945
8946 static Lisp_Object
8947 unwind_with_echo_area_buffer (vector)
8948 Lisp_Object vector;
8949 {
8950 set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
8951 Vdeactivate_mark = AREF (vector, 1);
8952 windows_or_buffers_changed = XFASTINT (AREF (vector, 2));
8953
8954 if (WINDOWP (AREF (vector, 3)))
8955 {
8956 struct window *w;
8957 Lisp_Object buffer, charpos, bytepos;
8958
8959 w = XWINDOW (AREF (vector, 3));
8960 buffer = AREF (vector, 4);
8961 charpos = AREF (vector, 5);
8962 bytepos = AREF (vector, 6);
8963
8964 w->buffer = buffer;
8965 set_marker_both (w->pointm, buffer,
8966 XFASTINT (charpos), XFASTINT (bytepos));
8967 }
8968
8969 Vwith_echo_area_save_vector = vector;
8970 return Qnil;
8971 }
8972
8973
8974 8975
8976
8977 void
8978 setup_echo_area_for_printing (multibyte_p)
8979 int multibyte_p;
8980 {
8981
8982 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
8983 Fkill_emacs (Qnil);
8984
8985 ensure_echo_area_buffers ();
8986
8987 if (!message_buf_print)
8988 {
8989 8990
8991 if (EQ (echo_area_buffer[1], echo_buffer[0]))
8992 echo_area_buffer[0] = echo_buffer[1];
8993 else
8994 echo_area_buffer[0] = echo_buffer[0];
8995
8996
8997 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
8998 current_buffer->truncate_lines = Qnil;
8999
9000 if (Z > BEG)
9001 {
9002 int count = SPECPDL_INDEX ();
9003 specbind (Qinhibit_read_only, Qt);
9004
9005 del_range (BEG, Z);
9006 unbind_to (count, Qnil);
9007 }
9008 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
9009
9010
9011 if (multibyte_p
9012 != !NILP (current_buffer->enable_multibyte_characters))
9013 Fset_buffer_multibyte (multibyte_p ? Qt : Qnil);
9014
9015
9016 if (minibuffer_auto_raise)
9017 {
9018 struct frame *sf = SELECTED_FRAME ();
9019 Lisp_Object mini_window;
9020 mini_window = FRAME_MINIBUF_WINDOW (sf);
9021 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
9022 }
9023
9024 message_log_maybe_newline ();
9025 message_buf_print = 1;
9026 }
9027 else
9028 {
9029 if (NILP (echo_area_buffer[0]))
9030 {
9031 if (EQ (echo_area_buffer[1], echo_buffer[0]))
9032 echo_area_buffer[0] = echo_buffer[1];
9033 else
9034 echo_area_buffer[0] = echo_buffer[0];
9035 }
9036
9037 if (current_buffer != XBUFFER (echo_area_buffer[0]))
9038 {
9039
9040 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
9041 current_buffer->truncate_lines = Qnil;
9042 }
9043 }
9044 }
9045
9046
9047 9048 9049 9050
9051
9052 static int
9053 display_echo_area (w)
9054 struct window *w;
9055 {
9056 int i, no_message_p, window_height_changed_p, count;
9057
9058 9059 9060 9061 9062
9063 count = inhibit_garbage_collection ();
9064
9065 9066 9067 9068
9069 i = display_last_displayed_message_p ? 1 : 0;
9070 no_message_p = NILP (echo_area_buffer[i]);
9071
9072 window_height_changed_p
9073 = with_echo_area_buffer (w, display_last_displayed_message_p,
9074 display_echo_area_1,
9075 (EMACS_INT) w, Qnil, 0, 0);
9076
9077 if (no_message_p)
9078 echo_area_buffer[i] = Qnil;
9079
9080 unbind_to (count, Qnil);
9081 return window_height_changed_p;
9082 }
9083
9084
9085 9086 9087 9088 9089
9090
9091 static int
9092 display_echo_area_1 (a1, a2, a3, a4)
9093 EMACS_INT a1;
9094 Lisp_Object a2;
9095 EMACS_INT a3, a4;
9096 {
9097 struct window *w = (struct window *) a1;
9098 Lisp_Object window;
9099 struct text_pos start;
9100 int window_height_changed_p = 0;
9101
9102 9103 9104
9105 window_height_changed_p = resize_mini_window (w, 0);
9106
9107
9108 SET_TEXT_POS_FROM_MARKER (start, w->start);
9109
9110
9111 clear_glyph_matrix (w->desired_matrix);
9112 XSETWINDOW (window, w);
9113 try_window (window, start, 0);
9114
9115 return window_height_changed_p;
9116 }
9117
9118
9119 9120 9121
9122
9123 void
9124 resize_echo_area_exactly ()
9125 {
9126 if (BUFFERP (echo_area_buffer[0])
9127 && WINDOWP (echo_area_window))
9128 {
9129 struct window *w = XWINDOW (echo_area_window);
9130 int resized_p;
9131 Lisp_Object resize_exactly;
9132
9133 if (minibuf_level == 0)
9134 resize_exactly = Qt;
9135 else
9136 resize_exactly = Qnil;
9137
9138 resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
9139 (EMACS_INT) w, resize_exactly, 0, 0);
9140 if (resized_p)
9141 {
9142 ++windows_or_buffers_changed;
9143 ++update_mode_lines;
9144 redisplay_internal (0);
9145 }
9146 }
9147 }
9148
9149
9150 9151 9152 9153 9154
9155
9156 static int
9157 resize_mini_window_1 (a1, exactly, a3, a4)
9158 EMACS_INT a1;
9159 Lisp_Object exactly;
9160 EMACS_INT a3, a4;
9161 {
9162 return resize_mini_window ((struct window *) a1, !NILP (exactly));
9163 }
9164
9165
9166 9167 9168 9169 9170 9171 9172 9173 9174 9175
9176
9177 int
9178 resize_mini_window (w, exact_p)
9179 struct window *w;
9180 int exact_p;
9181 {
9182 struct frame *f = XFRAME (w->frame);
9183 int window_height_changed_p = 0;
9184
9185 xassert (MINI_WINDOW_P (w));
9186
9187
9188 set_marker_both (w->start, w->buffer,
9189 BUF_BEGV (XBUFFER (w->buffer)),
9190 BUF_BEGV_BYTE (XBUFFER (w->buffer)));
9191
9192 9193 9194 9195 9196 9197
9198 if (!NILP (Vinhibit_redisplay))
9199 return 0;
9200
9201
9202 if (NILP (Vresize_mini_windows)
9203 || (FRAME_X_P (f) && FRAME_X_OUTPUT (f) == NULL))
9204 return 0;
9205
9206 if (!FRAME_MINIBUF_ONLY_P (f))
9207 {
9208 struct it it;
9209 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
9210 int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
9211 int height, max_height;
9212 int unit = FRAME_LINE_HEIGHT (f);
9213 struct text_pos start;
9214 struct buffer *old_current_buffer = NULL;
9215
9216 if (current_buffer != XBUFFER (w->buffer))
9217 {
9218 old_current_buffer = current_buffer;
9219 set_buffer_internal (XBUFFER (w->buffer));
9220 }
9221
9222 init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
9223
9224
9225 if (FLOATP (Vmax_mini_window_height))
9226 max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
9227 else if (INTEGERP (Vmax_mini_window_height))
9228 max_height = XINT (Vmax_mini_window_height);
9229 else
9230 max_height = total_height / 4;
9231
9232
9233 max_height = max (1, max_height);
9234 max_height = min (total_height, max_height);
9235
9236
9237 if (it.line_wrap == TRUNCATE)
9238 height = 1;
9239 else
9240 {
9241 last_height = 0;
9242 move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
9243 if (it.max_ascent == 0 && it.max_descent == 0)
9244 height = it.current_y + last_height;
9245 else
9246 height = it.current_y + it.max_ascent + it.max_descent;
9247 height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
9248 height = (height + unit - 1) / unit;
9249 }
9250
9251
9252 if (height > max_height)
9253 {
9254 height = max_height;
9255 init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
9256 move_it_vertically_backward (&it, (height - 1) * unit);
9257 start = it.current.pos;
9258 }
9259 else
9260 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
9261 SET_MARKER_FROM_TEXT_POS (w->start, start);
9262
9263 if (EQ (Vresize_mini_windows, Qgrow_only))
9264 {
9265 9266
9267 if (height > WINDOW_TOTAL_LINES (w))
9268 {
9269 int old_height = WINDOW_TOTAL_LINES (w);
9270 freeze_window_starts (f, 1);
9271 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
9272 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
9273 }
9274 else if (height < WINDOW_TOTAL_LINES (w)
9275 && (exact_p || BEGV == ZV))
9276 {
9277 int old_height = WINDOW_TOTAL_LINES (w);
9278 freeze_window_starts (f, 0);
9279 shrink_mini_window (w);
9280 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
9281 }
9282 }
9283 else
9284 {
9285
9286 if (height > WINDOW_TOTAL_LINES (w))
9287 {
9288 int old_height = WINDOW_TOTAL_LINES (w);
9289 freeze_window_starts (f, 1);
9290 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
9291 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
9292 }
9293 else if (height < WINDOW_TOTAL_LINES (w))
9294 {
9295 int old_height = WINDOW_TOTAL_LINES (w);
9296 freeze_window_starts (f, 0);
9297 shrink_mini_window (w);
9298
9299 if (height)
9300 {
9301 freeze_window_starts (f, 1);
9302 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
9303 }
9304
9305 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
9306 }
9307 }
9308
9309 if (old_current_buffer)
9310 set_buffer_internal (old_current_buffer);
9311 }
9312
9313 return window_height_changed_p;
9314 }
9315
9316
9317 9318
9319
9320 Lisp_Object
9321 current_message ()
9322 {
9323 Lisp_Object msg;
9324
9325 if (!BUFFERP (echo_area_buffer[0]))
9326 msg = Qnil;
9327 else
9328 {
9329 with_echo_area_buffer (0, 0, current_message_1,
9330 (EMACS_INT) &msg, Qnil, 0, 0);
9331 if (NILP (msg))
9332 echo_area_buffer[0] = Qnil;
9333 }
9334
9335 return msg;
9336 }
9337
9338
9339 static int
9340 current_message_1 (a1, a2, a3, a4)
9341 EMACS_INT a1;
9342 Lisp_Object a2;
9343 EMACS_INT a3, a4;
9344 {
9345 Lisp_Object *msg = (Lisp_Object *) a1;
9346
9347 if (Z > BEG)
9348 *msg = make_buffer_string (BEG, Z, 1);
9349 else
9350 *msg = Qnil;
9351 return 0;
9352 }
9353
9354
9355 9356 9357 9358
9359
9360 int
9361 push_message ()
9362 {
9363 Lisp_Object msg;
9364 msg = current_message ();
9365 Vmessage_stack = Fcons (msg, Vmessage_stack);
9366 return STRINGP (msg);
9367 }
9368
9369
9370
9371
9372 void
9373 restore_message ()
9374 {
9375 Lisp_Object msg;
9376
9377 xassert (CONSP (Vmessage_stack));
9378 msg = XCAR (Vmessage_stack);
9379 if (STRINGP (msg))
9380 message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
9381 else
9382 message3_nolog (msg, 0, 0);
9383 }
9384
9385
9386
9387
9388 Lisp_Object
9389 pop_message_unwind (dummy)
9390 Lisp_Object dummy;
9391 {
9392 pop_message ();
9393 return Qnil;
9394 }
9395
9396
9397
9398 void
9399 pop_message ()
9400 {
9401 xassert (CONSP (Vmessage_stack));
9402 Vmessage_stack = XCDR (Vmessage_stack);
9403 }
9404
9405
9406 9407 9408
9409
9410 void
9411 check_message_stack ()
9412 {
9413 if (!NILP (Vmessage_stack))
9414 abort ();
9415 }
9416
9417
9418 9419
9420
9421 void
9422 truncate_echo_area (nchars)
9423 int nchars;
9424 {
9425 if (nchars == 0)
9426 echo_area_buffer[0] = Qnil;
9427 9428 9429
9430 else if (!noninteractive
9431 && INTERACTIVE
9432 && !NILP (echo_area_buffer[0]))
9433 {
9434 struct frame *sf = SELECTED_FRAME ();
9435 if (FRAME_MESSAGE_BUF (sf))
9436 with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil, 0, 0);
9437 }
9438 }
9439
9440
9441 9442
9443
9444 static int
9445 truncate_message_1 (nchars, a2, a3, a4)
9446 EMACS_INT nchars;
9447 Lisp_Object a2;
9448 EMACS_INT a3, a4;
9449 {
9450 if (BEG + nchars < Z)
9451 del_range (BEG + nchars, Z);
9452 if (Z == BEG)
9453 echo_area_buffer[0] = Qnil;
9454 return 0;
9455 }
9456
9457
9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469 9470
9471
9472 void
9473 set_message (s, string, nbytes, multibyte_p)
9474 const char *s;
9475 Lisp_Object string;
9476 int nbytes, multibyte_p;
9477 {
9478 message_enable_multibyte
9479 = ((s && multibyte_p)
9480 || (STRINGP (string) && STRING_MULTIBYTE (string)));
9481
9482 with_echo_area_buffer (0, -1, set_message_1,
9483 (EMACS_INT) s, string, nbytes, multibyte_p);
9484 message_buf_print = 0;
9485 help_echo_showing_p = 0;
9486 }
9487
9488
9489 9490 9491 9492
9493
9494 static int
9495 set_message_1 (a1, a2, nbytes, multibyte_p)
9496 EMACS_INT a1;
9497 Lisp_Object a2;
9498 EMACS_INT nbytes, multibyte_p;
9499 {
9500 const char *s = (const char *) a1;
9501 Lisp_Object string = a2;
9502
9503
9504 if (message_enable_multibyte
9505 != !NILP (current_buffer->enable_multibyte_characters))
9506 Fset_buffer_multibyte (message_enable_multibyte ? Qt : Qnil);
9507
9508 current_buffer->truncate_lines = message_truncate_lines ? Qt : Qnil;
9509
9510
9511 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
9512
9513 if (STRINGP (string))
9514 {
9515 int nchars;
9516
9517 if (nbytes == 0)
9518 nbytes = SBYTES (string);
9519 nchars = string_byte_to_char (string, nbytes);
9520
9521 9522 9523
9524 insert_from_string (string, 0, 0, nchars, nbytes, 1);
9525 }
9526 else if (s)
9527 {
9528 if (nbytes == 0)
9529 nbytes = strlen (s);
9530
9531 if (multibyte_p && NILP (current_buffer->enable_multibyte_characters))
9532 {
9533
9534 int i, c, n;
9535 unsigned char work[1];
9536
9537
9538 for (i = 0; i < nbytes; i += n)
9539 {
9540 c = string_char_and_length (s + i, &n);
9541 work[0] = (ASCII_CHAR_P (c)
9542 ? c
9543 : multibyte_char_to_unibyte (c, Qnil));
9544 insert_1_both (work, 1, 1, 1, 0, 0);
9545 }
9546 }
9547 else if (!multibyte_p
9548 && !NILP (current_buffer->enable_multibyte_characters))
9549 {
9550
9551 int i, c, n;
9552 const unsigned char *msg = (const unsigned char *) s;
9553 unsigned char str[MAX_MULTIBYTE_LENGTH];
9554
9555
9556 for (i = 0; i < nbytes; i++)
9557 {
9558 c = msg[i];
9559 MAKE_CHAR_MULTIBYTE (c);
9560 n = CHAR_STRING (c, str);
9561 insert_1_both (str, 1, n, 1, 0, 0);
9562 }
9563 }
9564 else
9565 insert_1 (s, nbytes, 1, 0, 0);
9566 }
9567
9568 return 0;
9569 }
9570
9571
9572 9573 9574
9575
9576 void
9577 clear_message (current_p, last_displayed_p)
9578 int current_p, last_displayed_p;
9579 {
9580 if (current_p)
9581 {
9582 echo_area_buffer[0] = Qnil;
9583 message_cleared_p = 1;
9584 }
9585
9586 if (last_displayed_p)
9587 echo_area_buffer[1] = Qnil;
9588
9589 message_buf_print = 0;
9590 }
9591
9592 9593 9594 9595 9596 9597 9598 9599
9600
9601 static void
9602 clear_garbaged_frames ()
9603 {
9604 if (frame_garbaged)
9605 {
9606 Lisp_Object tail, frame;
9607 int changed_count = 0;
9608
9609 FOR_EACH_FRAME (tail, frame)
9610 {
9611 struct frame *f = XFRAME (frame);
9612
9613 if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
9614 {
9615 if (f->resized_p)
9616 {
9617 Fredraw_frame (frame);
9618 f->force_flush_display_p = 1;
9619 }
9620 clear_current_matrices (f);
9621 changed_count++;
9622 f->garbaged = 0;
9623 f->resized_p = 0;
9624 }
9625 }
9626
9627 frame_garbaged = 0;
9628 if (changed_count)
9629 ++windows_or_buffers_changed;
9630 }
9631 }
9632
9633
9634 9635 9636
9637
9638 static int
9639 echo_area_display (update_frame_p)
9640 int update_frame_p;
9641 {
9642 Lisp_Object mini_window;
9643 struct window *w;
9644 struct frame *f;
9645 int window_height_changed_p = 0;
9646 struct frame *sf = SELECTED_FRAME ();
9647
9648 mini_window = FRAME_MINIBUF_WINDOW (sf);
9649 w = XWINDOW (mini_window);
9650 f = XFRAME (WINDOW_FRAME (w));
9651
9652
9653 if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
9654 return 0;
9655
9656 #ifdef HAVE_WINDOW_SYSTEM
9657 9658 9659
9660 if (FRAME_INITIAL_P (XFRAME (selected_frame)))
9661 return 0;
9662 #endif
9663
9664
9665 if (frame_garbaged)
9666 clear_garbaged_frames ();
9667
9668 if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
9669 {
9670 echo_area_window = mini_window;
9671 window_height_changed_p = display_echo_area (w);
9672 w->must_be_updated_p = 1;
9673
9674 9675 9676 9677
9678 if (update_frame_p && !redisplaying_p)
9679 {
9680 int n = 0;
9681
9682 9683 9684 9685 9686
9687 if (!display_completed)
9688 n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), 0);
9689
9690 if (window_height_changed_p
9691 9692
9693 && !NILP (Vrun_hooks))
9694 {
9695 9696 9697
9698 int count = SPECPDL_INDEX ();
9699 specbind (Qredisplay_dont_pause, Qt);
9700 windows_or_buffers_changed = 1;
9701 redisplay_internal (0);
9702 unbind_to (count, Qnil);
9703 }
9704 else if (FRAME_WINDOW_P (f) && n == 0)
9705 {
9706 9707 9708
9709 update_single_window (w, 1);
9710 FRAME_RIF (f)->flush_display (f);
9711 }
9712 else
9713 update_frame (f, 1, 1);
9714
9715 9716 9717
9718 if (cursor_in_echo_area)
9719 ++windows_or_buffers_changed;
9720 }
9721 }
9722 else if (!EQ (mini_window, selected_window))
9723 windows_or_buffers_changed++;
9724
9725
9726 echo_area_buffer[1] = echo_area_buffer[0];
9727
9728 echo_message_buffer = Qnil;
9729
9730 9731 9732
9733 if (EQ (mini_window, selected_window))
9734 CHARPOS (this_line_start_pos) = 0;
9735
9736 return window_height_changed_p;
9737 }
9738
9739
9740
9741 9742 9743
9744
9745 9746 9747
9748
9749 static char *mode_line_noprop_buf;
9750
9751
9752
9753 static char *mode_line_noprop_buf_end;
9754 static char *mode_line_noprop_ptr;
9755
9756 #define MODE_LINE_NOPROP_LEN(start) \
9757 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
9758
9759 static enum {
9760 MODE_LINE_DISPLAY = 0,
9761 MODE_LINE_TITLE,
9762 MODE_LINE_NOPROP,
9763 MODE_LINE_STRING
9764 } mode_line_target;
9765
9766 9767
9768 static Lisp_Object mode_line_proptrans_alist;
9769
9770
9771 static Lisp_Object mode_line_string_list;
9772
9773
9774 static Lisp_Object mode_line_string_face;
9775 static Lisp_Object mode_line_string_face_prop;
9776
9777
9778
9779
9780 static Lisp_Object Vmode_line_unwind_vector;
9781
9782 static Lisp_Object
9783 format_mode_line_unwind_data (struct buffer *obuf,
9784 Lisp_Object owin,
9785 int save_proptrans)
9786 {
9787 Lisp_Object vector, tmp;
9788
9789 9790
9791 vector = Vmode_line_unwind_vector;
9792 Vmode_line_unwind_vector = Qnil;
9793
9794 if (NILP (vector))
9795 vector = Fmake_vector (make_number (8), Qnil);
9796
9797 ASET (vector, 0, make_number (mode_line_target));
9798 ASET (vector, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
9799 ASET (vector, 2, mode_line_string_list);
9800 ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
9801 ASET (vector, 4, mode_line_string_face);
9802 ASET (vector, 5, mode_line_string_face_prop);
9803
9804 if (obuf)
9805 XSETBUFFER (tmp, obuf);
9806 else
9807 tmp = Qnil;
9808 ASET (vector, 6, tmp);
9809 ASET (vector, 7, owin);
9810
9811 return vector;
9812 }
9813
9814 static Lisp_Object
9815 unwind_format_mode_line (vector)
9816 Lisp_Object vector;
9817 {
9818 mode_line_target = XINT (AREF (vector, 0));
9819 mode_line_noprop_ptr = mode_line_noprop_buf + XINT (AREF (vector, 1));
9820 mode_line_string_list = AREF (vector, 2);
9821 if (! EQ (AREF (vector, 3), Qt))
9822 mode_line_proptrans_alist = AREF (vector, 3);
9823 mode_line_string_face = AREF (vector, 4);
9824 mode_line_string_face_prop = AREF (vector, 5);
9825
9826 if (!NILP (AREF (vector, 7)))
9827
9828 Fselect_window (AREF (vector, 7), Qt);
9829
9830 if (!NILP (AREF (vector, 6)))
9831 {
9832 set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
9833 ASET (vector, 6, Qnil);
9834 }
9835
9836 Vmode_line_unwind_vector = vector;
9837 return Qnil;
9838 }
9839
9840
9841 9842
9843
9844 static void
9845 #ifdef PROTOTYPES
9846 store_mode_line_noprop_char (char c)
9847 #else
9848 store_mode_line_noprop_char (c)
9849 char c;
9850 #endif
9851 {
9852 9853
9854 if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
9855 {
9856 int len = MODE_LINE_NOPROP_LEN (0);
9857 int new_size = 2 * len * sizeof *mode_line_noprop_buf;
9858 mode_line_noprop_buf = (char *) xrealloc (mode_line_noprop_buf, new_size);
9859 mode_line_noprop_buf_end = mode_line_noprop_buf + new_size;
9860 mode_line_noprop_ptr = mode_line_noprop_buf + len;
9861 }
9862
9863 *mode_line_noprop_ptr++ = c;
9864 }
9865
9866
9867 9868 9869 9870 9871 9872 9873
9874
9875 static int
9876 store_mode_line_noprop (str, field_width, precision)
9877 const unsigned char *str;
9878 int field_width, precision;
9879 {
9880 int n = 0;
9881 int dummy, nbytes;
9882
9883
9884 nbytes = strlen (str);
9885 n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
9886 while (nbytes--)
9887 store_mode_line_noprop_char (*str++);
9888
9889
9890 while (field_width > 0
9891 && n < field_width)
9892 {
9893 store_mode_line_noprop_char (' ');
9894 ++n;
9895 }
9896
9897 return n;
9898 }
9899
9900 9901 9902
9903
9904 #ifdef HAVE_WINDOW_SYSTEM
9905
9906 9907 9908
9909
9910 static void
9911 x_consider_frame_title (frame)
9912 Lisp_Object frame;
9913 {
9914 struct frame *f = XFRAME (frame);
9915
9916 if (FRAME_WINDOW_P (f)
9917 || FRAME_MINIBUF_ONLY_P (f)
9918 || f->explicit_name)
9919 {
9920
9921 Lisp_Object tail;
9922 Lisp_Object fmt;
9923 int title_start;
9924 char *title;
9925 int len;
9926 struct it it;
9927 int count = SPECPDL_INDEX ();
9928
9929 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
9930 {
9931 Lisp_Object other_frame = XCAR (tail);
9932 struct frame *tf = XFRAME (other_frame);
9933
9934 if (tf != f
9935 && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
9936 && !FRAME_MINIBUF_ONLY_P (tf)
9937 && !EQ (other_frame, tip_frame)
9938 && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
9939 break;
9940 }
9941
9942
9943 multiple_frames = CONSP (tail);
9944
9945 9946 9947
9948 record_unwind_protect (unwind_format_mode_line,
9949 format_mode_line_unwind_data
9950 (current_buffer, selected_window, 0));
9951
9952 Fselect_window (f->selected_window, Qt);
9953 set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->buffer));
9954 fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
9955
9956 mode_line_target = MODE_LINE_TITLE;
9957 title_start = MODE_LINE_NOPROP_LEN (0);
9958 init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
9959 NULL, DEFAULT_FACE_ID);
9960 display_mode_element (&it, 0, -1, -1, fmt, Qnil, 0);
9961 len = MODE_LINE_NOPROP_LEN (title_start);
9962 title = mode_line_noprop_buf + title_start;
9963 unbind_to (count, Qnil);
9964
9965 9966 9967 9968 9969
9970 if (! STRINGP (f->name)
9971 || SBYTES (f->name) != len
9972 || bcmp (title, SDATA (f->name), len) != 0)
9973 x_implicitly_set_name (f, make_string (title, len), Qnil);
9974 }
9975 }
9976
9977 #endif
9978
9979
9980
9981
9982 9983 9984
9985
9986
9987 9988
9989
9990 void
9991 prepare_menu_bars ()
9992 {
9993 int all_windows;
9994 struct gcpro gcpro1, gcpro2;
9995 struct frame *f;
9996 Lisp_Object tooltip_frame;
9997
9998 #ifdef HAVE_WINDOW_SYSTEM
9999 tooltip_frame = tip_frame;
10000 #else
10001 tooltip_frame = Qnil;
10002 #endif
10003
10004 10005 10006
10007 #ifdef HAVE_WINDOW_SYSTEM
10008 if (windows_or_buffers_changed || update_mode_lines)
10009 {
10010 Lisp_Object tail, frame;
10011
10012 FOR_EACH_FRAME (tail, frame)
10013 {
10014 f = XFRAME (frame);
10015 if (!EQ (frame, tooltip_frame)
10016 && (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)))
10017 x_consider_frame_title (frame);
10018 }
10019 }
10020 #endif
10021
10022 10023
10024 all_windows = (update_mode_lines
10025 || buffer_shared > 1
10026 || windows_or_buffers_changed);
10027 if (all_windows)
10028 {
10029 Lisp_Object tail, frame;
10030 int count = SPECPDL_INDEX ();
10031 10032
10033 int menu_bar_hooks_run = 0;
10034
10035 record_unwind_save_match_data ();
10036
10037 FOR_EACH_FRAME (tail, frame)
10038 {
10039 f = XFRAME (frame);
10040
10041
10042 if (EQ (frame, tooltip_frame))
10043 continue;
10044
10045 10046
10047 if (FRAME_WINDOW_SIZES_CHANGED (f))
10048 {
10049 Lisp_Object functions;
10050
10051
10052 FRAME_WINDOW_SIZES_CHANGED (f) = 0;
10053 functions = Vwindow_size_change_functions;
10054 GCPRO2 (tail, functions);
10055
10056 while (CONSP (functions))
10057 {
10058 if (!EQ (XCAR (functions), Qt))
10059 call1 (XCAR (functions), frame);
10060 functions = XCDR (functions);
10061 }
10062 UNGCPRO;
10063 }
10064
10065 GCPRO1 (tail);
10066 menu_bar_hooks_run = update_menu_bar (f, 0, menu_bar_hooks_run);
10067 #ifdef HAVE_WINDOW_SYSTEM
10068 update_tool_bar (f, 0);
10069 #endif
10070 #ifdef HAVE_NS
10071 if (windows_or_buffers_changed
10072 && FRAME_NS_P (f))
10073 ns_set_doc_edited (f, Fbuffer_modified_p
10074 (XWINDOW (f->selected_window)->buffer));
10075 #endif
10076 UNGCPRO;
10077 }
10078
10079 unbind_to (count, Qnil);
10080 }
10081 else
10082 {
10083 struct frame *sf = SELECTED_FRAME ();
10084 update_menu_bar (sf, 1, 0);
10085 #ifdef HAVE_WINDOW_SYSTEM
10086 update_tool_bar (sf, 1);
10087 #endif
10088 }
10089
10090 10091
10092 #ifdef USE_X_TOOLKIT
10093 pending_menu_activation = 0;
10094 #endif
10095 }
10096
10097
10098 10099 10100 10101 10102 10103 10104 10105 10106 10107
10108
10109 static int
10110 update_menu_bar (f, save_match_data, hooks_run)
10111 struct frame *f;
10112 int save_match_data;
10113 int hooks_run;
10114 {
10115 Lisp_Object window;
10116 register struct window *w;
10117
10118 10119 10120
10121 if (inhibit_menubar_update)
10122 return hooks_run;
10123
10124 window = FRAME_SELECTED_WINDOW (f);
10125 w = XWINDOW (window);
10126
10127 if (FRAME_WINDOW_P (f)
10128 ?
10129 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10130 || defined (HAVE_NS) || defined (USE_GTK)
10131 FRAME_EXTERNAL_MENU_BAR (f)
10132 #else
10133 FRAME_MENU_BAR_LINES (f) > 0
10134 #endif
10135 : FRAME_MENU_BAR_LINES (f) > 0)
10136 {
10137 10138 10139 10140 10141 10142 10143
10144 if (windows_or_buffers_changed
10145 10146
10147 || update_mode_lines
10148 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
10149 < BUF_MODIFF (XBUFFER (w->buffer)))
10150 != !NILP (w->last_had_star))
10151 || ((!NILP (Vtransient_mark_mode)
10152 && !NILP (XBUFFER (w->buffer)->mark_active))
10153 != !NILP (w->region_showing)))
10154 {
10155 struct buffer *prev = current_buffer;
10156 int count = SPECPDL_INDEX ();
10157
10158 specbind (Qinhibit_menubar_update, Qt);
10159
10160 set_buffer_internal_1 (XBUFFER (w->buffer));
10161 if (save_match_data)
10162 record_unwind_save_match_data ();
10163 if (NILP (Voverriding_local_map_menu_flag))
10164 {
10165 specbind (Qoverriding_terminal_local_map, Qnil);
10166 specbind (Qoverriding_local_map, Qnil);
10167 }
10168
10169 if (!hooks_run)
10170 {
10171
10172 safe_run_hooks (Qactivate_menubar_hook);
10173
10174 10175
10176 if (! NILP (Vlucid_menu_bar_dirty_flag))
10177 call0 (Qrecompute_lucid_menubar);
10178
10179 safe_run_hooks (Qmenu_bar_update_hook);
10180
10181 hooks_run = 1;
10182 }
10183
10184 XSETFRAME (Vmenu_updating_frame, f);
10185 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
10186
10187
10188 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10189 || defined (HAVE_NS) || defined (USE_GTK)
10190 if (FRAME_WINDOW_P (f))
10191 {
10192 #if defined (HAVE_NS)
10193 10194
10195 if (f == SELECTED_FRAME ())
10196 #endif
10197 set_frame_menubar (f, 0, 0);
10198 }
10199 else
10200 10201
10202 w->update_mode_line = Qt;
10203 #else
10204 10205
10206 w->update_mode_line = Qt;
10207 #endif
10208
10209 unbind_to (count, Qnil);
10210 set_buffer_internal_1 (prev);
10211 }
10212 }
10213
10214 return hooks_run;
10215 }
10216
10217
10218
10219 10220 10221
10222
10223 #ifdef HAVE_WINDOW_SYSTEM
10224
10225 10226 10227 10228
10229
10230 struct cursor_pos output_cursor;
10231
10232
10233 10234 10235
10236
10237 void
10238 set_output_cursor (cursor)
10239 struct cursor_pos *cursor;
10240 {
10241 output_cursor.hpos = cursor->hpos;
10242 output_cursor.vpos = cursor->vpos;
10243 output_cursor.x = cursor->x;
10244 output_cursor.y = cursor->y;
10245 }
10246
10247
10248 10249 10250 10251 10252 10253 10254 10255 10256 10257
10258
10259 void
10260 x_cursor_to (vpos, hpos, y, x)
10261 int vpos, hpos, y, x;
10262 {
10263 struct window *w;
10264
10265
10266 if (updated_window)
10267 w = updated_window;
10268 else
10269 w = XWINDOW (selected_window);
10270
10271
10272 output_cursor.hpos = hpos;
10273 output_cursor.vpos = vpos;
10274 output_cursor.x = x;
10275 output_cursor.y = y;
10276
10277 10278
10279 if (updated_window == NULL)
10280 {
10281 BLOCK_INPUT;
10282 display_and_set_cursor (w, 1, hpos, vpos, x, y);
10283 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
10284 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
10285 UNBLOCK_INPUT;
10286 }
10287 }
10288
10289 #endif
10290
10291
10292 10293 10294
10295
10296 #ifdef HAVE_WINDOW_SYSTEM
10297
10298
10299
10300 FRAME_PTR last_mouse_frame;
10301
10302 10303
10304
10305 int last_tool_bar_item;
10306
10307
10308 static Lisp_Object
10309 update_tool_bar_unwind (frame)
10310 Lisp_Object frame;
10311 {
10312 selected_frame = frame;
10313 return Qnil;
10314 }
10315
10316 10317 10318 10319
10320
10321 static void
10322 update_tool_bar (f, save_match_data)
10323 struct frame *f;
10324 int save_match_data;
10325 {
10326 #if defined (USE_GTK) || defined (HAVE_NS)
10327 int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
10328 #else
10329 int do_update = WINDOWP (f->tool_bar_window)
10330 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
10331 #endif
10332
10333 if (do_update)
10334 {
10335 Lisp_Object window;
10336 struct window *w;
10337
10338 window = FRAME_SELECTED_WINDOW (f);
10339 w = XWINDOW (window);
10340
10341 10342 10343 10344 10345 10346 10347
10348 if (windows_or_buffers_changed
10349 || !NILP (w->update_mode_line)
10350 || update_mode_lines
10351 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
10352 < BUF_MODIFF (XBUFFER (w->buffer)))
10353 != !NILP (w->last_had_star))
10354 || ((!NILP (Vtransient_mark_mode)
10355 && !NILP (XBUFFER (w->buffer)->mark_active))
10356 != !NILP (w->region_showing)))
10357 {
10358 struct buffer *prev = current_buffer;
10359 int count = SPECPDL_INDEX ();
10360 Lisp_Object frame, new_tool_bar;
10361 int new_n_tool_bar;
10362 struct gcpro gcpro1;
10363
10364 10365 10366
10367 set_buffer_internal_1 (XBUFFER (w->buffer));
10368
10369
10370 if (save_match_data)
10371 record_unwind_save_match_data ();
10372
10373
10374 if (NILP (Voverriding_local_map_menu_flag))
10375 {
10376 specbind (Qoverriding_terminal_local_map, Qnil);
10377 specbind (Qoverriding_local_map, Qnil);
10378 }
10379
10380 GCPRO1 (new_tool_bar);
10381
10382 10383 10384 10385
10386 record_unwind_protect (update_tool_bar_unwind, selected_frame);
10387 XSETFRAME (frame, f);
10388 selected_frame = frame;
10389
10390
10391 new_tool_bar = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
10392 &new_n_tool_bar);
10393
10394
10395 if (new_n_tool_bar != f->n_tool_bar_items
10396 || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
10397 {
10398 10399 10400
10401 BLOCK_INPUT;
10402 f->tool_bar_items = new_tool_bar;
10403 f->n_tool_bar_items = new_n_tool_bar;
10404 w->update_mode_line = Qt;
10405 UNBLOCK_INPUT;
10406 }
10407
10408 UNGCPRO;
10409
10410 unbind_to (count, Qnil);
10411 set_buffer_internal_1 (prev);
10412 }
10413 }
10414 }
10415
10416
10417 10418 10419
10420
10421 static void
10422 build_desired_tool_bar_string (f)
10423 struct frame *f;
10424 {
10425 int i, size, size_needed;
10426 struct gcpro gcpro1, gcpro2, gcpro3;
10427 Lisp_Object image, plist, props;
10428
10429 image = plist = props = Qnil;
10430 GCPRO3 (image, plist, props);
10431
10432 10433
10434
10435
10436 size = (STRINGP (f->desired_tool_bar_string)
10437 ? SCHARS (f->desired_tool_bar_string)
10438 : 0);
10439
10440
10441 size_needed = f->n_tool_bar_items;
10442
10443
10444 if (size < size_needed || NILP (f->desired_tool_bar_string))
10445 f->desired_tool_bar_string = Fmake_string (make_number (size_needed),
10446 make_number (' '));
10447 else
10448 {
10449 props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
10450 Fremove_text_properties (make_number (0), make_number (size),
10451 props, f->desired_tool_bar_string);
10452 }
10453
10454 10455 10456
10457 for (i = 0; i < f->n_tool_bar_items; ++i)
10458 {
10459 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
10460
10461 int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
10462 int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
10463 int hmargin, vmargin, relief, idx, end;
10464 extern Lisp_Object QCrelief, QCmargin, QCconversion;
10465
10466 10467
10468 image = PROP (TOOL_BAR_ITEM_IMAGES);
10469 if (VECTORP (image))
10470 {
10471 if (enabled_p)
10472 idx = (selected_p
10473 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
10474 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
10475 else
10476 idx = (selected_p
10477 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
10478 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
10479
10480 xassert (ASIZE (image) >= idx);
10481 image = AREF (image, idx);
10482 }
10483 else
10484 idx = -1;
10485
10486
10487 if (!valid_image_p (image))
10488 continue;
10489
10490
10491 plist = Fcopy_sequence (XCDR (image));
10492
10493
10494 relief = (tool_bar_button_relief >= 0
10495 ? tool_bar_button_relief
10496 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
10497 hmargin = vmargin = relief;
10498
10499 if (INTEGERP (Vtool_bar_button_margin)
10500 && XINT (Vtool_bar_button_margin) > 0)
10501 {
10502 hmargin += XFASTINT (Vtool_bar_button_margin);
10503 vmargin += XFASTINT (Vtool_bar_button_margin);
10504 }
10505 else if (CONSP (Vtool_bar_button_margin))
10506 {
10507 if (INTEGERP (XCAR (Vtool_bar_button_margin))
10508 && XINT (XCAR (Vtool_bar_button_margin)) > 0)
10509 hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
10510
10511 if (INTEGERP (XCDR (Vtool_bar_button_margin))
10512 && XINT (XCDR (Vtool_bar_button_margin)) > 0)
10513 vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
10514 }
10515
10516 if (auto_raise_tool_bar_buttons_p)
10517 {
10518 10519
10520 if (selected_p)
10521 {
10522 plist = Fplist_put (plist, QCrelief, make_number (-relief));
10523 hmargin -= relief;
10524 vmargin -= relief;
10525 }
10526 }
10527 else
10528 {
10529 10530 10531
10532 plist = Fplist_put (plist, QCrelief,
10533 (selected_p
10534 ? make_number (-relief)
10535 : make_number (relief)));
10536 hmargin -= relief;
10537 vmargin -= relief;
10538 }
10539
10540
10541 if (hmargin || vmargin)
10542 {
10543 if (hmargin == vmargin)
10544 plist = Fplist_put (plist, QCmargin, make_number (hmargin));
10545 else
10546 plist = Fplist_put (plist, QCmargin,
10547 Fcons (make_number (hmargin),
10548 make_number (vmargin)));
10549 }
10550
10551 10552 10553
10554 if (!enabled_p && idx < 0)
10555 plist = Fplist_put (plist, QCconversion, Qdisabled);
10556
10557 10558 10559 10560
10561 image = Fcons (Qimage, plist);
10562 props = list4 (Qdisplay, image,
10563 Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
10564
10565 10566 10567
10568 if (i + 1 == f->n_tool_bar_items)
10569 end = SCHARS (f->desired_tool_bar_string);
10570 else
10571 end = i + 1;
10572 Fadd_text_properties (make_number (i), make_number (end),
10573 props, f->desired_tool_bar_string);
10574 #undef PROP
10575 }
10576
10577 UNGCPRO;
10578 }
10579
10580
10581 10582 10583 10584 10585 10586 10587 10588 10589 10590 10591
10592
10593 static void
10594 display_tool_bar_line (it, height)
10595 struct it *it;
10596 int height;
10597 {
10598 struct glyph_row *row = it->glyph_row;
10599 int max_x = it->last_visible_x;
10600 struct glyph *last;
10601
10602 prepare_desired_row (row);
10603 row->y = it->current_y;
10604
10605 10606
10607 it->start_of_box_run_p = 1;
10608
10609 while (it->current_x < max_x)
10610 {
10611 int x, n_glyphs_before, i, nglyphs;
10612 struct it it_before;
10613
10614
10615 if (!get_next_display_element (it))
10616 {
10617
10618 if (height < 0 && !it->hpos)
10619 return;
10620 break;
10621 }
10622
10623
10624 n_glyphs_before = row->used[TEXT_AREA];
10625 it_before = *it;
10626
10627 PRODUCE_GLYPHS (it);
10628
10629 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
10630 i = 0;
10631 x = it_before.current_x;
10632 while (i < nglyphs)
10633 {
10634 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
10635
10636 if (x + glyph->pixel_width > max_x)
10637 {
10638
10639 row->used[TEXT_AREA] = n_glyphs_before;
10640 *it = it_before;
10641 10642 10643
10644 if (n_glyphs_before == 0
10645 && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
10646 break;
10647 goto out;
10648 }
10649
10650 ++it->hpos;
10651 x += glyph->pixel_width;
10652 ++i;
10653 }
10654
10655
10656 if (ITERATOR_AT_END_OF_LINE_P (it))
10657 break;
10658
10659 set_iterator_to_next (it, 1);
10660 }
10661
10662 out:;
10663
10664 row->displays_text_p = row->used[TEXT_AREA] != 0;
10665
10666 10667 10668 10669 10670 10671
10672 if (!row->displays_text_p && !EQ (Vauto_resize_tool_bars, Qgrow_only))
10673 it->face_id = DEFAULT_FACE_ID;
10674
10675 extend_face_to_end_of_line (it);
10676 last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
10677 last->right_box_line_p = 1;
10678 if (last == row->glyphs[TEXT_AREA])
10679 last->left_box_line_p = 1;
10680
10681
10682 if ((height -= it->max_ascent + it->max_descent) > 0)
10683 {
10684
10685 height %= FRAME_LINE_HEIGHT (it->f);
10686 it->max_ascent += height / 2;
10687 it->max_descent += (height + 1) / 2;
10688 }
10689
10690 compute_line_metrics (it);
10691
10692
10693 if (!row->displays_text_p)
10694 {
10695 row->height = row->phys_height = it->last_visible_y - row->y;
10696 row->visible_height = row->height;
10697 row->ascent = row->phys_ascent = 0;
10698 row->extra_line_spacing = 0;
10699 }
10700
10701 row->full_width_p = 1;
10702 row->continued_p = 0;
10703 row->truncated_on_left_p = 0;
10704 row->truncated_on_right_p = 0;
10705
10706 it->current_x = it->hpos = 0;
10707 it->current_y += row->height;
10708 ++it->vpos;
10709 ++it->glyph_row;
10710 }
10711
10712
10713
10714
10715 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
10716 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
10717
10718 10719 10720
10721
10722 static int
10723 tool_bar_lines_needed (f, n_rows)
10724 struct frame *f;
10725 int *n_rows;
10726 {
10727 struct window *w = XWINDOW (f->tool_bar_window);
10728 struct it it;
10729 10730 10731
10732 struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
10733
10734 10735
10736 init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
10737 it.first_visible_x = 0;
10738 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10739 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10740
10741 while (!ITERATOR_AT_END_P (&it))
10742 {
10743 clear_glyph_row (temp_row);
10744 it.glyph_row = temp_row;
10745 display_tool_bar_line (&it, -1);
10746 }
10747 clear_glyph_row (temp_row);
10748
10749
10750 if (n_rows)
10751 *n_rows = it.vpos > 0 ? it.vpos : -1;
10752
10753 return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
10754 }
10755
10756
10757 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
10758 0, 1, 0,
10759 doc: )
10760 (frame)
10761 Lisp_Object frame;
10762 {
10763 struct frame *f;
10764 struct window *w;
10765 int nlines = 0;
10766
10767 if (NILP (frame))
10768 frame = selected_frame;
10769 else
10770 CHECK_FRAME (frame);
10771 f = XFRAME (frame);
10772
10773 if (WINDOWP (f->tool_bar_window)
10774 || (w = XWINDOW (f->tool_bar_window),
10775 WINDOW_TOTAL_LINES (w) > 0))
10776 {
10777 update_tool_bar (f, 1);
10778 if (f->n_tool_bar_items)
10779 {
10780 build_desired_tool_bar_string (f);
10781 nlines = tool_bar_lines_needed (f, NULL);
10782 }
10783 }
10784
10785 return make_number (nlines);
10786 }
10787
10788
10789 10790
10791
10792 static int
10793 redisplay_tool_bar (f)
10794 struct frame *f;
10795 {
10796 struct window *w;
10797 struct it it;
10798 struct glyph_row *row;
10799
10800 #if defined (USE_GTK) || defined (HAVE_NS)
10801 if (FRAME_EXTERNAL_TOOL_BAR (f))
10802 update_frame_tool_bar (f);
10803 return 0;
10804 #endif
10805
10806 10807 10808 10809
10810 if (!WINDOWP (f->tool_bar_window)
10811 || (w = XWINDOW (f->tool_bar_window),
10812 WINDOW_TOTAL_LINES (w) == 0))
10813 return 0;
10814
10815
10816 init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
10817 it.first_visible_x = 0;
10818 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10819 row = it.glyph_row;
10820
10821
10822 build_desired_tool_bar_string (f);
10823 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10824
10825 if (f->n_tool_bar_rows == 0)
10826 {
10827 int nlines;
10828
10829 if ((nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows),
10830 nlines != WINDOW_TOTAL_LINES (w)))
10831 {
10832 extern Lisp_Object Qtool_bar_lines;
10833 Lisp_Object frame;
10834 int old_height = WINDOW_TOTAL_LINES (w);
10835
10836 XSETFRAME (frame, f);
10837 Fmodify_frame_parameters (frame,
10838 Fcons (Fcons (Qtool_bar_lines,
10839 make_number (nlines)),
10840 Qnil));
10841 if (WINDOW_TOTAL_LINES (w) != old_height)
10842 {
10843 clear_glyph_matrix (w->desired_matrix);
10844 fonts_changed_p = 1;
10845 return 1;
10846 }
10847 }
10848 }
10849
10850
10851
10852 if (f->n_tool_bar_rows > 0)
10853 {
10854 int border, rows, height, extra;
10855
10856 if (INTEGERP (Vtool_bar_border))
10857 border = XINT (Vtool_bar_border);
10858 else if (EQ (Vtool_bar_border, Qinternal_border_width))
10859 border = FRAME_INTERNAL_BORDER_WIDTH (f);
10860 else if (EQ (Vtool_bar_border, Qborder_width))
10861 border = f->border_width;
10862 else
10863 border = 0;
10864 if (border < 0)
10865 border = 0;
10866
10867 rows = f->n_tool_bar_rows;
10868 height = max (1, (it.last_visible_y - border) / rows);
10869 extra = it.last_visible_y - border - height * rows;
10870
10871 while (it.current_y < it.last_visible_y)
10872 {
10873 int h = 0;
10874 if (extra > 0 && rows-- > 0)
10875 {
10876 h = (extra + rows - 1) / rows;
10877 extra -= h;
10878 }
10879 display_tool_bar_line (&it, height + h);
10880 }
10881 }
10882 else
10883 {
10884 while (it.current_y < it.last_visible_y)
10885 display_tool_bar_line (&it, 0);
10886 }
10887
10888 10889
10890 w->desired_matrix->no_scrolling_p = 1;
10891 w->must_be_updated_p = 1;
10892
10893 if (!NILP (Vauto_resize_tool_bars))
10894 {
10895 int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f);
10896 int change_height_p = 0;
10897
10898 10899
10900 if (IT_STRING_CHARPOS (it) < it.end_charpos
10901 && it.current_y < max_tool_bar_height)
10902 change_height_p = 1;
10903
10904 row = it.glyph_row - 1;
10905
10906 10907 10908
10909 if (!row->displays_text_p
10910 && row->height >= FRAME_LINE_HEIGHT (f))
10911 change_height_p = 1;
10912
10913 10914
10915 if (row->displays_text_p
10916 && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y
10917 && MATRIX_ROW_BOTTOM_Y (row) < max_tool_bar_height)
10918 change_height_p = 1;
10919
10920 10921
10922 if (change_height_p)
10923 {
10924 extern Lisp_Object Qtool_bar_lines;
10925 Lisp_Object frame;
10926 int old_height = WINDOW_TOTAL_LINES (w);
10927 int nrows;
10928 int nlines = tool_bar_lines_needed (f, &nrows);
10929
10930 change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
10931 && !f->minimize_tool_bar_window_p)
10932 ? (nlines > old_height)
10933 : (nlines != old_height));
10934 f->minimize_tool_bar_window_p = 0;
10935
10936 if (change_height_p)
10937 {
10938 XSETFRAME (frame, f);
10939 Fmodify_frame_parameters (frame,
10940 Fcons (Fcons (Qtool_bar_lines,
10941 make_number (nlines)),
10942 Qnil));
10943 if (WINDOW_TOTAL_LINES (w) != old_height)
10944 {
10945 clear_glyph_matrix (w->desired_matrix);
10946 f->n_tool_bar_rows = nrows;
10947 fonts_changed_p = 1;
10948 return 1;
10949 }
10950 }
10951 }
10952 }
10953
10954 f->minimize_tool_bar_window_p = 0;
10955 return 0;
10956 }
10957
10958
10959 10960 10961 10962
10963
10964 static int
10965 tool_bar_item_info (f, glyph, prop_idx)
10966 struct frame *f;
10967 struct glyph *glyph;
10968 int *prop_idx;
10969 {
10970 Lisp_Object prop;
10971 int success_p;
10972 int charpos;
10973
10974 10975 10976
10977 charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
10978 charpos = max (0, charpos);
10979
10980 10981 10982
10983 prop = Fget_text_property (make_number (charpos),
10984 Qmenu_item, f->current_tool_bar_string);
10985 if (INTEGERP (prop))
10986 {
10987 *prop_idx = XINT (prop);
10988 success_p = 1;
10989 }
10990 else
10991 success_p = 0;
10992
10993 return success_p;
10994 }
10995
10996
10997 10998 10999 11000 11001 11002 11003 11004 11005
11006
11007 static int
11008 get_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
11009 struct frame *f;
11010 int x, y;
11011 struct glyph **glyph;
11012 int *hpos, *vpos, *prop_idx;
11013 {
11014 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11015 struct window *w = XWINDOW (f->tool_bar_window);
11016 int area;
11017
11018
11019 *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
11020 if (*glyph == NULL)
11021 return -1;
11022
11023 11024
11025 if (!tool_bar_item_info (f, *glyph, prop_idx))
11026 return -1;
11027
11028
11029 if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
11030 && *vpos >= dpyinfo->mouse_face_beg_row
11031 && *vpos <= dpyinfo->mouse_face_end_row
11032 && (*vpos > dpyinfo->mouse_face_beg_row
11033 || *hpos >= dpyinfo->mouse_face_beg_col)
11034 && (*vpos < dpyinfo->mouse_face_end_row
11035 || *hpos < dpyinfo->mouse_face_end_col
11036 || dpyinfo->mouse_face_past_end))
11037 return 0;
11038
11039 return 1;
11040 }
11041
11042
11043 11044 11045 11046 11047
11048
11049 void
11050 handle_tool_bar_click (f, x, y, down_p, modifiers)
11051 struct frame *f;
11052 int x, y, down_p;
11053 unsigned int modifiers;
11054 {
11055 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11056 struct window *w = XWINDOW (f->tool_bar_window);
11057 int hpos, vpos, prop_idx;
11058 struct glyph *glyph;
11059 Lisp_Object enabled_p;
11060
11061
11062 frame_to_window_pixel_xy (w, &x, &y);
11063 if (get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
11064 return;
11065
11066
11067 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11068 if (NILP (enabled_p))
11069 return;
11070
11071 if (down_p)
11072 {
11073
11074 show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
11075 dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
11076 last_tool_bar_item = prop_idx;
11077 }
11078 else
11079 {
11080 Lisp_Object key, frame;
11081 struct input_event event;
11082 EVENT_INIT (event);
11083
11084
11085 show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
11086 dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
11087
11088 key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
11089
11090 XSETFRAME (frame, f);
11091 event.kind = TOOL_BAR_EVENT;
11092 event.frame_or_window = frame;
11093 event.arg = frame;
11094 kbd_buffer_store_event (&event);
11095
11096 event.kind = TOOL_BAR_EVENT;
11097 event.frame_or_window = frame;
11098 event.arg = key;
11099 event.modifiers = modifiers;
11100 kbd_buffer_store_event (&event);
11101 last_tool_bar_item = -1;
11102 }
11103 }
11104
11105
11106 11107 11108
11109
11110 static void
11111 note_tool_bar_highlight (f, x, y)
11112 struct frame *f;
11113 int x, y;
11114 {
11115 Lisp_Object window = f->tool_bar_window;
11116 struct window *w = XWINDOW (window);
11117 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11118 int hpos, vpos;
11119 struct glyph *glyph;
11120 struct glyph_row *row;
11121 int i;
11122 Lisp_Object enabled_p;
11123 int prop_idx;
11124 enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
11125 int mouse_down_p, rc;
11126
11127 11128
11129 if (x <= 0 || y <= 0)
11130 {
11131 clear_mouse_face (dpyinfo);
11132 return;
11133 }
11134
11135 rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
11136 if (rc < 0)
11137 {
11138
11139 clear_mouse_face (dpyinfo);
11140 return;
11141 }
11142 else if (rc == 0)
11143
11144 goto set_help_echo;
11145
11146 clear_mouse_face (dpyinfo);
11147
11148
11149 mouse_down_p = (dpyinfo->grabbed
11150 && f == last_mouse_frame
11151 && FRAME_LIVE_P (f));
11152 if (mouse_down_p
11153 && last_tool_bar_item != prop_idx)
11154 return;
11155
11156 dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
11157 draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
11158
11159
11160 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11161 if (!NILP (enabled_p))
11162 {
11163 11164
11165 row = MATRIX_ROW (w->current_matrix, vpos);
11166 for (i = x = 0; i < hpos; ++i)
11167 x += row->glyphs[TEXT_AREA][i].pixel_width;
11168
11169
11170 dpyinfo->mouse_face_beg_col = hpos;
11171 dpyinfo->mouse_face_beg_row = vpos;
11172 dpyinfo->mouse_face_beg_x = x;
11173 dpyinfo->mouse_face_beg_y = row->y;
11174 dpyinfo->mouse_face_past_end = 0;
11175
11176 dpyinfo->mouse_face_end_col = hpos + 1;
11177 dpyinfo->mouse_face_end_row = vpos;
11178 dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
11179 dpyinfo->mouse_face_end_y = row->y;
11180 dpyinfo->mouse_face_window = window;
11181 dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
11182
11183
11184 show_mouse_face (dpyinfo, draw);
11185 dpyinfo->mouse_face_image_state = draw;
11186 }
11187
11188 set_help_echo:
11189
11190 11191
11192 help_echo_object = help_echo_window = Qnil;
11193 help_echo_pos = -1;
11194 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
11195 if (NILP (help_echo_string))
11196 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
11197 }
11198
11199 #endif
11200
11201
11202
11203 11204 11205
11206
11207 static int hscroll_window_tree P_ ((Lisp_Object));
11208 static int hscroll_windows P_ ((Lisp_Object));
11209
11210 11211 11212 11213 11214
11215
11216 static int
11217 hscroll_window_tree (window)
11218 Lisp_Object window;
11219 {
11220 int hscrolled_p = 0;
11221 int hscroll_relative_p = FLOATP (Vhscroll_step);
11222 int hscroll_step_abs = 0;
11223 double hscroll_step_rel = 0;
11224
11225 if (hscroll_relative_p)
11226 {
11227 hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
11228 if (hscroll_step_rel < 0)
11229 {
11230 hscroll_relative_p = 0;
11231 hscroll_step_abs = 0;
11232 }
11233 }
11234 else if (INTEGERP (Vhscroll_step))
11235 {
11236 hscroll_step_abs = XINT (Vhscroll_step);
11237 if (hscroll_step_abs < 0)
11238 hscroll_step_abs = 0;
11239 }
11240 else
11241 hscroll_step_abs = 0;
11242
11243 while (WINDOWP (window))
11244 {
11245 struct window *w = XWINDOW (window);
11246
11247 if (WINDOWP (w->hchild))
11248 hscrolled_p |= hscroll_window_tree (w->hchild);
11249 else if (WINDOWP (w->vchild))
11250 hscrolled_p |= hscroll_window_tree (w->vchild);
11251 else if (w->cursor.vpos >= 0)
11252 {
11253 int h_margin;
11254 int text_area_width;
11255 struct glyph_row *current_cursor_row
11256 = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
11257 struct glyph_row *desired_cursor_row
11258 = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
11259 struct glyph_row *cursor_row
11260 = (desired_cursor_row->enabled_p
11261 ? desired_cursor_row
11262 : current_cursor_row);
11263
11264 text_area_width = window_box_width (w, TEXT_AREA);
11265
11266
11267 h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
11268
11269 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
11270 && ((XFASTINT (w->hscroll)
11271 && w->cursor.x <= h_margin)
11272 || (cursor_row->enabled_p
11273 && cursor_row->truncated_on_right_p
11274 && (w->cursor.x >= text_area_width - h_margin))))
11275 {
11276 struct it it;
11277 int hscroll;
11278 struct buffer *saved_current_buffer;
11279 int pt;
11280 int wanted_x;
11281
11282
11283 saved_current_buffer = current_buffer;
11284 current_buffer = XBUFFER (w->buffer);
11285
11286 if (w == XWINDOW (selected_window))
11287 pt = BUF_PT (current_buffer);
11288 else
11289 {
11290 pt = marker_position (w->pointm);
11291 pt = max (BEGV, pt);
11292 pt = min (ZV, pt);
11293 }
11294
11295 11296
11297 init_to_row_start (&it, w, cursor_row);
11298 it.last_visible_x = INFINITY;
11299 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
11300 current_buffer = saved_current_buffer;
11301
11302
11303 if (!hscroll_relative_p && hscroll_step_abs == 0)
11304 hscroll = max (0, (it.current_x
11305 - (ITERATOR_AT_END_OF_LINE_P (&it)
11306 ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
11307 : (text_area_width / 2))))
11308 / FRAME_COLUMN_WIDTH (it.f);
11309 else if (w->cursor.x >= text_area_width - h_margin)
11310 {
11311 if (hscroll_relative_p)
11312 wanted_x = text_area_width * (1 - hscroll_step_rel)
11313 - h_margin;
11314 else
11315 wanted_x = text_area_width
11316 - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
11317 - h_margin;
11318 hscroll
11319 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
11320 }
11321 else
11322 {
11323 if (hscroll_relative_p)
11324 wanted_x = text_area_width * hscroll_step_rel
11325 + h_margin;
11326 else
11327 wanted_x = hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
11328 + h_margin;
11329 hscroll
11330 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
11331 }
11332 hscroll = max (hscroll, XFASTINT (w->min_hscroll));
11333
11334 11335 11336
11337 if (XFASTINT (w->hscroll) != hscroll)
11338 {
11339 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
11340 w->hscroll = make_number (hscroll);
11341 hscrolled_p = 1;
11342 }
11343 }
11344 }
11345
11346 window = w->next;
11347 }
11348
11349
11350 return hscrolled_p;
11351 }
11352
11353
11354 11355 11356 11357 11358
11359
11360 static int
11361 hscroll_windows (window)
11362 Lisp_Object window;
11363 {
11364 int hscrolled_p = hscroll_window_tree (window);
11365 if (hscrolled_p)
11366 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
11367 return hscrolled_p;
11368 }
11369
11370
11371
11372 11373 11374
11375
11376 11377 11378
11379
11380 #if GLYPH_DEBUG
11381
11382
11383
11384 int debug_first_unchanged_at_end_vpos;
11385 int debug_last_unchanged_at_beg_vpos;
11386
11387
11388
11389 int debug_dvpos, debug_dy;
11390
11391
11392
11393 int debug_delta, debug_delta_bytes;
11394
11395 11396
11397
11398 EMACS_INT debug_end_pos, debug_end_vpos;
11399
11400 11401 11402 11403
11404
11405 static void
11406 debug_method_add (w, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
11407 struct window *w;
11408 char *fmt;
11409 int a1, a2, a3, a4, a5, a6, a7, a8, a9;
11410 {
11411 char buffer[512];
11412 char *method = w->desired_matrix->method;
11413 int len = strlen (method);
11414 int size = sizeof w->desired_matrix->method;
11415 int remaining = size - len - 1;
11416
11417 sprintf (buffer, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
11418 if (len && remaining)
11419 {
11420 method[len] = '|';
11421 --remaining, ++len;
11422 }
11423
11424 strncpy (method + len, buffer, remaining);
11425
11426 if (trace_redisplay_p)
11427 fprintf (stderr, "%p (%s): %s\n",
11428 w,
11429 ((BUFFERP (w->buffer)
11430 && STRINGP (XBUFFER (w->buffer)->name))
11431 ? (char *) SDATA (XBUFFER (w->buffer)->name)
11432 : "no buffer"),
11433 buffer);
11434 }
11435
11436 #endif
11437
11438
11439 11440 11441 11442
11443
11444 static INLINE int
11445 text_outside_line_unchanged_p (w, start, end)
11446 struct window *w;
11447 int start, end;
11448 {
11449 int unchanged_p = 1;
11450
11451
11452 if (XFASTINT (w->last_modified) < MODIFF
11453 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
11454 {
11455
11456 if (GPT < start || Z - GPT < end)
11457 unchanged_p = 0;
11458
11459
11460 if (unchanged_p
11461 && (BEG_UNCHANGED < start - 1
11462 || END_UNCHANGED < end))
11463 unchanged_p = 0;
11464
11465 11466
11467 if (unchanged_p
11468 && INTEGERP (current_buffer->selective_display)
11469 && XINT (current_buffer->selective_display) > 0
11470 && (BEG_UNCHANGED < start || GPT <= start))
11471 unchanged_p = 0;
11472
11473 11474 11475 11476 11477 11478 11479
11480 if (unchanged_p)
11481 {
11482 if (BEG + BEG_UNCHANGED == start
11483 && overlay_touches_p (start))
11484 unchanged_p = 0;
11485 if (END_UNCHANGED == end
11486 && overlay_touches_p (Z - end))
11487 unchanged_p = 0;
11488 }
11489
11490 11491 11492 11493 11494 11495 11496
11497 if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering)
11498 && NILP (XBUFFER (w->buffer)->bidi_paragraph_direction))
11499 unchanged_p = 0;
11500 }
11501
11502 return unchanged_p;
11503 }
11504
11505
11506 11507 11508 11509 11510 11511
11512
11513 void
11514 redisplay ()
11515 {
11516 redisplay_internal (0);
11517 }
11518
11519
11520 static Lisp_Object
11521 overlay_arrow_string_or_property (var)
11522 Lisp_Object var;
11523 {
11524 Lisp_Object val;
11525
11526 if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
11527 return val;
11528
11529 return Voverlay_arrow_string;
11530 }
11531
11532
11533 static int
11534 overlay_arrow_in_current_buffer_p ()
11535 {
11536 Lisp_Object vlist;
11537
11538 for (vlist = Voverlay_arrow_variable_list;
11539 CONSP (vlist);
11540 vlist = XCDR (vlist))
11541 {
11542 Lisp_Object var = XCAR (vlist);
11543 Lisp_Object val;
11544
11545 if (!SYMBOLP (var))
11546 continue;
11547 val = find_symbol_value (var);
11548 if (MARKERP (val)
11549 && current_buffer == XMARKER (val)->buffer)
11550 return 1;
11551 }
11552 return 0;
11553 }
11554
11555
11556 11557
11558
11559 static int
11560 overlay_arrows_changed_p ()
11561 {
11562 Lisp_Object vlist;
11563
11564 for (vlist = Voverlay_arrow_variable_list;
11565 CONSP (vlist);
11566 vlist = XCDR (vlist))
11567 {
11568 Lisp_Object var = XCAR (vlist);
11569 Lisp_Object val, pstr;
11570
11571 if (!SYMBOLP (var))
11572 continue;
11573 val = find_symbol_value (var);
11574 if (!MARKERP (val))
11575 continue;
11576 if (! EQ (COERCE_MARKER (val),
11577 Fget (var, Qlast_arrow_position))
11578 || ! (pstr = overlay_arrow_string_or_property (var),
11579 EQ (pstr, Fget (var, Qlast_arrow_string))))
11580 return 1;
11581 }
11582 return 0;
11583 }
11584
11585
11586
11587 static void
11588 update_overlay_arrows (up_to_date)
11589 int up_to_date;
11590 {
11591 Lisp_Object vlist;
11592
11593 for (vlist = Voverlay_arrow_variable_list;
11594 CONSP (vlist);
11595 vlist = XCDR (vlist))
11596 {
11597 Lisp_Object var = XCAR (vlist);
11598
11599 if (!SYMBOLP (var))
11600 continue;
11601
11602 if (up_to_date > 0)
11603 {
11604 Lisp_Object val = find_symbol_value (var);
11605 Fput (var, Qlast_arrow_position,
11606 COERCE_MARKER (val));
11607 Fput (var, Qlast_arrow_string,
11608 overlay_arrow_string_or_property (var));
11609 }
11610 else if (up_to_date < 0
11611 || !NILP (Fget (var, Qlast_arrow_position)))
11612 {
11613 Fput (var, Qlast_arrow_position, Qt);
11614 Fput (var, Qlast_arrow_string, Qt);
11615 }
11616 }
11617 }
11618
11619
11620 11621 11622
11623
11624 static Lisp_Object
11625 overlay_arrow_at_row (it, row)
11626 struct it *it;
11627 struct glyph_row *row;
11628 {
11629 Lisp_Object vlist;
11630
11631 for (vlist = Voverlay_arrow_variable_list;
11632 CONSP (vlist);
11633 vlist = XCDR (vlist))
11634 {
11635 Lisp_Object var = XCAR (vlist);
11636 Lisp_Object val;
11637
11638 if (!SYMBOLP (var))
11639 continue;
11640
11641 val = find_symbol_value (var);
11642
11643 if (MARKERP (val)
11644 && current_buffer == XMARKER (val)->buffer
11645 && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
11646 {
11647 if (FRAME_WINDOW_P (it->f)
11648 && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
11649 {
11650 #ifdef HAVE_WINDOW_SYSTEM
11651 if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
11652 {
11653 int fringe_bitmap;
11654 if ((fringe_bitmap = lookup_fringe_bitmap (val)) != 0)
11655 return make_number (fringe_bitmap);
11656 }
11657 #endif
11658 return make_number (-1);
11659 }
11660 return overlay_arrow_string_or_property (var);
11661 }
11662 }
11663
11664 return Qnil;
11665 }
11666
11667 11668 11669
11670
11671 int
11672 check_point_in_composition (prev_buf, prev_pt, buf, pt)
11673 struct buffer *prev_buf, *buf;
11674 int prev_pt, pt;
11675 {
11676 EMACS_INT start, end;
11677 Lisp_Object prop;
11678 Lisp_Object buffer;
11679
11680 XSETBUFFER (buffer, buf);
11681 11682
11683 if (prev_buf == buf)
11684 {
11685 if (prev_pt == pt)
11686
11687 return 0;
11688
11689 if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
11690 && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
11691 && COMPOSITION_VALID_P (start, end, prop)
11692 && start < prev_pt && end > prev_pt)
11693 11694
11695 return (pt <= start || pt >= end);
11696 }
11697
11698
11699 return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
11700 && find_composition (pt, -1, &start, &end, &prop, buffer)
11701 && COMPOSITION_VALID_P (start, end, prop)
11702 && start < pt && end > pt);
11703 }
11704
11705
11706 11707
11708
11709 static INLINE void
11710 reconsider_clip_changes (w, b)
11711 struct window *w;
11712 struct buffer *b;
11713 {
11714 if (b->clip_changed
11715 && !NILP (w->window_end_valid)
11716 && w->current_matrix->buffer == b
11717 && w->current_matrix->zv == BUF_ZV (b)
11718 && w->current_matrix->begv == BUF_BEGV (b))
11719 b->clip_changed = 0;
11720
11721 11722 11723 11724 11725
11726 if (!b->clip_changed
11727 && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
11728 {
11729 int pt;
11730
11731 if (w == XWINDOW (selected_window))
11732 pt = BUF_PT (current_buffer);
11733 else
11734 pt = marker_position (w->pointm);
11735
11736 if ((w->current_matrix->buffer != XBUFFER (w->buffer)
11737 || pt != XINT (w->last_point))
11738 && check_point_in_composition (w->current_matrix->buffer,
11739 XINT (w->last_point),
11740 XBUFFER (w->buffer), pt))
11741 b->clip_changed = 1;
11742 }
11743 }
11744
11745
11746 11747 11748
11749
11750 static void
11751 select_frame_for_redisplay (frame)
11752 Lisp_Object frame;
11753 {
11754 Lisp_Object tail, tem;
11755 Lisp_Object old = selected_frame;
11756 struct Lisp_Symbol *sym;
11757
11758 xassert (FRAMEP (frame) && FRAME_LIVE_P (XFRAME (frame)));
11759
11760 selected_frame = frame;
11761
11762 do {
11763 for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
11764 if (CONSP (XCAR (tail))
11765 && (tem = XCAR (XCAR (tail)),
11766 SYMBOLP (tem))
11767 && (sym = indirect_variable (XSYMBOL (tem)),
11768 sym->redirect == SYMBOL_LOCALIZED)
11769 && sym->val.blv->frame_local)
11770 11771
11772 find_symbol_value (tem);
11773 } while (!EQ (frame, old) && (frame = old, 1));
11774 }
11775
11776
11777 #define STOP_POLLING \
11778 do { if (! polling_stopped_here) stop_polling (); \
11779 polling_stopped_here = 1; } while (0)
11780
11781 #define RESUME_POLLING \
11782 do { if (polling_stopped_here) start_polling (); \
11783 polling_stopped_here = 0; } while (0)
11784
11785
11786 11787 11788 11789 11790
11791
11792 static void
11793 redisplay_internal (preserve_echo_area)
11794 int preserve_echo_area;
11795 {
11796 struct window *w = XWINDOW (selected_window);
11797 struct frame *f;
11798 int pause;
11799 int must_finish = 0;
11800 struct text_pos tlbufpos, tlendpos;
11801 int number_of_visible_frames;
11802 int count, count1;
11803 struct frame *sf;
11804 int polling_stopped_here = 0;
11805 Lisp_Object old_frame = selected_frame;
11806
11807 11808
11809 int consider_all_windows_p;
11810
11811 TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
11812
11813 11814 11815
11816 if (FRAME_INITIAL_P (SELECTED_FRAME ())
11817 || !NILP (Vinhibit_redisplay))
11818 return;
11819
11820 11821 11822
11823 f = XFRAME (w->frame);
11824 sf = SELECTED_FRAME ();
11825
11826 if (!f->glyphs_initialized_p)
11827 return;
11828
11829 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
11830 if (popup_activated ())
11831 return;
11832 #endif
11833
11834
11835 if (redisplaying_p)
11836 return;
11837
11838 11839
11840 count = SPECPDL_INDEX ();
11841 record_unwind_protect (unwind_redisplay,
11842 Fcons (make_number (redisplaying_p), selected_frame));
11843 ++redisplaying_p;
11844 specbind (Qinhibit_free_realized_faces, Qnil);
11845
11846 {
11847 Lisp_Object tail, frame;
11848
11849 FOR_EACH_FRAME (tail, frame)
11850 {
11851 struct frame *f = XFRAME (frame);
11852 f->already_hscrolled_p = 0;
11853 }
11854 }
11855
11856 retry:
11857 if (!EQ (old_frame, selected_frame)
11858 && FRAME_LIVE_P (XFRAME (old_frame)))
11859 11860 11861 11862
11863 select_frame_for_redisplay (old_frame);
11864
11865 pause = 0;
11866 reconsider_clip_changes (w, current_buffer);
11867 last_escape_glyph_frame = NULL;
11868 last_escape_glyph_face_id = (1 << FACE_ID_BITS);
11869
11870 11871
11872 if (fonts_changed_p)
11873 {
11874 adjust_glyphs (NULL);
11875 ++windows_or_buffers_changed;
11876 fonts_changed_p = 0;
11877 }
11878
11879 11880 11881
11882 if (face_change_count)
11883 ++windows_or_buffers_changed;
11884
11885 if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
11886 && FRAME_TTY (sf)->previous_frame != sf)
11887 {
11888 11889 11890
11891 windows_or_buffers_changed++;
11892 SET_FRAME_GARBAGED (sf);
11893 #ifndef DOS_NT
11894 set_tty_color_mode (FRAME_TTY (sf), sf);
11895 #endif
11896 FRAME_TTY (sf)->previous_frame = sf;
11897 }
11898
11899 11900 11901 11902
11903 {
11904 Lisp_Object tail, frame;
11905
11906 number_of_visible_frames = 0;
11907
11908 FOR_EACH_FRAME (tail, frame)
11909 {
11910 struct frame *f = XFRAME (frame);
11911
11912 FRAME_SAMPLE_VISIBILITY (f);
11913 if (FRAME_VISIBLE_P (f))
11914 ++number_of_visible_frames;
11915 clear_desired_matrices (f);
11916 }
11917 }
11918
11919
11920 do_pending_window_change (1);
11921
11922
11923 if (frame_garbaged)
11924 clear_garbaged_frames ();
11925
11926
11927 if (NILP (Vmemory_full))
11928 prepare_menu_bars ();
11929
11930 if (windows_or_buffers_changed)
11931 update_mode_lines++;
11932
11933
11934 if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
11935 {
11936 w->update_mode_line = Qt;
11937 if (buffer_shared > 1)
11938 update_mode_lines++;
11939 }
11940
11941
11942 count1 = SPECPDL_INDEX ();
11943 specbind (Qinhibit_point_motion_hooks, Qt);
11944
11945
11946 if (!NILP (w->column_number_displayed)
11947 11948
11949 && !(PT == XFASTINT (w->last_point)
11950 && XFASTINT (w->last_modified) >= MODIFF
11951 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
11952 && (XFASTINT (w->column_number_displayed)
11953 != (int) current_column ()))
11954 w->update_mode_line = Qt;
11955
11956 unbind_to (count1, Qnil);
11957
11958 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
11959
11960 11961 11962
11963 consider_all_windows_p = (update_mode_lines || buffer_shared > 1
11964 || cursor_type_changed);
11965
11966 11967
11968 if (overlay_arrows_changed_p ())
11969 consider_all_windows_p = windows_or_buffers_changed = 1;
11970
11971 11972 11973 11974 11975
11976 if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
11977 || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
11978 || (message_cleared_p
11979 && minibuf_level == 0
11980 11981
11982 && !MINI_WINDOW_P (XWINDOW (selected_window))))
11983 {
11984 int window_height_changed_p = echo_area_display (0);
11985 must_finish = 1;
11986
11987 11988 11989 11990
11991 if (!display_last_displayed_message_p)
11992 message_cleared_p = 0;
11993
11994 if (fonts_changed_p)
11995 goto retry;
11996 else if (window_height_changed_p)
11997 {
11998 consider_all_windows_p = 1;
11999 ++update_mode_lines;
12000 ++windows_or_buffers_changed;
12001
12002 12003 12004
12005 if (frame_garbaged)
12006 clear_garbaged_frames ();
12007 }
12008 }
12009 else if (EQ (selected_window, minibuf_window)
12010 && (current_buffer->clip_changed
12011 || XFASTINT (w->last_modified) < MODIFF
12012 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
12013 && resize_mini_window (w, 0))
12014 {
12015 12016
12017 must_finish = 1;
12018 12019 12020 12021
12022 consider_all_windows_p = 1;
12023 ++windows_or_buffers_changed;
12024 ++update_mode_lines;
12025
12026 12027 12028
12029 if (frame_garbaged)
12030 clear_garbaged_frames ();
12031 }
12032
12033
12034 12035 12036
12037 if (((!NILP (Vtransient_mark_mode)
12038 && !NILP (XBUFFER (w->buffer)->mark_active))
12039 != !NILP (w->region_showing))
12040 || (!NILP (w->region_showing)
12041 && !EQ (w->region_showing,
12042 Fmarker_position (XBUFFER (w->buffer)->mark))))
12043 CHARPOS (this_line_start_pos) = 0;
12044
12045 12046 12047 12048
12049 tlbufpos = this_line_start_pos;
12050 tlendpos = this_line_end_pos;
12051 if (!consider_all_windows_p
12052 && CHARPOS (tlbufpos) > 0
12053 && NILP (w->update_mode_line)
12054 && !current_buffer->clip_changed
12055 && !current_buffer->prevent_redisplay_optimizations_p
12056 && FRAME_VISIBLE_P (XFRAME (w->frame))
12057 && !FRAME_OBSCURED_P (XFRAME (w->frame))
12058
12059 && this_line_buffer == current_buffer
12060 && current_buffer == XBUFFER (w->buffer)
12061 && NILP (w->force_start)
12062 && NILP (w->optional_new_start)
12063
12064 && PT >= CHARPOS (tlbufpos)
12065 && PT <= Z - CHARPOS (tlendpos)
12066 12067
12068 && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
12069 CHARPOS (tlendpos)))
12070 {
12071 if (CHARPOS (tlbufpos) > BEGV
12072 && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
12073 && (CHARPOS (tlbufpos) == ZV
12074 || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
12075
12076 goto cancel;
12077 else if (XFASTINT (w->last_modified) < MODIFF
12078 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
12079 || MINI_WINDOW_P (w))
12080 {
12081 12082 12083 12084 12085 12086 12087 12088 12089 12090 12091 12092 12093 12094
12095
12096 struct it it;
12097 int line_height_before = this_line_pixel_height;
12098
12099 12100
12101 start_display (&it, w, tlbufpos);
12102
12103
12104 if (it.current_x != this_line_start_x)
12105 goto cancel;
12106
12107 TRACE ((stderr, "trying display optimization 1\n"));
12108 w->cursor.vpos = -1;
12109 overlay_arrow_seen = 0;
12110 it.vpos = this_line_vpos;
12111 it.current_y = this_line_y;
12112 it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
12113 display_line (&it);
12114
12115 12116
12117 if (w->cursor.vpos >= 0
12118 12119
12120 && CHARPOS (this_line_start_pos)
12121
12122 && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
12123 12124
12125 && this_line_pixel_height == line_height_before)
12126 {
12127 12128
12129 if (it.current_y < it.last_visible_y)
12130 {
12131 struct glyph_row *row
12132 = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
12133 int delta, delta_bytes;
12134
12135 12136 12137 12138 12139
12140 delta = (Z
12141 - CHARPOS (tlendpos)
12142 - MATRIX_ROW_START_CHARPOS (row));
12143 delta_bytes = (Z_BYTE
12144 - BYTEPOS (tlendpos)
12145 - MATRIX_ROW_START_BYTEPOS (row));
12146
12147 increment_matrix_positions (w->current_matrix,
12148 this_line_vpos + 1,
12149 w->current_matrix->nrows,
12150 delta, delta_bytes);
12151 }
12152
12153 12154 12155
12156 if ((it.glyph_row - 1)->displays_text_p)
12157 {
12158 if (XFASTINT (w->window_end_vpos) < this_line_vpos)
12159 XSETINT (w->window_end_vpos, this_line_vpos);
12160 }
12161 else if (XFASTINT (w->window_end_vpos) == this_line_vpos
12162 && this_line_vpos > 0)
12163 XSETINT (w->window_end_vpos, this_line_vpos - 1);
12164 w->window_end_valid = Qnil;
12165
12166
12167 w->desired_matrix->no_scrolling_p = 1;
12168
12169 #if GLYPH_DEBUG
12170 *w->desired_matrix->method = 0;
12171 debug_method_add (w, "optimization 1");
12172 #endif
12173 #ifdef HAVE_WINDOW_SYSTEM
12174 update_window_fringes (w, 0);
12175 #endif
12176 goto update;
12177 }
12178 else
12179 goto cancel;
12180 }
12181 else if (
12182 PT == XFASTINT (w->last_point)
12183 12184
12185 && 0 <= w->cursor.vpos
12186 && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
12187 {
12188 if (!must_finish)
12189 {
12190 do_pending_window_change (1);
12191
12192 12193
12194 if (w->cursor_off_p == w->last_cursor_off_p)
12195 goto end_of_redisplay;
12196 }
12197 goto update;
12198 }
12199 12200
12201 else if (! (!NILP (Vtransient_mark_mode)
12202 && !NILP (current_buffer->mark_active))
12203 && (EQ (selected_window, current_buffer->last_selected_window)
12204 || highlight_nonselected_windows)
12205 && NILP (w->region_showing)
12206 && NILP (Vshow_trailing_whitespace)
12207 && !cursor_in_echo_area)
12208 {
12209 struct it it;
12210 struct glyph_row *row;
12211
12212 12213 12214
12215 init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
12216 NULL, DEFAULT_FACE_ID);
12217 it.current_x = this_line_start_x;
12218 it.current_y = this_line_y;
12219 it.vpos = this_line_vpos;
12220
12221 12222
12223 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
12224
12225 if (it.vpos == this_line_vpos
12226 && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
12227 row->enabled_p))
12228 {
12229 xassert (this_line_vpos == it.vpos);
12230 xassert (this_line_y == it.current_y);
12231 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
12232 #if GLYPH_DEBUG
12233 *w->desired_matrix->method = 0;
12234 debug_method_add (w, "optimization 3");
12235 #endif
12236 goto update;
12237 }
12238 else
12239 goto cancel;
12240 }
12241
12242 cancel:
12243
12244 SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, 0);
12245 }
12246
12247 CHARPOS (this_line_start_pos) = 0;
12248 consider_all_windows_p |= buffer_shared > 1;
12249 ++clear_face_cache_count;
12250 #ifdef HAVE_WINDOW_SYSTEM
12251 ++clear_image_cache_count;
12252 #endif
12253
12254 12255 12256
12257
12258 if (consider_all_windows_p)
12259 {
12260 Lisp_Object tail, frame;
12261
12262 FOR_EACH_FRAME (tail, frame)
12263 XFRAME (frame)->updated_p = 0;
12264
12265 12266
12267 buffer_shared = 0;
12268
12269 FOR_EACH_FRAME (tail, frame)
12270 {
12271 struct frame *f = XFRAME (frame);
12272
12273 if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
12274 {
12275 if (! EQ (frame, selected_frame))
12276 12277
12278 select_frame_for_redisplay (frame);
12279
12280 12281
12282 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
12283 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
12284
12285 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
12286 redisplay_windows (FRAME_ROOT_WINDOW (f));
12287
12288
12289 if (!FRAME_LIVE_P (f))
12290 continue;
12291
12292 12293
12294 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
12295 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
12296
12297
12298 12299
12300 if (fonts_changed_p)
12301 goto retry;
12302
12303 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
12304 {
12305
12306 if (!f->already_hscrolled_p)
12307 {
12308 f->already_hscrolled_p = 1;
12309 if (hscroll_windows (f->root_window))
12310 goto retry;
12311 }
12312
12313 12314 12315 12316
12317 if (interrupt_input)
12318 unrequest_sigio ();
12319 STOP_POLLING;
12320
12321
12322 set_window_update_flags (XWINDOW (f->root_window), 1);
12323 pause |= update_frame (f, 0, 0);
12324 f->updated_p = 1;
12325 }
12326 }
12327 }
12328
12329 if (!EQ (old_frame, selected_frame)
12330 && FRAME_LIVE_P (XFRAME (old_frame)))
12331 12332 12333
12334 select_frame_for_redisplay (old_frame);
12335 eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
12336
12337 if (!pause)
12338 {
12339 12340 12341
12342 FOR_EACH_FRAME (tail, frame)
12343 {
12344 struct frame *f = XFRAME (frame);
12345 if (f->updated_p)
12346 {
12347 mark_window_display_accurate (f->root_window, 1);
12348 if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
12349 FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
12350 }
12351 }
12352 }
12353 }
12354 else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
12355 {
12356 Lisp_Object mini_window;
12357 struct frame *mini_frame;
12358
12359 displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
12360 12361
12362 internal_condition_case_1 (redisplay_window_1, selected_window,
12363 list_of_error,
12364 redisplay_window_error);
12365
12366
12367
12368 update:
12369
12370 if (fonts_changed_p)
12371 goto retry;
12372
12373 12374 12375
12376 if (interrupt_input)
12377 unrequest_sigio ();
12378 STOP_POLLING;
12379
12380 if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
12381 {
12382 if (hscroll_windows (selected_window))
12383 goto retry;
12384
12385 XWINDOW (selected_window)->must_be_updated_p = 1;
12386 pause = update_frame (sf, 0, 0);
12387 }
12388
12389 12390 12391 12392 12393
12394 mini_window = FRAME_MINIBUF_WINDOW (sf);
12395 mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
12396
12397 if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
12398 {
12399 XWINDOW (mini_window)->must_be_updated_p = 1;
12400 pause |= update_frame (mini_frame, 0, 0);
12401 if (!pause && hscroll_windows (mini_window))
12402 goto retry;
12403 }
12404 }
12405
12406 12407
12408 if (pause)
12409 {
12410 12411 12412
12413 CHARPOS (this_line_start_pos) = 0;
12414
12415
12416 update_overlay_arrows (0);
12417
12418 12419
12420 if (!WINDOW_FULL_WIDTH_P (w)
12421 && !FRAME_WINDOW_P (XFRAME (w->frame)))
12422 update_mode_lines = 1;
12423 }
12424 else
12425 {
12426 if (!consider_all_windows_p)
12427 {
12428 12429
12430 mark_window_display_accurate_1 (w, 1);
12431
12432
12433 update_overlay_arrows (1);
12434
12435 if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
12436 FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
12437 }
12438
12439 update_mode_lines = 0;
12440 windows_or_buffers_changed = 0;
12441 cursor_type_changed = 0;
12442 }
12443
12444 12445 12446 12447
12448 if (interrupt_input)
12449 request_sigio ();
12450 RESUME_POLLING;
12451
12452 12453 12454 12455 12456 12457
12458 if (!pause)
12459 {
12460 Lisp_Object tail, frame;
12461 int new_count = 0;
12462
12463 FOR_EACH_FRAME (tail, frame)
12464 {
12465 int this_is_visible = 0;
12466
12467 if (XFRAME (frame)->visible)
12468 this_is_visible = 1;
12469 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
12470 if (XFRAME (frame)->visible)
12471 this_is_visible = 1;
12472
12473 if (this_is_visible)
12474 new_count++;
12475 }
12476
12477 if (new_count != number_of_visible_frames)
12478 windows_or_buffers_changed++;
12479 }
12480
12481
12482 do_pending_window_change (1);
12483
12484 12485
12486 if (windows_or_buffers_changed && !pause)
12487 goto retry;
12488
12489 12490 12491 12492 12493
12494
12495 if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
12496 {
12497 clear_face_cache (0);
12498 clear_face_cache_count = 0;
12499 }
12500
12501 #ifdef HAVE_WINDOW_SYSTEM
12502 if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
12503 {
12504 clear_image_caches (Qnil);
12505 clear_image_cache_count = 0;
12506 }
12507 #endif
12508
12509 end_of_redisplay:
12510 unbind_to (count, Qnil);
12511 RESUME_POLLING;
12512 }
12513
12514
12515 12516 12517 12518 12519 12520 12521 12522 12523 12524
12525
12526 void
12527 redisplay_preserve_echo_area (from_where)
12528 int from_where;
12529 {
12530 TRACE ((stderr, "redisplay_preserve_echo_area (%d)\n", from_where));
12531
12532 if (!NILP (echo_area_buffer[1]))
12533 {
12534 12535
12536 display_last_displayed_message_p = 1;
12537 redisplay_internal (1);
12538 display_last_displayed_message_p = 0;
12539 }
12540 else
12541 redisplay_internal (1);
12542
12543 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
12544 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
12545 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL);
12546 }
12547
12548
12549 12550 12551 12552 12553 12554
12555
12556 static Lisp_Object
12557 unwind_redisplay (val)
12558 Lisp_Object val;
12559 {
12560 Lisp_Object old_redisplaying_p, old_frame;
12561
12562 old_redisplaying_p = XCAR (val);
12563 redisplaying_p = XFASTINT (old_redisplaying_p);
12564 old_frame = XCDR (val);
12565 if (! EQ (old_frame, selected_frame)
12566 && FRAME_LIVE_P (XFRAME (old_frame)))
12567 select_frame_for_redisplay (old_frame);
12568 return Qnil;
12569 }
12570
12571
12572 12573 12574 12575
12576
12577 static void
12578 mark_window_display_accurate_1 (w, accurate_p)
12579 struct window *w;
12580 int accurate_p;
12581 {
12582 if (BUFFERP (w->buffer))
12583 {
12584 struct buffer *b = XBUFFER (w->buffer);
12585
12586 w->last_modified
12587 = make_number (accurate_p ? BUF_MODIFF (b) : 0);
12588 w->last_overlay_modified
12589 = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
12590 w->last_had_star
12591 = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
12592
12593 if (accurate_p)
12594 {
12595 b->clip_changed = 0;
12596 b->prevent_redisplay_optimizations_p = 0;
12597
12598 BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
12599 BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
12600 BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
12601 BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
12602
12603 w->current_matrix->buffer = b;
12604 w->current_matrix->begv = BUF_BEGV (b);
12605 w->current_matrix->zv = BUF_ZV (b);
12606
12607 w->last_cursor = w->cursor;
12608 w->last_cursor_off_p = w->cursor_off_p;
12609
12610 if (w == XWINDOW (selected_window))
12611 w->last_point = make_number (BUF_PT (b));
12612 else
12613 w->last_point = make_number (XMARKER (w->pointm)->charpos);
12614 }
12615 }
12616
12617 if (accurate_p)
12618 {
12619 w->window_end_valid = w->buffer;
12620 w->update_mode_line = Qnil;
12621 }
12622 }
12623
12624
12625 12626 12627 12628
12629
12630 void
12631 mark_window_display_accurate (window, accurate_p)
12632 Lisp_Object window;
12633 int accurate_p;
12634 {
12635 struct window *w;
12636
12637 for (; !NILP (window); window = w->next)
12638 {
12639 w = XWINDOW (window);
12640 mark_window_display_accurate_1 (w, accurate_p);
12641
12642 if (!NILP (w->vchild))
12643 mark_window_display_accurate (w->vchild, accurate_p);
12644 if (!NILP (w->hchild))
12645 mark_window_display_accurate (w->hchild, accurate_p);
12646 }
12647
12648 if (accurate_p)
12649 {
12650 update_overlay_arrows (1);
12651 }
12652 else
12653 {
12654 12655 12656
12657 update_overlay_arrows (-1);
12658 }
12659 }
12660
12661
12662 12663 12664 12665
12666
12667 Lisp_Object
12668 disp_char_vector (dp, c)
12669 struct Lisp_Char_Table *dp;
12670 int c;
12671 {
12672 Lisp_Object val;
12673
12674 if (ASCII_CHAR_P (c))
12675 {
12676 val = dp->ascii;
12677 if (SUB_CHAR_TABLE_P (val))
12678 val = XSUB_CHAR_TABLE (val)->contents[c];
12679 }
12680 else
12681 {
12682 Lisp_Object table;
12683
12684 XSETCHAR_TABLE (table, dp);
12685 val = char_table_ref (table, c);
12686 }
12687 if (NILP (val))
12688 val = dp->defalt;
12689 return val;
12690 }
12691
12692
12693
12694 12695 12696
12697
12698
12699
12700 static void
12701 redisplay_windows (window)
12702 Lisp_Object window;
12703 {
12704 while (!NILP (window))
12705 {
12706 struct window *w = XWINDOW (window);
12707
12708 if (!NILP (w->hchild))
12709 redisplay_windows (w->hchild);
12710 else if (!NILP (w->vchild))
12711 redisplay_windows (w->vchild);
12712 else if (!NILP (w->buffer))
12713 {
12714 displayed_buffer = XBUFFER (w->buffer);
12715 12716
12717 internal_condition_case_1 (redisplay_window_0, window,
12718 list_of_error,
12719 redisplay_window_error);
12720 }
12721
12722 window = w->next;
12723 }
12724 }
12725
12726 static Lisp_Object
12727 redisplay_window_error ()
12728 {
12729 displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
12730 return Qnil;
12731 }
12732
12733 static Lisp_Object
12734 redisplay_window_0 (window)
12735 Lisp_Object window;
12736 {
12737 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12738 redisplay_window (window, 0);
12739 return Qnil;
12740 }
12741
12742 static Lisp_Object
12743 redisplay_window_1 (window)
12744 Lisp_Object window;
12745 {
12746 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12747 redisplay_window (window, 1);
12748 return Qnil;
12749 }
12750
12751
12752 12753
12754
12755 #define SKIP_GLYPHS(glyph, end, x, condition) \
12756 do \
12757 { \
12758 (x) += (glyph)->pixel_width; \
12759 ++(glyph); \
12760 } \
12761 while ((glyph) < (end) && (condition))
12762
12763
12764 12765 12766 12767 12768 12769
12770
12771 int
12772 set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos)
12773 struct window *w;
12774 struct glyph_row *row;
12775 struct glyph_matrix *matrix;
12776 int delta, delta_bytes, dy, dvpos;
12777 {
12778 struct glyph *glyph = row->glyphs[TEXT_AREA];
12779 struct glyph *end = glyph + row->used[TEXT_AREA];
12780 struct glyph *cursor = NULL;
12781
12782 int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
12783 int x = row->x;
12784 EMACS_INT pt_old = PT - delta;
12785 EMACS_INT pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
12786 EMACS_INT pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
12787 struct glyph *glyph_before = glyph - 1, *glyph_after = end;
12788 12789
12790 struct glyph *glyphs_end = end;
12791 12792
12793 int match_with_avoid_cursor = 0;
12794 12795
12796 int string_seen = 0;
12797
12798 EMACS_INT bpos_max = last_pos;
12799 12800
12801 EMACS_INT bpos_covered = 0;
12802
12803 12804 12805
12806 if (row->displays_text_p)
12807 {
12808 if (!row->reversed_p)
12809 {
12810 while (glyph < end
12811 && INTEGERP (glyph->object)
12812 && glyph->charpos < 0)
12813 {
12814 x += glyph->pixel_width;
12815 ++glyph;
12816 }
12817 while (end > glyph
12818 && INTEGERP ((end - 1)->object)
12819 12820
12821 && (end - 1)->charpos <= 0)
12822 --end;
12823 glyph_before = glyph - 1;
12824 glyph_after = end;
12825 }
12826 else
12827 {
12828 struct glyph *g;
12829
12830 12831
12832 glyphs_end = end = glyph - 1;
12833 glyph += row->used[TEXT_AREA] - 1;
12834
12835 while (glyph > end + 1
12836 && INTEGERP (glyph->object)
12837 && glyph->charpos < 0)
12838 {
12839 --glyph;
12840 x -= glyph->pixel_width;
12841 }
12842 if (INTEGERP (glyph->object) && glyph->charpos < 0)
12843 --glyph;
12844 12845
12846 for (g = end + 1; g < glyph; g++)
12847 x += g->pixel_width;
12848 while (end < glyph
12849 && INTEGERP ((end + 1)->object)
12850 && (end + 1)->charpos <= 0)
12851 ++end;
12852 glyph_before = glyph + 1;
12853 glyph_after = end;
12854 }
12855 }
12856 else if (row->reversed_p)
12857 {
12858 12859 12860
12861 cursor = end - 1;
12862 12863 12864
12865 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
12866 && !WINDOW_RIGHTMOST_P (w)
12867 && cursor == row->glyphs[LAST_AREA] - 1)
12868 cursor--;
12869 x = -1;
12870 }
12871
12872 12873 12874 12875
12876 if (!row->reversed_p)
12877 while (
12878 glyph < end
12879
12880 && !INTEGERP (glyph->object))
12881 {
12882 if (BUFFERP (glyph->object))
12883 {
12884 EMACS_INT dpos = glyph->charpos - pt_old;
12885
12886 if (glyph->charpos > bpos_max)
12887 bpos_max = glyph->charpos;
12888 if (!glyph->avoid_cursor_p)
12889 {
12890 12891
12892 if (dpos == 0)
12893 {
12894 match_with_avoid_cursor = 0;
12895 break;
12896 }
12897 12898 12899 12900 12901
12902 if (0 > dpos && dpos > pos_before - pt_old)
12903 {
12904 pos_before = glyph->charpos;
12905 glyph_before = glyph;
12906 }
12907 else if (0 < dpos && dpos <= pos_after - pt_old)
12908 {
12909 pos_after = glyph->charpos;
12910 glyph_after = glyph;
12911 }
12912 }
12913 else if (dpos == 0)
12914 match_with_avoid_cursor = 1;
12915 }
12916 else if (STRINGP (glyph->object))
12917 {
12918 Lisp_Object chprop;
12919 int glyph_pos = glyph->charpos;
12920
12921 chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
12922 glyph->object);
12923 if (INTEGERP (chprop))
12924 {
12925 bpos_covered = bpos_max + XINT (chprop);
12926 12927 12928 12929 12930 12931 12932 12933 12934 12935 12936 12937
12938 12939 12940
12941 if (bpos_max <= pt_old && bpos_covered >= pt_old)
12942 {
12943 cursor = glyph;
12944 break;
12945 }
12946 }
12947
12948 string_seen = 1;
12949 }
12950 x += glyph->pixel_width;
12951 ++glyph;
12952 }
12953 else if (glyph > end)
12954 while (!INTEGERP (glyph->object))
12955 {
12956 if (BUFFERP (glyph->object))
12957 {
12958 EMACS_INT dpos = glyph->charpos - pt_old;
12959
12960 if (glyph->charpos > bpos_max)
12961 bpos_max = glyph->charpos;
12962 if (!glyph->avoid_cursor_p)
12963 {
12964 if (dpos == 0)
12965 {
12966 match_with_avoid_cursor = 0;
12967 break;
12968 }
12969 if (0 > dpos && dpos > pos_before - pt_old)
12970 {
12971 pos_before = glyph->charpos;
12972 glyph_before = glyph;
12973 }
12974 else if (0 < dpos && dpos <= pos_after - pt_old)
12975 {
12976 pos_after = glyph->charpos;
12977 glyph_after = glyph;
12978 }
12979 }
12980 else if (dpos == 0)
12981 match_with_avoid_cursor = 1;
12982 }
12983 else if (STRINGP (glyph->object))
12984 {
12985 Lisp_Object chprop;
12986 int glyph_pos = glyph->charpos;
12987
12988 chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
12989 glyph->object);
12990 if (INTEGERP (chprop))
12991 {
12992 bpos_covered = bpos_max + XINT (chprop);
12993 12994 12995
12996 if (bpos_max <= pt_old && bpos_covered >= pt_old)
12997 {
12998 cursor = glyph;
12999 break;
13000 }
13001 }
13002 string_seen = 1;
13003 }
13004 --glyph;
13005 if (glyph == glyphs_end)
13006 {
13007 x--;
13008 break;
13009 }
13010 x -= glyph->pixel_width;
13011 }
13012
13013 13014 13015
13016 if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
13017 && BUFFERP (glyph->object) && glyph->charpos == pt_old)
13018 && bpos_covered < pt_old)
13019 {
13020 if (row->ends_in_ellipsis_p && pos_after == last_pos)
13021 {
13022 EMACS_INT ellipsis_pos;
13023
13024
13025 if (!row->reversed_p)
13026 {
13027 ellipsis_pos = (glyph - 1)->charpos;
13028 while (glyph > row->glyphs[TEXT_AREA]
13029 && (glyph - 1)->charpos == ellipsis_pos)
13030 glyph--, x -= glyph->pixel_width;
13031 13032 13033
13034 x += glyph->pixel_width;
13035 glyph++;
13036 }
13037 else
13038 {
13039 ellipsis_pos = (glyph + 1)->charpos;
13040 while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
13041 && (glyph + 1)->charpos == ellipsis_pos)
13042 glyph++, x += glyph->pixel_width;
13043 x -= glyph->pixel_width;
13044 glyph--;
13045 }
13046 }
13047 else if (match_with_avoid_cursor
13048
13049 || ((row->reversed_p
13050 ? glyph_after > glyphs_end
13051 : glyph_after < glyphs_end)
13052 && eabs (glyph_after - glyph_before) == 1))
13053 {
13054 cursor = glyph_after;
13055 x = -1;
13056 }
13057 else if (string_seen)
13058 {
13059 int incr = row->reversed_p ? -1 : +1;
13060
13061 13062 13063 13064 13065
13066 struct glyph *stop = glyph_after;
13067 EMACS_INT pos = pos_before;
13068
13069 x = -1;
13070 for (glyph = glyph_before + incr;
13071 row->reversed_p ? glyph > stop : glyph < stop; )
13072 {
13073
13074 13075 13076
13077 if (STRINGP (glyph->object))
13078 {
13079 Lisp_Object str;
13080 EMACS_INT tem;
13081
13082 str = glyph->object;
13083 tem = string_buffer_position_lim (w, str, pos, pos_after, 0);
13084 if (tem == 0
13085 || pos <= tem)
13086 {
13087 13088 13089 13090 13091 13092 13093 13094 13095
13096 if (tem == 0 || tem == pt_old)
13097 {
13098 13099 13100 13101 13102 13103
13104 int strpos = glyph->charpos;
13105
13106 cursor = glyph;
13107 for (glyph += incr;
13108 (row->reversed_p ? glyph > stop : glyph < stop)
13109 && EQ (glyph->object, str);
13110 glyph += incr)
13111 {
13112 Lisp_Object cprop;
13113 int gpos = glyph->charpos;
13114
13115 cprop = Fget_char_property (make_number (gpos),
13116 Qcursor,
13117 glyph->object);
13118 if (!NILP (cprop))
13119 {
13120 cursor = glyph;
13121 break;
13122 }
13123 if (glyph->charpos < strpos)
13124 {
13125 strpos = glyph->charpos;
13126 cursor = glyph;
13127 }
13128 }
13129
13130 if (tem == pt_old)
13131 goto compute_x;
13132 }
13133 if (tem)
13134 pos = tem + 1;
13135 }
13136 13137
13138 do
13139 glyph += incr;
13140 while ((row->reversed_p ? glyph > stop : glyph < stop)
13141 && EQ (glyph->object, str));
13142 }
13143 else
13144 glyph += incr;
13145 }
13146
13147 13148
13149 if (cursor == NULL
13150 && (row->reversed_p ? glyph <= end : glyph >= end)
13151 && STRINGP (end->object)
13152 && row->continued_p)
13153 return 0;
13154 }
13155 }
13156
13157 compute_x:
13158 if (cursor != NULL)
13159 glyph = cursor;
13160 if (x < 0)
13161 {
13162 struct glyph *g;
13163
13164
13165 for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
13166 {
13167 if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
13168 abort ();
13169 x += g->pixel_width;
13170 }
13171 }
13172
13173 13174 13175 13176 13177
13178 if (
13179 w->cursor.vpos >= 0
13180
13181 && MATRIX_ROW (matrix, w->cursor.vpos) != row
13182
13183 && (row->continued_p || MATRIX_ROW_CONTINUATION_LINE_P (row))
13184 13185 13186 13187
13188 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
13189 && pt_old < MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)))
13190 {
13191 struct glyph *g1 =
13192 MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
13193
13194
13195 if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
13196 return 0;
13197 13198
13199 if (
13200 w->cursor.hpos >= 0
13201 && w->cursor.hpos < MATRIX_ROW_USED(matrix, w->cursor.vpos)
13202 && BUFFERP (g1->object)
13203 && (g1->charpos == pt_old
13204 || (BUFFERP (glyph->object)
13205 && eabs (g1->charpos - pt_old)
13206 < eabs (glyph->charpos - pt_old))))
13207 return 0;
13208
13209 if (!(BUFFERP (glyph->object) && glyph->charpos == pt_old)
13210 13211 13212 13213 13214
13215 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
13216 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
13217 < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
13218 return 0;
13219 }
13220 w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
13221 w->cursor.x = x;
13222 w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
13223 w->cursor.y = row->y + dy;
13224
13225 if (w == XWINDOW (selected_window))
13226 {
13227 if (!row->continued_p
13228 && !MATRIX_ROW_CONTINUATION_LINE_P (row)
13229 && row->x == 0)
13230 {
13231 this_line_buffer = XBUFFER (w->buffer);
13232
13233 CHARPOS (this_line_start_pos)
13234 = MATRIX_ROW_START_CHARPOS (row) + delta;
13235 BYTEPOS (this_line_start_pos)
13236 = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
13237
13238 CHARPOS (this_line_end_pos)
13239 = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
13240 BYTEPOS (this_line_end_pos)
13241 = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
13242
13243 this_line_y = w->cursor.y;
13244 this_line_pixel_height = row->height;
13245 this_line_vpos = w->cursor.vpos;
13246 this_line_start_x = row->x;
13247 }
13248 else
13249 CHARPOS (this_line_start_pos) = 0;
13250 }
13251
13252 return 1;
13253 }
13254
13255
13256 13257 13258 13259
13260
13261 static INLINE struct text_pos
13262 run_window_scroll_functions (window, startp)
13263 Lisp_Object window;
13264 struct text_pos startp;
13265 {
13266 struct window *w = XWINDOW (window);
13267 SET_MARKER_FROM_TEXT_POS (w->start, startp);
13268
13269 if (current_buffer != XBUFFER (w->buffer))
13270 abort ();
13271
13272 if (!NILP (Vwindow_scroll_functions))
13273 {
13274 run_hook_with_args_2 (Qwindow_scroll_functions, window,
13275 make_number (CHARPOS (startp)));
13276 SET_TEXT_POS_FROM_MARKER (startp, w->start);
13277
13278 if (current_buffer != XBUFFER (w->buffer))
13279 set_buffer_internal_1 (XBUFFER (w->buffer));
13280 }
13281
13282 return startp;
13283 }
13284
13285
13286 13287 13288 13289 13290 13291 13292 13293 13294 13295
13296
13297 static int
13298 cursor_row_fully_visible_p (w, force_p, current_matrix_p)
13299 struct window *w;
13300 int force_p;
13301 int current_matrix_p;
13302 {
13303 struct glyph_matrix *matrix;
13304 struct glyph_row *row;
13305 int window_height;
13306
13307 if (!make_cursor_line_fully_visible_p)
13308 return 1;
13309
13310 13311
13312 if (w->cursor.vpos < 0)
13313 return 1;
13314
13315 matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
13316 row = MATRIX_ROW (matrix, w->cursor.vpos);
13317
13318
13319 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
13320 return 1;
13321
13322 13323
13324 window_height = window_box_height (w);
13325 if (row->height >= window_height)
13326 {
13327 if (!force_p || MINI_WINDOW_P (w)
13328 || w->vscroll || w->cursor.vpos == 0)
13329 return 1;
13330 }
13331 return 0;
13332 }
13333
13334
13335 13336 13337 13338 13339 13340 13341 13342 13343 13344 13345 13346 13347 13348 13349 13350 13351
13352
13353 enum
13354 {
13355 SCROLLING_SUCCESS,
13356 SCROLLING_FAILED,
13357 SCROLLING_NEED_LARGER_MATRICES
13358 };
13359
13360 static int
13361 try_scrolling (window, just_this_one_p, scroll_conservatively,
13362 scroll_step, temp_scroll_step, last_line_misfit)
13363 Lisp_Object window;
13364 int just_this_one_p;
13365 EMACS_INT scroll_conservatively, scroll_step;
13366 int temp_scroll_step;
13367 int last_line_misfit;
13368 {
13369 struct window *w = XWINDOW (window);
13370 struct frame *f = XFRAME (w->frame);
13371 struct text_pos pos, startp;
13372 struct it it;
13373 int this_scroll_margin, scroll_max, rc, height;
13374 int dy = 0, amount_to_scroll = 0, scroll_down_p = 0;
13375 int extra_scroll_margin_lines = last_line_misfit ? 1 : 0;
13376 Lisp_Object aggressive;
13377 int scroll_limit = INT_MAX / FRAME_LINE_HEIGHT (f);
13378
13379 #if GLYPH_DEBUG
13380 debug_method_add (w, "try_scrolling");
13381 #endif
13382
13383 SET_TEXT_POS_FROM_MARKER (startp, w->start);
13384
13385 13386
13387 if (scroll_margin > 0)
13388 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4)
13389 * FRAME_LINE_HEIGHT (f);
13390 else
13391 this_scroll_margin = 0;
13392
13393 13394 13395 13396
13397 if (scroll_conservatively > scroll_limit)
13398 {
13399 scroll_conservatively = scroll_limit;
13400 scroll_max = INT_MAX;
13401 }
13402 else if (scroll_step || scroll_conservatively || temp_scroll_step)
13403 13404
13405 scroll_max = (max (scroll_step,
13406 max (scroll_conservatively, temp_scroll_step))
13407 * FRAME_LINE_HEIGHT (f));
13408 else if (NUMBERP (current_buffer->scroll_down_aggressively)
13409 || NUMBERP (current_buffer->scroll_up_aggressively))
13410 13411
13412 scroll_max = 10 * FRAME_LINE_HEIGHT (f);
13413 else
13414 scroll_max = 0;
13415
13416 too_near_end:
13417
13418
13419 if (PT > CHARPOS (startp))
13420 {
13421 int scroll_margin_y;
13422
13423 13424
13425 start_display (&it, w, startp);
13426 scroll_margin_y = it.last_visible_y - this_scroll_margin
13427 - FRAME_LINE_HEIGHT (f) * extra_scroll_margin_lines;
13428 move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
13429 (MOVE_TO_POS | MOVE_TO_Y));
13430
13431 if (PT > CHARPOS (it.current.pos))
13432 {
13433 int y0 = line_bottom_y (&it);
13434
13435 13436 13437 13438 13439
13440 move_it_to (&it, PT, -1,
13441 it.last_visible_y + 10 * FRAME_LINE_HEIGHT (f),
13442 -1, MOVE_TO_POS | MOVE_TO_Y);
13443 dy = line_bottom_y (&it) - y0;
13444
13445 if (dy > scroll_max)
13446 return SCROLLING_FAILED;
13447
13448 scroll_down_p = 1;
13449 }
13450 }
13451
13452 if (scroll_down_p)
13453 {
13454 13455 13456 13457
13458 if (scroll_conservatively)
13459 amount_to_scroll
13460 = min (max (dy, FRAME_LINE_HEIGHT (f)),
13461 FRAME_LINE_HEIGHT (f) * scroll_conservatively);
13462 else if (scroll_step || temp_scroll_step)
13463 amount_to_scroll = scroll_max;
13464 else
13465 {
13466 aggressive = current_buffer->scroll_up_aggressively;
13467 height = WINDOW_BOX_TEXT_HEIGHT (w);
13468 if (NUMBERP (aggressive))
13469 {
13470 double float_amount = XFLOATINT (aggressive) * height;
13471 amount_to_scroll = float_amount;
13472 if (amount_to_scroll == 0 && float_amount > 0)
13473 amount_to_scroll = 1;
13474 }
13475 }
13476
13477 if (amount_to_scroll <= 0)
13478 return SCROLLING_FAILED;
13479
13480 start_display (&it, w, startp);
13481 move_it_vertically (&it, amount_to_scroll);
13482
13483
13484 if (CHARPOS (it.current.pos) == CHARPOS (startp))
13485 move_it_by_lines (&it, 1, 1);
13486 startp = it.current.pos;
13487 }
13488 else
13489 {
13490 struct text_pos scroll_margin_pos = startp;
13491
13492 13493
13494 if (this_scroll_margin)
13495 {
13496 start_display (&it, w, startp);
13497 move_it_vertically (&it, this_scroll_margin);
13498 scroll_margin_pos = it.current.pos;
13499 }
13500
13501 if (PT < CHARPOS (scroll_margin_pos))
13502 {
13503 13504
13505 int y0;
13506
13507 13508 13509
13510 SET_TEXT_POS (pos, PT, PT_BYTE);
13511 start_display (&it, w, pos);
13512 y0 = it.current_y;
13513 move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
13514 it.last_visible_y, -1,
13515 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
13516 dy = it.current_y - y0;
13517 if (dy > scroll_max)
13518 return SCROLLING_FAILED;
13519
13520
13521 start_display (&it, w, startp);
13522
13523 if (scroll_conservatively)
13524 amount_to_scroll
13525 = max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
13526 else if (scroll_step || temp_scroll_step)
13527 amount_to_scroll = scroll_max;
13528 else
13529 {
13530 aggressive = current_buffer->scroll_down_aggressively;
13531 height = WINDOW_BOX_TEXT_HEIGHT (w);
13532 if (NUMBERP (aggressive))
13533 {
13534 double float_amount = XFLOATINT (aggressive) * height;
13535 amount_to_scroll = float_amount;
13536 if (amount_to_scroll == 0 && float_amount > 0)
13537 amount_to_scroll = 1;
13538 }
13539 }
13540
13541 if (amount_to_scroll <= 0)
13542 return SCROLLING_FAILED;
13543
13544 move_it_vertically_backward (&it, amount_to_scroll);
13545 startp = it.current.pos;
13546 }
13547 }
13548
13549
13550 startp = run_window_scroll_functions (window, startp);
13551
13552 13553
13554 if (!try_window (window, startp, 0))
13555 rc = SCROLLING_NEED_LARGER_MATRICES;
13556 else if (w->cursor.vpos < 0)
13557 {
13558 clear_glyph_matrix (w->desired_matrix);
13559 rc = SCROLLING_FAILED;
13560 }
13561 else
13562 {
13563
13564 if (!just_this_one_p
13565 || current_buffer->clip_changed
13566 || BEG_UNCHANGED < CHARPOS (startp))
13567 w->base_line_number = Qnil;
13568
13569 13570
13571 if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1, 0))
13572 {
13573 clear_glyph_matrix (w->desired_matrix);
13574 ++extra_scroll_margin_lines;
13575 goto too_near_end;
13576 }
13577 rc = SCROLLING_SUCCESS;
13578 }
13579
13580 return rc;
13581 }
13582
13583
13584 13585 13586 13587 13588 13589 13590
13591
13592 static int
13593 compute_window_start_on_continuation_line (w)
13594 struct window *w;
13595 {
13596 struct text_pos pos, start_pos;
13597 int window_start_changed_p = 0;
13598
13599 SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
13600
13601 13602 13603
13604 if (CHARPOS (start_pos) > BEGV
13605 && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
13606 {
13607 struct it it;
13608 struct glyph_row *row;
13609
13610
13611 if (CHARPOS (start_pos) < BEGV)
13612 SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
13613 else if (CHARPOS (start_pos) > ZV)
13614 SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
13615
13616 13617
13618 row = w->desired_matrix->rows + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0);
13619 init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
13620 row, DEFAULT_FACE_ID);
13621 reseat_at_previous_visible_line_start (&it);
13622
13623 13624
13625 if (CHARPOS (start_pos) - IT_CHARPOS (it)
13626 < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
13627 {
13628 int min_distance, distance;
13629
13630 13631 13632 13633 13634 13635
13636 pos = it.current.pos;
13637 min_distance = INFINITY;
13638 while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
13639 distance < min_distance)
13640 {
13641 min_distance = distance;
13642 pos = it.current.pos;
13643 move_it_by_lines (&it, 1, 0);
13644 }
13645
13646
13647 SET_MARKER_FROM_TEXT_POS (w->start, pos);
13648 window_start_changed_p = 1;
13649 }
13650 }
13651
13652 return window_start_changed_p;
13653 }
13654
13655
13656 13657 13658 13659 13660 13661 13662 13663 13664 13665 13666 13667 13668 13669
13670
13671 enum
13672 {
13673 CURSOR_MOVEMENT_SUCCESS,
13674 CURSOR_MOVEMENT_CANNOT_BE_USED,
13675 CURSOR_MOVEMENT_MUST_SCROLL,
13676 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
13677 };
13678
13679 static int
13680 try_cursor_movement (window, startp, scroll_step)
13681 Lisp_Object window;
13682 struct text_pos startp;
13683 int *scroll_step;
13684 {
13685 struct window *w = XWINDOW (window);
13686 struct frame *f = XFRAME (w->frame);
13687 int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
13688
13689 #if GLYPH_DEBUG
13690 if (inhibit_try_cursor_movement)
13691 return rc;
13692 #endif
13693
13694 13695
13696 if (
13697 PT >= CHARPOS (startp)
13698
13699 && !current_buffer->clip_changed
13700 13701 13702 13703
13704 && !update_mode_lines
13705 && !windows_or_buffers_changed
13706 && !cursor_type_changed
13707 13708 13709
13710 && !(!NILP (Vtransient_mark_mode)
13711 && !NILP (current_buffer->mark_active))
13712 && NILP (w->region_showing)
13713 && NILP (Vshow_trailing_whitespace)
13714
13715 && INTEGERP (w->last_point)
13716 13717 13718 13719 13720 13721
13722 && !EQ (window, minibuf_window)
13723 13724 13725 13726 13727
13728 && INTEGERP (w->window_end_vpos)
13729 && XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
13730 && (FRAME_WINDOW_P (f)
13731 || !overlay_arrow_in_current_buffer_p ()))
13732 {
13733 int this_scroll_margin, top_scroll_margin;
13734 struct glyph_row *row = NULL;
13735
13736 #if GLYPH_DEBUG
13737 debug_method_add (w, "cursor movement");
13738 #endif
13739
13740 13741
13742 if (scroll_margin > 0)
13743 {
13744 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
13745 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
13746 }
13747 else
13748 this_scroll_margin = 0;
13749
13750 top_scroll_margin = this_scroll_margin;
13751 if (WINDOW_WANTS_HEADER_LINE_P (w))
13752 top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
13753
13754 13755
13756 if (w->last_cursor.vpos < 0
13757 || w->last_cursor.vpos >= w->current_matrix->nrows)
13758 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13759 else
13760 {
13761 row = MATRIX_ROW (w->current_matrix, w->last_cursor.vpos);
13762 if (row->mode_line_p)
13763 ++row;
13764 if (!row->enabled_p)
13765 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13766 13767 13768 13769 13770 13771
13772 13773 13774
13775 if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
13776 {
13777 while (MATRIX_ROW_CONTINUATION_LINE_P (row))
13778 {
13779 xassert (row->enabled_p);
13780 --row;
13781 13782 13783
13784 if (row <= w->current_matrix->rows)
13785 {
13786 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13787 break;
13788 }
13789
13790 }
13791 }
13792 }
13793
13794 if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
13795 {
13796 int scroll_p = 0;
13797 int last_y = window_text_bottom_y (w) - this_scroll_margin;
13798
13799 if (PT > XFASTINT (w->last_point))
13800 {
13801
13802 while (MATRIX_ROW_END_CHARPOS (row) < PT
13803 && MATRIX_ROW_BOTTOM_Y (row) < last_y)
13804 {
13805 xassert (row->enabled_p);
13806 ++row;
13807 }
13808
13809 13810 13811
13812 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13813 && MATRIX_ROW_END_CHARPOS (row) == PT
13814 && row < w->current_matrix->rows
13815 + w->current_matrix->nrows - 1
13816 && MATRIX_ROW_START_CHARPOS (row+1) == PT
13817 && !cursor_row_p (w, row))
13818 ++row;
13819
13820 13821 13822 13823
13824 if (MATRIX_ROW_BOTTOM_Y (row) > last_y
13825 || PT > MATRIX_ROW_END_CHARPOS (row)
13826 13827
13828 || (MATRIX_ROW_BOTTOM_Y (row) == last_y
13829 && PT == MATRIX_ROW_END_CHARPOS (row)
13830 && !row->ends_at_zv_p
13831 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
13832 scroll_p = 1;
13833 }
13834 else if (PT < XFASTINT (w->last_point))
13835 {
13836 13837
13838 while (!row->mode_line_p
13839 && (MATRIX_ROW_START_CHARPOS (row) > PT
13840 || (MATRIX_ROW_START_CHARPOS (row) == PT
13841 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
13842 || (
13843 row > w->current_matrix->rows
13844 && (row-1)->ends_in_newline_from_string_p))))
13845 && (row->y > top_scroll_margin
13846 || CHARPOS (startp) == BEGV))
13847 {
13848 xassert (row->enabled_p);
13849 --row;
13850 }
13851
13852 13853 13854 13855 13856
13857 if (row < w->current_matrix->rows
13858 || row->mode_line_p)
13859 {
13860 row = w->current_matrix->rows;
13861 if (row->mode_line_p)
13862 ++row;
13863 }
13864
13865 13866
13867 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13868 && MATRIX_ROW_END_CHARPOS (row) == PT
13869 && !cursor_row_p (w, row))
13870 ++row;
13871
13872
13873 if (row->y < top_scroll_margin
13874 && CHARPOS (startp) != BEGV)
13875 scroll_p = 1;
13876 }
13877 else
13878 {
13879 13880
13881 rc = CURSOR_MOVEMENT_SUCCESS;
13882 }
13883
13884 if (PT < MATRIX_ROW_START_CHARPOS (row)
13885 || PT > MATRIX_ROW_END_CHARPOS (row))
13886 {
13887
13888 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13889 }
13890 else if (rc != CURSOR_MOVEMENT_SUCCESS
13891 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
13892 && make_cursor_line_fully_visible_p)
13893 {
13894 if (PT == MATRIX_ROW_END_CHARPOS (row)
13895 && !row->ends_at_zv_p
13896 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
13897 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13898 else if (row->height > window_box_height (w))
13899 {
13900 13901 13902 13903
13904 *scroll_step = 1;
13905 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13906 }
13907 else
13908 {
13909 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
13910 if (!cursor_row_fully_visible_p (w, 0, 1))
13911 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13912 else
13913 rc = CURSOR_MOVEMENT_SUCCESS;
13914 }
13915 }
13916 else if (scroll_p)
13917 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13918 else if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
13919 {
13920 13921 13922 13923
13924 13925 13926
13927 int rv = 0;
13928
13929 do
13930 {
13931 rv |= set_cursor_from_row (w, row, w->current_matrix,
13932 0, 0, 0, 0);
13933 13934
13935 if (rv
13936 && MATRIX_ROW (w->current_matrix, w->cursor.vpos)->ends_at_zv_p)
13937 {
13938 rc = CURSOR_MOVEMENT_SUCCESS;
13939 break;
13940 }
13941 ++row;
13942 }
13943 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13944 && MATRIX_ROW_START_CHARPOS (row) <= PT
13945 && PT <= MATRIX_ROW_END_CHARPOS (row)
13946 && cursor_row_p (w, row));
13947 13948 13949
13950 if (rc != CURSOR_MOVEMENT_SUCCESS
13951 && (!rv
13952 || (MATRIX_ROW_START_CHARPOS (row) <= PT
13953 && PT <= MATRIX_ROW_END_CHARPOS (row))))
13954 rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
13955 else
13956 rc = CURSOR_MOVEMENT_SUCCESS;
13957 }
13958 else
13959 {
13960 do
13961 {
13962 if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
13963 {
13964 rc = CURSOR_MOVEMENT_SUCCESS;
13965 break;
13966 }
13967 ++row;
13968 }
13969 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13970 && MATRIX_ROW_START_CHARPOS (row) == PT
13971 && cursor_row_p (w, row));
13972 }
13973 }
13974 }
13975
13976 return rc;
13977 }
13978
13979 void
13980 set_vertical_scroll_bar (w)
13981 struct window *w;
13982 {
13983 int start, end, whole;
13984
13985 13986 13987 13988 13989 13990 13991
13992 if (!MINI_WINDOW_P (w)
13993 || (w == XWINDOW (minibuf_window)
13994 && NILP (echo_area_buffer[0])))
13995 {
13996 struct buffer *buf = XBUFFER (w->buffer);
13997 whole = BUF_ZV (buf) - BUF_BEGV (buf);
13998 start = marker_position (w->start) - BUF_BEGV (buf);
13999 14000
14001 end = BUF_Z (buf) - XFASTINT (w->window_end_pos) - BUF_BEGV (buf);
14002
14003 if (end < start)
14004 end = start;
14005 if (whole < (end - start))
14006 whole = end - start;
14007 }
14008 else
14009 start = end = whole = 0;
14010
14011
14012 if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
14013 (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
14014 (w, end - start, whole, start);
14015 }
14016
14017
14018 14019 14020 14021 14022 14023
14024
14025 static void
14026 redisplay_window (window, just_this_one_p)
14027 Lisp_Object window;
14028 int just_this_one_p;
14029 {
14030 struct window *w = XWINDOW (window);
14031 struct frame *f = XFRAME (w->frame);
14032 struct buffer *buffer = XBUFFER (w->buffer);
14033 struct buffer *old = current_buffer;
14034 struct text_pos lpoint, opoint, startp;
14035 int update_mode_line;
14036 int tem;
14037 struct it it;
14038
14039 int current_matrix_up_to_date_p = 0;
14040 int used_current_matrix_p = 0;
14041 14042
14043 int buffer_unchanged_p = 0;
14044 int temp_scroll_step = 0;
14045 int count = SPECPDL_INDEX ();
14046 int rc;
14047 int centering_position = -1;
14048 int last_line_misfit = 0;
14049 int beg_unchanged, end_unchanged;
14050
14051 SET_TEXT_POS (lpoint, PT, PT_BYTE);
14052 opoint = lpoint;
14053
14054
14055 xassert (!NILP (w->buffer));
14056 #if GLYPH_DEBUG
14057 *w->desired_matrix->method = 0;
14058 #endif
14059
14060 restart:
14061 reconsider_clip_changes (w, buffer);
14062
14063
14064 update_mode_line = (!NILP (w->update_mode_line)
14065 || update_mode_lines
14066 || buffer->clip_changed
14067 || buffer->prevent_redisplay_optimizations_p);
14068
14069 if (MINI_WINDOW_P (w))
14070 {
14071 if (w == XWINDOW (echo_area_window)
14072 && !NILP (echo_area_buffer[0]))
14073 {
14074 if (update_mode_line)
14075 14076
14077 goto finish_menu_bars;
14078 else
14079
14080 goto finish_scroll_bars;
14081 }
14082 else if ((w != XWINDOW (minibuf_window)
14083 || minibuf_level == 0)
14084
14085 && BUF_Z (XBUFFER (w->buffer)) == BUF_BEG (XBUFFER (w->buffer))
14086 14087
14088 && !NILP (Fmemq (w->buffer, Vminibuffer_list)))
14089 {
14090 14091
14092 int yb = window_text_bottom_y (w);
14093 struct glyph_row *row;
14094 int y;
14095
14096 for (y = 0, row = w->desired_matrix->rows;
14097 y < yb;
14098 y += row->height, ++row)
14099 blank_row (w, row, y);
14100 goto finish_scroll_bars;
14101 }
14102
14103 clear_glyph_matrix (w->desired_matrix);
14104 }
14105
14106 14107
14108 14109
14110 set_buffer_internal_1 (XBUFFER (w->buffer));
14111
14112 current_matrix_up_to_date_p
14113 = (!NILP (w->window_end_valid)
14114 && !current_buffer->clip_changed
14115 && !current_buffer->prevent_redisplay_optimizations_p
14116 && XFASTINT (w->last_modified) >= MODIFF
14117 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
14118
14119 14120 14121
14122 if (!current_matrix_up_to_date_p
14123 && !NILP (Vwindow_text_change_functions))
14124 {
14125 safe_run_hooks (Qwindow_text_change_functions);
14126 goto restart;
14127 }
14128
14129 beg_unchanged = BEG_UNCHANGED;
14130 end_unchanged = END_UNCHANGED;
14131
14132 SET_TEXT_POS (opoint, PT, PT_BYTE);
14133
14134 specbind (Qinhibit_point_motion_hooks, Qt);
14135
14136 buffer_unchanged_p
14137 = (!NILP (w->window_end_valid)
14138 && !current_buffer->clip_changed
14139 && XFASTINT (w->last_modified) >= MODIFF
14140 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
14141
14142 14143
14144 if (windows_or_buffers_changed)
14145 {
14146 14147
14148 if (XMARKER (w->start)->buffer == current_buffer)
14149 compute_window_start_on_continuation_line (w);
14150
14151 w->window_end_valid = Qnil;
14152 }
14153
14154
14155 CHECK_WINDOW_END (w);
14156 if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
14157 abort ();
14158 if (BYTEPOS (opoint) < CHARPOS (opoint))
14159 abort ();
14160
14161
14162 if (!NILP (w->column_number_displayed)
14163 14164
14165 && !(PT == XFASTINT (w->last_point)
14166 && XFASTINT (w->last_modified) >= MODIFF
14167 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
14168 && (XFASTINT (w->column_number_displayed)
14169 != (int) current_column ()))
14170 update_mode_line = 1;
14171
14172 14173
14174 if (!just_this_one_p)
14175 {
14176 struct buffer *current_base, *window_base;
14177 current_base = current_buffer;
14178 window_base = XBUFFER (XWINDOW (selected_window)->buffer);
14179 if (current_base->base_buffer)
14180 current_base = current_base->base_buffer;
14181 if (window_base->base_buffer)
14182 window_base = window_base->base_buffer;
14183 if (current_base == window_base)
14184 buffer_shared++;
14185 }
14186
14187 14188
14189 if (!EQ (window, selected_window))
14190 {
14191 int new_pt = XMARKER (w->pointm)->charpos;
14192 int new_pt_byte = marker_byte_position (w->pointm);
14193 if (new_pt < BEGV)
14194 {
14195 new_pt = BEGV;
14196 new_pt_byte = BEGV_BYTE;
14197 set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
14198 }
14199 else if (new_pt > (ZV - 1))
14200 {
14201 new_pt = ZV;
14202 new_pt_byte = ZV_BYTE;
14203 set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
14204 }
14205
14206
14207 TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
14208 }
14209
14210 14211 14212 14213 14214
14215 if (current_buffer->width_run_cache)
14216 {
14217 struct Lisp_Char_Table *disptab = buffer_display_table ();
14218
14219 if (! disptab_matches_widthtab (disptab,
14220 XVECTOR (current_buffer->width_table)))
14221 {
14222 invalidate_region_cache (current_buffer,
14223 current_buffer->width_run_cache,
14224 BEG, Z);
14225 recompute_width_table (current_buffer, disptab);
14226 }
14227 }
14228
14229
14230 if (XMARKER (w->start)->buffer != current_buffer)
14231 goto recenter;
14232
14233 SET_TEXT_POS_FROM_MARKER (startp, w->start);
14234
14235 14236
14237 if (!NILP (w->optional_new_start)
14238 && CHARPOS (startp) >= BEGV
14239 && CHARPOS (startp) <= ZV)
14240 {
14241 w->optional_new_start = Qnil;
14242 start_display (&it, w, startp);
14243 move_it_to (&it, PT, 0, it.last_visible_y, -1,
14244 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
14245 if (IT_CHARPOS (it) == PT)
14246 w->force_start = Qt;
14247
14248 else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
14249 w->force_start = Qt;
14250 }
14251
14252 force_start:
14253
14254 14255
14256 if (!NILP (w->force_start)
14257 || w->frozen_window_start_p)
14258 {
14259
14260 int new_vpos = -1;
14261
14262 w->force_start = Qnil;
14263 w->vscroll = 0;
14264 w->window_end_valid = Qnil;
14265
14266
14267 if (!buffer_unchanged_p)
14268 w->base_line_number = Qnil;
14269
14270 14271 14272
14273 14274 14275 14276
14277 if (!update_mode_line
14278 || ! NILP (Vwindow_scroll_functions))
14279 {
14280 update_mode_line = 1;
14281 w->update_mode_line = Qt;
14282 startp = run_window_scroll_functions (window, startp);
14283 }
14284
14285 w->last_modified = make_number (0);
14286 w->last_overlay_modified = make_number (0);
14287 if (CHARPOS (startp) < BEGV)
14288 SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
14289 else if (CHARPOS (startp) > ZV)
14290 SET_TEXT_POS (startp, ZV, ZV_BYTE);
14291
14292 14293
14294 14295 14296
14297 if (!try_window (window, startp, 0))
14298 {
14299 w->force_start = Qt;
14300 clear_glyph_matrix (w->desired_matrix);
14301 goto need_larger_matrices;
14302 }
14303
14304 if (w->cursor.vpos < 0 && !w->frozen_window_start_p)
14305 {
14306 14307 14308
14309 new_vpos = window_box_height (w) / 2;
14310 }
14311
14312 if (!cursor_row_fully_visible_p (w, 0, 0))
14313 {
14314 14315
14316 new_vpos = window_box_height (w);
14317 }
14318
14319 14320
14321 if (new_vpos >= 0)
14322 {
14323 struct glyph_row *row;
14324
14325 row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
14326 while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos)
14327 ++row;
14328
14329 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
14330 MATRIX_ROW_START_BYTEPOS (row));
14331
14332 if (w != XWINDOW (selected_window))
14333 set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
14334 else if (current_buffer == old)
14335 SET_TEXT_POS (lpoint, PT, PT_BYTE);
14336
14337 set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
14338
14339 14340
14341 if (!NILP (Vtransient_mark_mode)
14342 && !NILP (current_buffer->mark_active))
14343 {
14344 clear_glyph_matrix (w->desired_matrix);
14345 if (!try_window (window, startp, 0))
14346 goto need_larger_matrices;
14347 }
14348 }
14349
14350 #if GLYPH_DEBUG
14351 debug_method_add (w, "forced window start");
14352 #endif
14353 goto done;
14354 }
14355
14356 14357 14358
14359 if (current_matrix_up_to_date_p
14360 && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
14361 rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
14362 {
14363 switch (rc)
14364 {
14365 case CURSOR_MOVEMENT_SUCCESS:
14366 used_current_matrix_p = 1;
14367 goto done;
14368
14369 case CURSOR_MOVEMENT_MUST_SCROLL:
14370 goto try_to_scroll;
14371
14372 default:
14373 abort ();
14374 }
14375 }
14376 14377
14378 else if (!NILP (w->start_at_line_beg)
14379 && !(CHARPOS (startp) <= BEGV
14380 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'))
14381 {
14382 #if GLYPH_DEBUG
14383 debug_method_add (w, "recenter 1");
14384 #endif
14385 goto recenter;
14386 }
14387
14388 14389 14390
14391 else if ((tem = try_window_id (w)) != 0)
14392 {
14393 #if GLYPH_DEBUG
14394 debug_method_add (w, "try_window_id %d", tem);
14395 #endif
14396
14397 if (fonts_changed_p)
14398 goto need_larger_matrices;
14399 if (tem > 0)
14400 goto done;
14401
14402 14403
14404 }
14405 else if (CHARPOS (startp) >= BEGV
14406 && CHARPOS (startp) <= ZV
14407 && PT >= CHARPOS (startp)
14408 && (CHARPOS (startp) < ZV
14409
14410 || CHARPOS (startp) == BEGV
14411 || (XFASTINT (w->last_modified) >= MODIFF
14412 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)))
14413 {
14414
14415 14416 14417 14418 14419 14420 14421 14422 14423
14424 if (NILP (w->start_at_line_beg)
14425 && NILP (do_mouse_tracking)
14426 && CHARPOS (startp) > BEGV
14427 && CHARPOS (startp) > BEG + beg_unchanged
14428 && CHARPOS (startp) <= Z - end_unchanged
14429 14430 14431 14432 14433
14434 && XMARKER (w->start)->buffer == current_buffer
14435 && compute_window_start_on_continuation_line (w))
14436 {
14437 w->force_start = Qt;
14438 SET_TEXT_POS_FROM_MARKER (startp, w->start);
14439 goto force_start;
14440 }
14441
14442 #if GLYPH_DEBUG
14443 debug_method_add (w, "same window start");
14444 #endif
14445
14446 14447
14448 if (!current_matrix_up_to_date_p
14449 14450 14451
14452 || !NILP (Vwindow_scroll_functions)
14453 || MINI_WINDOW_P (w)
14454 || !(used_current_matrix_p
14455 = try_window_reusing_current_matrix (w)))
14456 {
14457 IF_DEBUG (debug_method_add (w, "1"));
14458 if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
14459 14460 14461
14462 goto try_to_scroll;
14463 }
14464
14465 if (fonts_changed_p)
14466 goto need_larger_matrices;
14467
14468 if (w->cursor.vpos >= 0)
14469 {
14470 if (!just_this_one_p
14471 || current_buffer->clip_changed
14472 || BEG_UNCHANGED < CHARPOS (startp))
14473
14474 w->base_line_number = Qnil;
14475
14476 if (!cursor_row_fully_visible_p (w, 1, 0))
14477 {
14478 clear_glyph_matrix (w->desired_matrix);
14479 last_line_misfit = 1;
14480 }
14481
14482 else
14483 goto done;
14484 }
14485 else
14486 clear_glyph_matrix (w->desired_matrix);
14487 }
14488
14489 try_to_scroll:
14490
14491 w->last_modified = make_number (0);
14492 w->last_overlay_modified = make_number (0);
14493
14494
14495 if (!update_mode_line)
14496 {
14497 update_mode_line = 1;
14498 w->update_mode_line = Qt;
14499 }
14500
14501
14502 if ((scroll_conservatively
14503 || scroll_step
14504 || temp_scroll_step
14505 || NUMBERP (current_buffer->scroll_up_aggressively)
14506 || NUMBERP (current_buffer->scroll_down_aggressively))
14507 && !current_buffer->clip_changed
14508 && CHARPOS (startp) >= BEGV
14509 && CHARPOS (startp) <= ZV)
14510 {
14511 14512
14513 int rc = try_scrolling (window, just_this_one_p,
14514 scroll_conservatively,
14515 scroll_step,
14516 temp_scroll_step, last_line_misfit);
14517 switch (rc)
14518 {
14519 case SCROLLING_SUCCESS:
14520 goto done;
14521
14522 case SCROLLING_NEED_LARGER_MATRICES:
14523 goto need_larger_matrices;
14524
14525 case SCROLLING_FAILED:
14526 break;
14527
14528 default:
14529 abort ();
14530 }
14531 }
14532
14533
14534
14535 recenter:
14536 if (centering_position < 0)
14537 centering_position = window_box_height (w) / 2;
14538
14539 #if GLYPH_DEBUG
14540 debug_method_add (w, "recenter");
14541 #endif
14542
14543
14544
14545
14546 if (!buffer_unchanged_p)
14547 w->base_line_number = Qnil;
14548
14549
14550 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
14551 it.current_y = it.last_visible_y;
14552 move_it_vertically_backward (&it, centering_position);
14553 xassert (IT_CHARPOS (it) >= BEGV);
14554
14555 14556 14557 14558 14559
14560 if (it.current_y <= 0)
14561 {
14562 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
14563 move_it_vertically_backward (&it, 0);
14564 it.current_y = 0;
14565 }
14566
14567 it.current_x = it.hpos = 0;
14568
14569 14570
14571 set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
14572
14573
14574 startp = run_window_scroll_functions (window, it.current.pos);
14575
14576
14577 if (!current_matrix_up_to_date_p
14578 || windows_or_buffers_changed
14579 || cursor_type_changed
14580 14581
14582 || !NILP (Vwindow_scroll_functions)
14583 || !just_this_one_p
14584 || MINI_WINDOW_P (w)
14585 || !(used_current_matrix_p
14586 = try_window_reusing_current_matrix (w)))
14587 try_window (window, startp, 0);
14588
14589 14590 14591
14592 if (fonts_changed_p)
14593 goto need_larger_matrices;
14594
14595 14596 14597 14598 14599
14600 if (w->cursor.vpos < 0)
14601 {
14602 if (!NILP (w->window_end_valid)
14603 && PT >= Z - XFASTINT (w->window_end_pos))
14604 {
14605 clear_glyph_matrix (w->desired_matrix);
14606 move_it_by_lines (&it, 1, 0);
14607 try_window (window, it.current.pos, 0);
14608 }
14609 else if (PT < IT_CHARPOS (it))
14610 {
14611 clear_glyph_matrix (w->desired_matrix);
14612 move_it_by_lines (&it, -1, 0);
14613 try_window (window, it.current.pos, 0);
14614 }
14615 else
14616 {
14617
14618 }
14619 }
14620
14621 14622 14623 14624
14625 if (w->cursor.vpos < 0)
14626 {
14627 struct glyph_row *row = w->current_matrix->rows;
14628 if (row->mode_line_p)
14629 ++row;
14630 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
14631 }
14632
14633 if (!cursor_row_fully_visible_p (w, 0, 0))
14634 {
14635
14636 if (w->vscroll)
14637 {
14638 w->vscroll = 0;
14639 clear_glyph_matrix (w->desired_matrix);
14640 goto recenter;
14641 }
14642
14643 14644 14645
14646 if (centering_position == 0)
14647 goto done;
14648
14649 clear_glyph_matrix (w->desired_matrix);
14650 centering_position = 0;
14651 goto recenter;
14652 }
14653
14654 done:
14655
14656 SET_TEXT_POS_FROM_MARKER (startp, w->start);
14657 w->start_at_line_beg = ((CHARPOS (startp) == BEGV
14658 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
14659 ? Qt : Qnil);
14660
14661
14662 if ((update_mode_line
14663 14664 14665 14666
14667 || (!just_this_one_p
14668 && !FRAME_WINDOW_P (f)
14669 && !WINDOW_FULL_WIDTH_P (w))
14670
14671 || INTEGERP (w->base_line_pos)
14672
14673 || (!NILP (w->column_number_displayed)
14674 && (XFASTINT (w->column_number_displayed)
14675 != (int) current_column ())))
14676
14677 && (WINDOW_WANTS_MODELINE_P (w)
14678 || WINDOW_WANTS_HEADER_LINE_P (w)))
14679 {
14680 display_mode_lines (w);
14681
14682 14683
14684 if (WINDOW_WANTS_MODELINE_P (w)
14685 && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
14686 {
14687 fonts_changed_p = 1;
14688 MATRIX_MODE_LINE_ROW (w->current_matrix)->height
14689 = DESIRED_MODE_LINE_HEIGHT (w);
14690 }
14691
14692 14693
14694 if (WINDOW_WANTS_HEADER_LINE_P (w)
14695 && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
14696 {
14697 fonts_changed_p = 1;
14698 MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
14699 = DESIRED_HEADER_LINE_HEIGHT (w);
14700 }
14701
14702 if (fonts_changed_p)
14703 goto need_larger_matrices;
14704 }
14705
14706 if (!line_number_displayed
14707 && !BUFFERP (w->base_line_pos))
14708 {
14709 w->base_line_pos = Qnil;
14710 w->base_line_number = Qnil;
14711 }
14712
14713 finish_menu_bars:
14714
14715
14716 if (update_mode_line
14717 && EQ (FRAME_SELECTED_WINDOW (f), window))
14718 {
14719 int redisplay_menu_p = 0;
14720 int redisplay_tool_bar_p = 0;
14721
14722 if (FRAME_WINDOW_P (f))
14723 {
14724 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
14725 || defined (HAVE_NS) || defined (USE_GTK)
14726 redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
14727 #else
14728 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
14729 #endif
14730 }
14731 else
14732 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
14733
14734 if (redisplay_menu_p)
14735 display_menu_bar (w);
14736
14737 #ifdef HAVE_WINDOW_SYSTEM
14738 if (FRAME_WINDOW_P (f))
14739 {
14740 #if defined (USE_GTK) || defined (HAVE_NS)
14741 redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
14742 #else
14743 redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
14744 && (FRAME_TOOL_BAR_LINES (f) > 0
14745 || !NILP (Vauto_resize_tool_bars));
14746 #endif
14747
14748 if (redisplay_tool_bar_p && redisplay_tool_bar (f))
14749 {
14750 extern int ignore_mouse_drag_p;
14751 ignore_mouse_drag_p = 1;
14752 }
14753 }
14754 #endif
14755 }
14756
14757 #ifdef HAVE_WINDOW_SYSTEM
14758 if (FRAME_WINDOW_P (f)
14759 && update_window_fringes (w, (just_this_one_p
14760 || (!used_current_matrix_p && !overlay_arrow_seen)
14761 || w->pseudo_window_p)))
14762 {
14763 update_begin (f);
14764 BLOCK_INPUT;
14765 if (draw_window_fringes (w, 1))
14766 x_draw_vertical_border (w);
14767 UNBLOCK_INPUT;
14768 update_end (f);
14769 }
14770 #endif
14771
14772 14773 14774 14775
14776 need_larger_matrices:
14777 ;
14778 finish_scroll_bars:
14779
14780 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
14781 {
14782
14783 set_vertical_scroll_bar (w);
14784
14785 14786
14787 if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
14788 (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
14789 }
14790
14791
14792 TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
14793 set_buffer_internal_1 (old);
14794 14795
14796 if (CHARPOS (lpoint) <= ZV)
14797 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
14798
14799 unbind_to (count, Qnil);
14800 }
14801
14802
14803 14804 14805 14806 14807 14808 14809 14810 14811
14812
14813 int
14814 try_window (window, pos, flags)
14815 Lisp_Object window;
14816 struct text_pos pos;
14817 int flags;
14818 {
14819 struct window *w = XWINDOW (window);
14820 struct it it;
14821 struct glyph_row *last_text_row = NULL;
14822 struct frame *f = XFRAME (w->frame);
14823
14824
14825 set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
14826
14827
14828 w->cursor.vpos = -1;
14829 overlay_arrow_seen = 0;
14830
14831
14832 start_display (&it, w, pos);
14833
14834
14835 while (it.current_y < it.last_visible_y)
14836 {
14837 if (display_line (&it))
14838 last_text_row = it.glyph_row - 1;
14839 if (fonts_changed_p && !(flags & TRY_WINDOW_IGNORE_FONTS_CHANGE))
14840 return 0;
14841 }
14842
14843
14844 if ((flags & TRY_WINDOW_CHECK_MARGINS)
14845 && !MINI_WINDOW_P (w))
14846 {
14847 int this_scroll_margin;
14848
14849 if (scroll_margin > 0)
14850 {
14851 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
14852 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
14853 }
14854 else
14855 this_scroll_margin = 0;
14856
14857 if ((w->cursor.y >= 0
14858 && w->cursor.y < this_scroll_margin
14859 && CHARPOS (pos) > BEGV
14860 && IT_CHARPOS (it) < ZV)
14861 14862 14863 14864
14865 || w->cursor.y > it.last_visible_y - this_scroll_margin - 1)
14866 {
14867 w->cursor.vpos = -1;
14868 clear_glyph_matrix (w->desired_matrix);
14869 return -1;
14870 }
14871 }
14872
14873
14874 if (XFASTINT (w->window_end_pos) <= 0
14875 && Z != IT_CHARPOS (it))
14876 w->update_mode_line = Qt;
14877
14878 14879 14880
14881 if (last_text_row)
14882 {
14883 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
14884 w->window_end_bytepos
14885 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
14886 w->window_end_pos
14887 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
14888 w->window_end_vpos
14889 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
14890 xassert (MATRIX_ROW (w->desired_matrix, XFASTINT (w->window_end_vpos))
14891 ->displays_text_p);
14892 }
14893 else
14894 {
14895 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
14896 w->window_end_pos = make_number (Z - ZV);
14897 w->window_end_vpos = make_number (0);
14898 }
14899
14900
14901 w->window_end_valid = Qnil;
14902 return 1;
14903 }
14904
14905
14906
14907 14908 14909
14910
14911 14912 14913 14914
14915
14916 static int
14917 try_window_reusing_current_matrix (w)
14918 struct window *w;
14919 {
14920 struct frame *f = XFRAME (w->frame);
14921 struct glyph_row *row, *bottom_row;
14922 struct it it;
14923 struct run run;
14924 struct text_pos start, new_start;
14925 int nrows_scrolled, i;
14926 struct glyph_row *last_text_row;
14927 struct glyph_row *last_reused_text_row;
14928 struct glyph_row *start_row;
14929 int start_vpos, min_y, max_y;
14930
14931 #if GLYPH_DEBUG
14932 if (inhibit_try_window_reusing)
14933 return 0;
14934 #endif
14935
14936 if (
14937 !FRAME_WINDOW_P (f)
14938 14939
14940 || windows_or_buffers_changed
14941 || cursor_type_changed)
14942 return 0;
14943
14944
14945 if ((!NILP (Vtransient_mark_mode)
14946 && !NILP (current_buffer->mark_active))
14947 || !NILP (w->region_showing)
14948 || !NILP (Vshow_trailing_whitespace))
14949 return 0;
14950
14951
14952 if (WINDOW_WANTS_HEADER_LINE_P (w)
14953 != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
14954 return 0;
14955
14956 14957
14958 start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
14959 if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
14960 return 0;
14961
14962 14963
14964 SET_TEXT_POS_FROM_MARKER (new_start, w->start);
14965 start = start_row->minpos;
14966 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
14967
14968
14969 clear_glyph_matrix (w->desired_matrix);
14970
14971 if (CHARPOS (new_start) <= CHARPOS (start))
14972 {
14973 int first_row_y;
14974
14975 14976 14977 14978
14979 if (in_ellipses_for_invisible_text_p (&start_row->start, w))
14980 return 0;
14981
14982 IF_DEBUG (debug_method_add (w, "twu1"));
14983
14984 14985 14986 14987
14988 start_display (&it, w, new_start);
14989 first_row_y = it.current_y;
14990 w->cursor.vpos = -1;
14991 last_text_row = last_reused_text_row = NULL;
14992
14993 while (it.current_y < it.last_visible_y
14994 && !fonts_changed_p)
14995 {
14996 14997 14998 14999
15000 while (IT_CHARPOS (it) > CHARPOS (start))
15001 {
15002
15003 start_row++;
15004 start = start_row->minpos;
15005
15006 if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
15007 || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
15008 || CHARPOS (start) == ZV)
15009 {
15010 clear_glyph_matrix (w->desired_matrix);
15011 return 0;
15012 }
15013
15014 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
15015 }
15016 15017
15018 if (IT_CHARPOS (it) == CHARPOS (start))
15019 break;
15020
15021 if (display_line (&it))
15022 last_text_row = it.glyph_row - 1;
15023 }
15024
15025 15026 15027
15028 if (it.current_y < it.last_visible_y)
15029 {
15030
15031 nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
15032
15033
15034 if (w->cursor.vpos < 0)
15035 {
15036 int dy = it.current_y - start_row->y;
15037
15038 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15039 row = row_containing_pos (w, PT, row, NULL, dy);
15040 if (row)
15041 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
15042 dy, nrows_scrolled);
15043 else
15044 {
15045 clear_glyph_matrix (w->desired_matrix);
15046 return 0;
15047 }
15048 }
15049
15050 15051 15052 15053 15054 15055
15056 run.current_y = start_row->y;
15057 run.desired_y = it.current_y;
15058 run.height = it.last_visible_y - it.current_y;
15059
15060 if (run.height > 0 && run.current_y != run.desired_y)
15061 {
15062 update_begin (f);
15063 FRAME_RIF (f)->update_window_begin_hook (w);
15064 FRAME_RIF (f)->clear_window_mouse_face (w);
15065 FRAME_RIF (f)->scroll_run_hook (w, &run);
15066 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
15067 update_end (f);
15068 }
15069
15070
15071 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
15072 rotate_matrix (w->current_matrix,
15073 start_vpos,
15074 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
15075 nrows_scrolled);
15076
15077
15078 for (i = 0; i < nrows_scrolled; ++i)
15079 (start_row + i)->enabled_p = 0;
15080
15081
15082 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
15083 max_y = it.last_visible_y;
15084 for (row = start_row + nrows_scrolled;
15085 row < bottom_row;
15086 ++row)
15087 {
15088 row->y = it.current_y;
15089 row->visible_height = row->height;
15090
15091 if (row->y < min_y)
15092 row->visible_height -= min_y - row->y;
15093 if (row->y + row->height > max_y)
15094 row->visible_height -= row->y + row->height - max_y;
15095 row->redraw_fringe_bitmaps_p = 1;
15096
15097 it.current_y += row->height;
15098
15099 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15100 last_reused_text_row = row;
15101 if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
15102 break;
15103 }
15104
15105 15106
15107 for (++row; row < bottom_row; ++row)
15108 row->enabled_p = row->mode_line_p = 0;
15109 }
15110
15111 15112 15113 15114
15115 if (last_reused_text_row)
15116 {
15117 w->window_end_bytepos
15118 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
15119 w->window_end_pos
15120 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
15121 w->window_end_vpos
15122 = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
15123 w->current_matrix));
15124 }
15125 else if (last_text_row)
15126 {
15127 w->window_end_bytepos
15128 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15129 w->window_end_pos
15130 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15131 w->window_end_vpos
15132 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
15133 }
15134 else
15135 {
15136
15137 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
15138 w->window_end_pos = make_number (Z - ZV);
15139 w->window_end_vpos = make_number (0);
15140 }
15141 w->window_end_valid = Qnil;
15142
15143
15144 w->desired_matrix->no_scrolling_p = 1;
15145
15146 #if GLYPH_DEBUG
15147 debug_method_add (w, "try_window_reusing_current_matrix 1");
15148 #endif
15149 return 1;
15150 }
15151 else if (CHARPOS (new_start) > CHARPOS (start))
15152 {
15153 struct glyph_row *pt_row, *row;
15154 struct glyph_row *first_reusable_row;
15155 struct glyph_row *first_row_to_display;
15156 int dy;
15157 int yb = window_text_bottom_y (w);
15158
15159 15160
15161 first_reusable_row = start_row;
15162 while (first_reusable_row->enabled_p
15163 && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
15164 && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
15165 < CHARPOS (new_start)))
15166 ++first_reusable_row;
15167
15168
15169 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
15170 || !first_reusable_row->enabled_p
15171 || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
15172 != CHARPOS (new_start)))
15173 return 0;
15174
15175 15176 15177 15178
15179 pt_row = NULL;
15180 for (first_row_to_display = first_reusable_row;
15181 MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
15182 ++first_row_to_display)
15183 {
15184 if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
15185 && PT < MATRIX_ROW_END_CHARPOS (first_row_to_display))
15186 pt_row = first_row_to_display;
15187 }
15188
15189
15190 xassert (first_row_to_display->y < yb);
15191 init_to_row_start (&it, w, first_row_to_display);
15192
15193 nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
15194 - start_vpos);
15195 it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
15196 - nrows_scrolled);
15197 it.current_y = (first_row_to_display->y - first_reusable_row->y
15198 + WINDOW_HEADER_LINE_HEIGHT (w));
15199
15200 15201 15202
15203 it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
15204 if (pt_row == NULL)
15205 w->cursor.vpos = -1;
15206 last_text_row = NULL;
15207 while (it.current_y < it.last_visible_y && !fonts_changed_p)
15208 if (display_line (&it))
15209 last_text_row = it.glyph_row - 1;
15210
15211 15212
15213 if (pt_row)
15214 {
15215 w->cursor.vpos -= nrows_scrolled;
15216 w->cursor.y -= first_reusable_row->y - start_row->y;
15217 }
15218
15219 15220 15221 15222
15223 if (w->cursor.vpos < 0)
15224 {
15225 clear_glyph_matrix (w->desired_matrix);
15226 return 0;
15227 }
15228
15229
15230 run.current_y = first_reusable_row->y;
15231 run.desired_y = WINDOW_HEADER_LINE_HEIGHT (w);
15232 run.height = it.last_visible_y - run.current_y;
15233 dy = run.current_y - run.desired_y;
15234
15235 if (run.height)
15236 {
15237 update_begin (f);
15238 FRAME_RIF (f)->update_window_begin_hook (w);
15239 FRAME_RIF (f)->clear_window_mouse_face (w);
15240 FRAME_RIF (f)->scroll_run_hook (w, &run);
15241 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
15242 update_end (f);
15243 }
15244
15245
15246 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
15247 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
15248 max_y = it.last_visible_y;
15249 for (row = first_reusable_row; row < first_row_to_display; ++row)
15250 {
15251 row->y -= dy;
15252 row->visible_height = row->height;
15253 if (row->y < min_y)
15254 row->visible_height -= min_y - row->y;
15255 if (row->y + row->height > max_y)
15256 row->visible_height -= row->y + row->height - max_y;
15257 row->redraw_fringe_bitmaps_p = 1;
15258 }
15259
15260
15261 xassert (nrows_scrolled > 0);
15262 rotate_matrix (w->current_matrix,
15263 start_vpos,
15264 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
15265 -nrows_scrolled);
15266
15267
15268 for (row -= nrows_scrolled; row < bottom_row; ++row)
15269 row->enabled_p = 0;
15270
15271 15272
15273 if (pt_row)
15274 {
15275 for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
15276 row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
15277 row++)
15278 {
15279 w->cursor.vpos++;
15280 w->cursor.y = row->y;
15281 }
15282 if (row < bottom_row)
15283 {
15284 struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
15285 struct glyph *end = glyph + row->used[TEXT_AREA];
15286
15287 15288
15289 if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
15290 {
15291 if (!(w->cursor.hpos >= 0
15292 && w->cursor.hpos < row->used[TEXT_AREA]
15293 && BUFFERP (glyph->object)
15294 && glyph->charpos == PT))
15295 return 0;
15296 }
15297 else
15298 for (; glyph < end
15299 && (!BUFFERP (glyph->object)
15300 || glyph->charpos < PT);
15301 glyph++)
15302 {
15303 w->cursor.hpos++;
15304 w->cursor.x += glyph->pixel_width;
15305 }
15306 }
15307 }
15308
15309 15310 15311
15312 if (last_text_row)
15313 {
15314 w->window_end_bytepos
15315 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15316 w->window_end_pos
15317 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15318 w->window_end_vpos
15319 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
15320 }
15321 else
15322 {
15323 w->window_end_vpos
15324 = make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled);
15325 }
15326
15327 w->window_end_valid = Qnil;
15328 w->desired_matrix->no_scrolling_p = 1;
15329
15330 #if GLYPH_DEBUG
15331 debug_method_add (w, "try_window_reusing_current_matrix 2");
15332 #endif
15333 return 1;
15334 }
15335
15336 return 0;
15337 }
15338
15339
15340
15341 15342 15343
15344
15345 static struct glyph_row *find_last_unchanged_at_beg_row P_ ((struct window *));
15346 static struct glyph_row *find_first_unchanged_at_end_row P_ ((struct window *,
15347 int *, int *));
15348 static struct glyph_row *
15349 find_last_row_displaying_text P_ ((struct glyph_matrix *, struct it *,
15350 struct glyph_row *));
15351
15352
15353 15354 15355 15356
15357
15358 static struct glyph_row *
15359 find_last_row_displaying_text (matrix, it, start)
15360 struct glyph_matrix *matrix;
15361 struct it *it;
15362 struct glyph_row *start;
15363 {
15364 struct glyph_row *row, *row_found;
15365
15366 15367 15368
15369 row_found = NULL;
15370 row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
15371 while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15372 {
15373 xassert (row->enabled_p);
15374 row_found = row;
15375 if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
15376 break;
15377 ++row;
15378 }
15379
15380 return row_found;
15381 }
15382
15383
15384 15385 15386 15387 15388 15389 15390 15391 15392
15393
15394 static struct glyph_row *
15395 find_last_unchanged_at_beg_row (w)
15396 struct window *w;
15397 {
15398 int first_changed_pos = BEG + BEG_UNCHANGED;
15399 struct glyph_row *row;
15400 struct glyph_row *row_found = NULL;
15401 int yb = window_text_bottom_y (w);
15402
15403
15404 for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15405 MATRIX_ROW_DISPLAYS_TEXT_P (row)
15406 && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
15407 ++row)
15408 {
15409 if (15410
15411 MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
15412 15413
15414 && !row->ends_at_zv_p
15415 15416 15417
15418 && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
15419 && (row->continued_p
15420 || row->exact_window_width_line_p)))
15421 row_found = row;
15422
15423
15424 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
15425 break;
15426 }
15427
15428 return row_found;
15429 }
15430
15431
15432 15433 15434 15435 15436 15437 15438 15439 15440 15441 15442
15443
15444 static struct glyph_row *
15445 find_first_unchanged_at_end_row (w, delta, delta_bytes)
15446 struct window *w;
15447 int *delta, *delta_bytes;
15448 {
15449 struct glyph_row *row;
15450 struct glyph_row *row_found = NULL;
15451
15452 *delta = *delta_bytes = 0;
15453
15454 15455
15456 eassert (!NILP (w->window_end_valid));
15457
15458 15459 15460
15461 if (XFASTINT (w->window_end_pos) >= END_UNCHANGED)
15462 return NULL;
15463
15464
15465 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
15466
15467
15468 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15469 {
15470 15471 15472 15473 15474
15475 int Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
15476 int Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
15477 int last_unchanged_pos, last_unchanged_pos_old;
15478 struct glyph_row *first_text_row
15479 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15480
15481 *delta = Z - Z_old;
15482 *delta_bytes = Z_BYTE - Z_BYTE_old;
15483
15484 15485 15486 15487 15488 15489
15490 last_unchanged_pos = Z - END_UNCHANGED + BEG;
15491 last_unchanged_pos_old = last_unchanged_pos - *delta;
15492
15493 15494
15495 for (; row > first_text_row; --row)
15496 {
15497 15498
15499 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
15500 break;
15501
15502 if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
15503 row_found = row;
15504 }
15505 }
15506
15507 eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
15508
15509 return row_found;
15510 }
15511
15512
15513 15514 15515 15516 15517
15518
15519 static void
15520 sync_frame_with_window_matrix_rows (w)
15521 struct window *w;
15522 {
15523 struct frame *f = XFRAME (w->frame);
15524 struct glyph_row *window_row, *window_row_end, *frame_row;
15525
15526 15527
15528 xassert (NILP (w->hchild) && NILP (w->vchild));
15529 xassert (WINDOW_FULL_WIDTH_P (w));
15530 xassert (!FRAME_WINDOW_P (f));
15531
15532 15533 15534 15535
15536 window_row = w->current_matrix->rows;
15537 window_row_end = window_row + w->current_matrix->nrows;
15538 frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
15539 while (window_row < window_row_end)
15540 {
15541 struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
15542 struct glyph *end = window_row->glyphs[LAST_AREA];
15543
15544 frame_row->glyphs[LEFT_MARGIN_AREA] = start;
15545 frame_row->glyphs[TEXT_AREA] = start;
15546 frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
15547 frame_row->glyphs[LAST_AREA] = end;
15548
15549 15550
15551 if (!window_row->enabled_p)
15552 frame_row->enabled_p = 0;
15553
15554 ++window_row, ++frame_row;
15555 }
15556 }
15557
15558
15559 15560 15561 15562
15563
15564 struct glyph_row *
15565 row_containing_pos (w, charpos, start, end, dy)
15566 struct window *w;
15567 int charpos;
15568 struct glyph_row *start, *end;
15569 int dy;
15570 {
15571 struct glyph_row *row = start;
15572 struct glyph_row *best_row = NULL;
15573 EMACS_INT mindif = BUF_ZV (XBUFFER (w->buffer)) + 1;
15574 int last_y;
15575
15576
15577 if (row->mode_line_p)
15578 ++row;
15579
15580 if ((end && row >= end) || !row->enabled_p)
15581 return NULL;
15582
15583 last_y = window_text_bottom_y (w) - dy;
15584
15585 while (1)
15586 {
15587
15588 if (end && row >= end)
15589 return NULL;
15590 15591 15592
15593 if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
15594 return NULL;
15595
15596
15597 if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
15598 || (MATRIX_ROW_END_CHARPOS (row) == charpos
15599 15600 15601 15602
15603 && !row->ends_at_zv_p
15604 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
15605 && charpos >= MATRIX_ROW_START_CHARPOS (row))
15606 {
15607 struct glyph *g;
15608
15609 if (NILP (XBUFFER (w->buffer)->bidi_display_reordering))
15610 return row;
15611 15612 15613
15614 for (g = row->glyphs[TEXT_AREA];
15615 g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
15616 g++)
15617 {
15618 if (!STRINGP (g->object))
15619 {
15620 if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
15621 {
15622 mindif = eabs (g->charpos - charpos);
15623 best_row = row;
15624 }
15625 }
15626 }
15627 }
15628 else if (best_row)
15629 return best_row;
15630 ++row;
15631 }
15632 }
15633
15634
15635 15636 15637 15638 15639 15640 15641 15642 15643 15644 15645 15646 15647 15648 15649 15650 15651 15652 15653 15654 15655 15656 15657 15658 15659 15660 15661 15662 15663 15664 15665 15666 15667 15668
15669
15670 static int
15671 try_window_id (w)
15672 struct window *w;
15673 {
15674 struct frame *f = XFRAME (w->frame);
15675 struct glyph_matrix *current_matrix = w->current_matrix;
15676 struct glyph_matrix *desired_matrix = w->desired_matrix;
15677 struct glyph_row *last_unchanged_at_beg_row;
15678 struct glyph_row *first_unchanged_at_end_row;
15679 struct glyph_row *row;
15680 struct glyph_row *bottom_row;
15681 int bottom_vpos;
15682 struct it it;
15683 int delta = 0, delta_bytes = 0, stop_pos, dvpos, dy;
15684 struct text_pos start_pos;
15685 struct run run;
15686 int first_unchanged_at_end_vpos = 0;
15687 struct glyph_row *last_text_row, *last_text_row_at_end;
15688 struct text_pos start;
15689 int first_changed_charpos, last_changed_charpos;
15690
15691 #if GLYPH_DEBUG
15692 if (inhibit_try_window_id)
15693 return 0;
15694 #endif
15695
15696
15697 #if 0
15698 #define GIVE_UP(X) \
15699 do { \
15700 fprintf (stderr, "try_window_id give up %d\n", (X)); \
15701 return 0; \
15702 } while (0)
15703 #else
15704 #define GIVE_UP(X) return 0
15705 #endif
15706
15707 SET_TEXT_POS_FROM_MARKER (start, w->start);
15708
15709 15710
15711 if (MINI_WINDOW_P (w))
15712 GIVE_UP (1);
15713
15714
15715 if (windows_or_buffers_changed || cursor_type_changed)
15716 GIVE_UP (2);
15717
15718 15719 15720 15721
15722 if (current_buffer->clip_changed
15723 || current_buffer->prevent_redisplay_optimizations_p)
15724 GIVE_UP (3);
15725
15726
15727 if (!FRAME_WINDOW_P (f)
15728 && (!FRAME_LINE_INS_DEL_OK (f)
15729 || !WINDOW_FULL_WIDTH_P (w)))
15730 GIVE_UP (4);
15731
15732
15733 if (PT < CHARPOS (start))
15734 GIVE_UP (5);
15735
15736
15737 if (XFASTINT (w->last_modified) == 0)
15738 GIVE_UP (6);
15739
15740
15741 if (XFASTINT (w->hscroll) != 0)
15742 GIVE_UP (7);
15743
15744
15745 if (NILP (w->window_end_valid))
15746 GIVE_UP (8);
15747
15748 15749
15750 if (!NILP (Vtransient_mark_mode)
15751 && !NILP (current_buffer->mark_active))
15752 GIVE_UP (9);
15753
15754
15755 if (!NILP (Vshow_trailing_whitespace))
15756 GIVE_UP (11);
15757
15758
15759 if (!NILP (w->region_showing))
15760 GIVE_UP (10);
15761
15762 15763
15764 if (overlay_arrows_changed_p ())
15765 GIVE_UP (12);
15766
15767 15768 15769 15770
15771 if (!NILP (XBUFFER (w->buffer)->word_wrap))
15772 GIVE_UP (21);
15773
15774 15775 15776 15777 15778 15779 15780 15781
15782 if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering)
15783 && NILP (XBUFFER (w->buffer)->bidi_paragraph_direction))
15784 GIVE_UP (22);
15785
15786 15787 15788 15789
15790 if (MODIFF > SAVE_MODIFF
15791
15792 || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
15793 {
15794 if (GPT - BEG < BEG_UNCHANGED)
15795 BEG_UNCHANGED = GPT - BEG;
15796 if (Z - GPT < END_UNCHANGED)
15797 END_UNCHANGED = Z - GPT;
15798 }
15799
15800
15801 first_changed_charpos = BEG + BEG_UNCHANGED;
15802 last_changed_charpos = Z - END_UNCHANGED;
15803
15804 15805 15806 15807 15808
15809 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
15810 if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
15811 && ((last_changed_charpos < CHARPOS (start)
15812 && CHARPOS (start) == BEGV)
15813 || (last_changed_charpos < CHARPOS (start) - 1
15814 && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
15815 {
15816 int Z_old, delta, Z_BYTE_old, delta_bytes;
15817 struct glyph_row *r0;
15818
15819 15820
15821 Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
15822 Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
15823 delta = Z - Z_old;
15824 delta_bytes = Z_BYTE - Z_BYTE_old;
15825
15826 15827 15828
15829 if (PT >= MATRIX_ROW_END_CHARPOS (row) + delta)
15830 GIVE_UP (13);
15831
15832 15833 15834
15835 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
15836 if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + delta
15837 && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + delta_bytes
15838
15839 && !(PT >= MATRIX_ROW_START_CHARPOS (row) + delta
15840 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
15841 {
15842
15843 if (delta || delta_bytes)
15844 {
15845 struct glyph_row *r1
15846 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
15847 increment_matrix_positions (w->current_matrix,
15848 MATRIX_ROW_VPOS (r0, current_matrix),
15849 MATRIX_ROW_VPOS (r1, current_matrix),
15850 delta, delta_bytes);
15851 }
15852
15853
15854 row = row_containing_pos (w, PT, r0, NULL, 0);
15855 if (row)
15856 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
15857 else
15858 abort ();
15859 return 1;
15860 }
15861 }
15862
15863 15864 15865 15866
15867 if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
15868 15869
15870 && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
15871 || first_changed_charpos == last_changed_charpos))
15872 {
15873 struct glyph_row *r0;
15874
15875 15876 15877
15878 if (PT >= MATRIX_ROW_END_CHARPOS (row))
15879 GIVE_UP (14);
15880
15881 15882 15883
15884 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
15885 if (TEXT_POS_EQUAL_P (start, r0->minpos)
15886
15887 && !(PT >= MATRIX_ROW_START_CHARPOS (row)
15888 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
15889 {
15890 15891
15892 w->window_end_pos
15893 = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
15894 w->window_end_bytepos
15895 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
15896
15897
15898 row = row_containing_pos (w, PT, r0, NULL, 0);
15899 if (row)
15900 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
15901 else
15902 abort ();
15903 return 2;
15904 }
15905 }
15906
15907 15908 15909 15910 15911 15912 15913
15914 if (CHARPOS (start) >= first_changed_charpos
15915 && CHARPOS (start) <= last_changed_charpos)
15916 GIVE_UP (15);
15917
15918 15919 15920 15921
15922 row = MATRIX_FIRST_TEXT_ROW (current_matrix);
15923 if (!TEXT_POS_EQUAL_P (start, row->minpos))
15924 GIVE_UP (16);
15925
15926 15927
15928 row = MATRIX_ROW (current_matrix, XFASTINT (w->window_end_vpos));
15929 if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
15930 GIVE_UP (20);
15931
15932 15933 15934 15935 15936 15937
15938 last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
15939 if (last_unchanged_at_beg_row)
15940 {
15941 15942 15943 15944
15945 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
15946 || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
15947 && last_unchanged_at_beg_row > w->current_matrix->rows)
15948 --last_unchanged_at_beg_row;
15949
15950 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
15951 GIVE_UP (17);
15952
15953 if (init_to_row_end (&it, w, last_unchanged_at_beg_row) == 0)
15954 GIVE_UP (18);
15955 start_pos = it.current.pos;
15956
15957 15958 15959
15960 it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
15961 current_matrix);
15962 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
15963 it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
15964
15965 xassert (it.hpos == 0 && it.current_x == 0);
15966 }
15967 else
15968 {
15969 15970
15971 start_display (&it, w, start);
15972 it.vpos = it.first_vpos;
15973 start_pos = it.current.pos;
15974 }
15975
15976 15977 15978 15979 15980 15981
15982 first_unchanged_at_end_row
15983 = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
15984 IF_DEBUG (debug_delta = delta);
15985 IF_DEBUG (debug_delta_bytes = delta_bytes);
15986
15987 15988 15989 15990 15991
15992 stop_pos = 0;
15993 if (first_unchanged_at_end_row)
15994 {
15995 xassert (last_unchanged_at_beg_row == NULL
15996 || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
15997
15998 15999 16000 16001
16002 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
16003 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
16004 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
16005 < it.last_visible_y))
16006 ++first_unchanged_at_end_row;
16007
16008 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
16009 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
16010 >= it.last_visible_y))
16011 first_unchanged_at_end_row = NULL;
16012 else
16013 {
16014 stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
16015 + delta);
16016 first_unchanged_at_end_vpos
16017 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
16018 xassert (stop_pos >= Z - END_UNCHANGED);
16019 }
16020 }
16021 else if (last_unchanged_at_beg_row == NULL)
16022 GIVE_UP (19);
16023
16024
16025 #if GLYPH_DEBUG
16026
16027 16028 16029
16030 xassert (first_unchanged_at_end_row == NULL
16031 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
16032
16033 debug_last_unchanged_at_beg_vpos
16034 = (last_unchanged_at_beg_row
16035 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
16036 : -1);
16037 debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
16038
16039 #endif
16040
16041
16042 16043 16044
16045 w->cursor.vpos = -1;
16046 last_text_row = NULL;
16047 overlay_arrow_seen = 0;
16048 while (it.current_y < it.last_visible_y
16049 && !fonts_changed_p
16050 && (first_unchanged_at_end_row == NULL
16051 || IT_CHARPOS (it) < stop_pos))
16052 {
16053 if (display_line (&it))
16054 last_text_row = it.glyph_row - 1;
16055 }
16056
16057 if (fonts_changed_p)
16058 return -1;
16059
16060
16061 16062 16063
16064 if (first_unchanged_at_end_row
16065 16066
16067 && it.current_y < it.last_visible_y)
16068 {
16069 dvpos = (it.vpos
16070 - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
16071 current_matrix));
16072 dy = it.current_y - first_unchanged_at_end_row->y;
16073 run.current_y = first_unchanged_at_end_row->y;
16074 run.desired_y = run.current_y + dy;
16075 run.height = it.last_visible_y - max (run.current_y, run.desired_y);
16076 }
16077 else
16078 {
16079 delta = delta_bytes = dvpos = dy
16080 = run.current_y = run.desired_y = run.height = 0;
16081 first_unchanged_at_end_row = NULL;
16082 }
16083 IF_DEBUG (debug_dvpos = dvpos; debug_dy = dy);
16084
16085
16086 16087 16088 16089 16090 16091 16092 16093
16094 if (w->cursor.vpos < 0)
16095 {
16096
16097 if (PT < CHARPOS (start_pos)
16098 && last_unchanged_at_beg_row)
16099 {
16100 row = row_containing_pos (w, PT,
16101 MATRIX_FIRST_TEXT_ROW (w->current_matrix),
16102 last_unchanged_at_beg_row + 1, 0);
16103 if (row)
16104 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
16105 }
16106
16107
16108 else if (first_unchanged_at_end_row)
16109 {
16110 row = row_containing_pos (w, PT - delta,
16111 first_unchanged_at_end_row, NULL, 0);
16112 if (row)
16113 set_cursor_from_row (w, row, w->current_matrix, delta,
16114 delta_bytes, dy, dvpos);
16115 }
16116
16117
16118 if (w->cursor.vpos < 0)
16119 {
16120 clear_glyph_matrix (w->desired_matrix);
16121 return -1;
16122 }
16123 }
16124
16125
16126 {
16127 int this_scroll_margin, cursor_height;
16128
16129 this_scroll_margin = max (0, scroll_margin);
16130 this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
16131 this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
16132 cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
16133
16134 if ((w->cursor.y < this_scroll_margin
16135 && CHARPOS (start) > BEGV)
16136 16137
16138 || (w->cursor.y + (make_cursor_line_fully_visible_p
16139 ? cursor_height + this_scroll_margin
16140 : 1)) > it.last_visible_y)
16141 {
16142 w->cursor.vpos = -1;
16143 clear_glyph_matrix (w->desired_matrix);
16144 return -1;
16145 }
16146 }
16147
16148 16149 16150
16151 if (dy && run.height)
16152 {
16153 update_begin (f);
16154
16155 if (FRAME_WINDOW_P (f))
16156 {
16157 FRAME_RIF (f)->update_window_begin_hook (w);
16158 FRAME_RIF (f)->clear_window_mouse_face (w);
16159 FRAME_RIF (f)->scroll_run_hook (w, &run);
16160 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
16161 }
16162 else
16163 {
16164 16165
16166 int first_unchanged_at_end_vpos
16167 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
16168 int from = WINDOW_TOP_EDGE_LINE (w) + first_unchanged_at_end_vpos;
16169 int end = (WINDOW_TOP_EDGE_LINE (w)
16170 + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
16171 + window_internal_height (w));
16172
16173
16174 if (dvpos > 0)
16175 {
16176 16177
16178 set_terminal_window (f, end);
16179
16180 16181
16182 if (!FRAME_SCROLL_REGION_OK (f))
16183 ins_del_lines (f, end - dvpos, -dvpos);
16184
16185 16186
16187 ins_del_lines (f, from, dvpos);
16188 }
16189 else if (dvpos < 0)
16190 {
16191 16192
16193 set_terminal_window (f, end);
16194
16195 16196 16197 16198
16199 ins_del_lines (f, from + dvpos, dvpos);
16200
16201 16202
16203 if (!FRAME_SCROLL_REGION_OK (f))
16204 ins_del_lines (f, end + dvpos, -dvpos);
16205 }
16206
16207 set_terminal_window (f, 0);
16208 }
16209
16210 update_end (f);
16211 }
16212
16213 16214 16215
16216 bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
16217 bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
16218 if (dvpos < 0)
16219 {
16220 rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
16221 bottom_vpos, dvpos);
16222 enable_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
16223 bottom_vpos, 0);
16224 }
16225 else if (dvpos > 0)
16226 {
16227 rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
16228 bottom_vpos, dvpos);
16229 enable_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
16230 first_unchanged_at_end_vpos + dvpos, 0);
16231 }
16232
16233 16234
16235 if (!FRAME_WINDOW_P (f))
16236 sync_frame_with_window_matrix_rows (w);
16237
16238
16239 if (delta || delta_bytes)
16240 increment_matrix_positions (current_matrix,
16241 first_unchanged_at_end_vpos + dvpos,
16242 bottom_vpos, delta, delta_bytes);
16243
16244
16245 if (dy)
16246 shift_glyph_matrix (w, current_matrix,
16247 first_unchanged_at_end_vpos + dvpos,
16248 bottom_vpos, dy);
16249
16250 if (first_unchanged_at_end_row)
16251 {
16252 first_unchanged_at_end_row += dvpos;
16253 if (first_unchanged_at_end_row->y >= it.last_visible_y
16254 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
16255 first_unchanged_at_end_row = NULL;
16256 }
16257
16258 16259
16260 last_text_row_at_end = NULL;
16261 if (dy < 0)
16262 {
16263 16264
16265 16266 16267
16268 int last_vpos = XFASTINT (w->window_end_vpos) + dvpos;
16269 struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
16270
16271
16272 xassert (last_row->displays_text_p);
16273
16274 16275 16276
16277 if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
16278 {
16279 init_to_row_start (&it, w, last_row);
16280 it.vpos = last_vpos;
16281 it.current_y = last_row->y;
16282 }
16283 else
16284 {
16285 init_to_row_end (&it, w, last_row);
16286 it.vpos = 1 + last_vpos;
16287 it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
16288 ++last_row;
16289 }
16290
16291 16292
16293 it.continuation_lines_width = last_row->continuation_lines_width;
16294 it.hpos = it.current_x = 0;
16295
16296
16297 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
16298 while (it.current_y < it.last_visible_y
16299 && !fonts_changed_p)
16300 {
16301 16302 16303 16304
16305 MATRIX_ROW (w->current_matrix, it.vpos)->enabled_p = 0;
16306 if (display_line (&it))
16307 last_text_row_at_end = it.glyph_row - 1;
16308 }
16309 }
16310
16311
16312 if (first_unchanged_at_end_row
16313 && !last_text_row_at_end)
16314 {
16315 16316 16317 16318
16319 xassert (first_unchanged_at_end_row->displays_text_p);
16320 row = find_last_row_displaying_text (w->current_matrix, &it,
16321 first_unchanged_at_end_row);
16322 xassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
16323
16324 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
16325 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
16326 w->window_end_vpos
16327 = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
16328 xassert (w->window_end_bytepos >= 0);
16329 IF_DEBUG (debug_method_add (w, "A"));
16330 }
16331 else if (last_text_row_at_end)
16332 {
16333 w->window_end_pos
16334 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
16335 w->window_end_bytepos
16336 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
16337 w->window_end_vpos
16338 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
16339 xassert (w->window_end_bytepos >= 0);
16340 IF_DEBUG (debug_method_add (w, "B"));
16341 }
16342 else if (last_text_row)
16343 {
16344 16345 16346
16347 w->window_end_pos
16348 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
16349 w->window_end_bytepos
16350 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
16351 w->window_end_vpos
16352 = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
16353 xassert (w->window_end_bytepos >= 0);
16354 }
16355 else if (first_unchanged_at_end_row == NULL
16356 && last_text_row == NULL
16357 && last_text_row_at_end == NULL)
16358 {
16359 16360
16361 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
16362 int vpos = XFASTINT (w->window_end_vpos);
16363 struct glyph_row *current_row = current_matrix->rows + vpos;
16364 struct glyph_row *desired_row = desired_matrix->rows + vpos;
16365
16366 for (row = NULL;
16367 row == NULL && vpos >= first_vpos;
16368 --vpos, --current_row, --desired_row)
16369 {
16370 if (desired_row->enabled_p)
16371 {
16372 if (desired_row->displays_text_p)
16373 row = desired_row;
16374 }
16375 else if (current_row->displays_text_p)
16376 row = current_row;
16377 }
16378
16379 xassert (row != NULL);
16380 w->window_end_vpos = make_number (vpos + 1);
16381 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
16382 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
16383 xassert (w->window_end_bytepos >= 0);
16384 IF_DEBUG (debug_method_add (w, "C"));
16385 }
16386 else
16387 abort ();
16388
16389 IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
16390 debug_end_vpos = XFASTINT (w->window_end_vpos));
16391
16392
16393 w->window_end_valid = Qnil;
16394 w->desired_matrix->no_scrolling_p = 1;
16395 return 3;
16396
16397 #undef GIVE_UP
16398 }
16399
16400
16401
16402 16403 16404
16405
16406 #if GLYPH_DEBUG
16407
16408 void dump_glyph_row P_ ((struct glyph_row *, int, int));
16409 void dump_glyph_matrix P_ ((struct glyph_matrix *, int));
16410 void dump_glyph P_ ((struct glyph_row *, struct glyph *, int));
16411
16412
16413 16414 16415 16416 16417
16418
16419 void
16420 dump_glyph_matrix (matrix, glyphs)
16421 struct glyph_matrix *matrix;
16422 int glyphs;
16423 {
16424 int i;
16425 for (i = 0; i < matrix->nrows; ++i)
16426 dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
16427 }
16428
16429
16430 16431
16432
16433 void
16434 dump_glyph (row, glyph, area)
16435 struct glyph_row *row;
16436 struct glyph *glyph;
16437 int area;
16438 {
16439 if (glyph->type == CHAR_GLYPH)
16440 {
16441 fprintf (stderr,
16442 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16443 glyph - row->glyphs[TEXT_AREA],
16444 'C',
16445 glyph->charpos,
16446 (BUFFERP (glyph->object)
16447 ? 'B'
16448 : (STRINGP (glyph->object)
16449 ? 'S'
16450 : '-')),
16451 glyph->pixel_width,
16452 glyph->u.ch,
16453 (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
16454 ? glyph->u.ch
16455 : '.'),
16456 glyph->face_id,
16457 glyph->left_box_line_p,
16458 glyph->right_box_line_p);
16459 }
16460 else if (glyph->type == STRETCH_GLYPH)
16461 {
16462 fprintf (stderr,
16463 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16464 glyph - row->glyphs[TEXT_AREA],
16465 'S',
16466 glyph->charpos,
16467 (BUFFERP (glyph->object)
16468 ? 'B'
16469 : (STRINGP (glyph->object)
16470 ? 'S'
16471 : '-')),
16472 glyph->pixel_width,
16473 0,
16474 '.',
16475 glyph->face_id,
16476 glyph->left_box_line_p,
16477 glyph->right_box_line_p);
16478 }
16479 else if (glyph->type == IMAGE_GLYPH)
16480 {
16481 fprintf (stderr,
16482 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16483 glyph - row->glyphs[TEXT_AREA],
16484 'I',
16485 glyph->charpos,
16486 (BUFFERP (glyph->object)
16487 ? 'B'
16488 : (STRINGP (glyph->object)
16489 ? 'S'
16490 : '-')),
16491 glyph->pixel_width,
16492 glyph->u.img_id,
16493 '.',
16494 glyph->face_id,
16495 glyph->left_box_line_p,
16496 glyph->right_box_line_p);
16497 }
16498 else if (glyph->type == COMPOSITE_GLYPH)
16499 {
16500 fprintf (stderr,
16501 " %5d %4c %6d %c %3d 0x%05x",
16502 glyph - row->glyphs[TEXT_AREA],
16503 '+',
16504 glyph->charpos,
16505 (BUFFERP (glyph->object)
16506 ? 'B'
16507 : (STRINGP (glyph->object)
16508 ? 'S'
16509 : '-')),
16510 glyph->pixel_width,
16511 glyph->u.cmp.id);
16512 if (glyph->u.cmp.automatic)
16513 fprintf (stderr,
16514 "[%d-%d]",
16515 glyph->u.cmp.from, glyph->u.cmp.to);
16516 fprintf (stderr, " . %4d %1.1d%1.1d\n",
16517 glyph->face_id,
16518 glyph->left_box_line_p,
16519 glyph->right_box_line_p);
16520 }
16521 }
16522
16523
16524 16525 16526 16527
16528
16529 void
16530 dump_glyph_row (row, vpos, glyphs)
16531 struct glyph_row *row;
16532 int vpos, glyphs;
16533 {
16534 if (glyphs != 1)
16535 {
16536 fprintf (stderr, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
16537 fprintf (stderr, "======================================================================\n");
16538
16539 fprintf (stderr, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
16540 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
16541 vpos,
16542 MATRIX_ROW_START_CHARPOS (row),
16543 MATRIX_ROW_END_CHARPOS (row),
16544 row->used[TEXT_AREA],
16545 row->contains_overlapping_glyphs_p,
16546 row->enabled_p,
16547 row->truncated_on_left_p,
16548 row->truncated_on_right_p,
16549 row->continued_p,
16550 MATRIX_ROW_CONTINUATION_LINE_P (row),
16551 row->displays_text_p,
16552 row->ends_at_zv_p,
16553 row->fill_line_p,
16554 row->ends_in_middle_of_char_p,
16555 row->starts_in_middle_of_char_p,
16556 row->mouse_face_p,
16557 row->x,
16558 row->y,
16559 row->pixel_width,
16560 row->height,
16561 row->visible_height,
16562 row->ascent,
16563 row->phys_ascent);
16564 fprintf (stderr, "%9d %5d\t%5d\n", row->start.overlay_string_index,
16565 row->end.overlay_string_index,
16566 row->continuation_lines_width);
16567 fprintf (stderr, "%9d %5d\n",
16568 CHARPOS (row->start.string_pos),
16569 CHARPOS (row->end.string_pos));
16570 fprintf (stderr, "%9d %5d\n", row->start.dpvec_index,
16571 row->end.dpvec_index);
16572 }
16573
16574 if (glyphs > 1)
16575 {
16576 int area;
16577
16578 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16579 {
16580 struct glyph *glyph = row->glyphs[area];
16581 struct glyph *glyph_end = glyph + row->used[area];
16582
16583
16584 if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
16585 ++glyph_end;
16586
16587 if (glyph < glyph_end)
16588 fprintf (stderr, " Glyph Type Pos O W Code C Face LR\n");
16589
16590 for (; glyph < glyph_end; ++glyph)
16591 dump_glyph (row, glyph, area);
16592 }
16593 }
16594 else if (glyphs == 1)
16595 {
16596 int area;
16597
16598 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16599 {
16600 char *s = (char *) alloca (row->used[area] + 1);
16601 int i;
16602
16603 for (i = 0; i < row->used[area]; ++i)
16604 {
16605 struct glyph *glyph = row->glyphs[area] + i;
16606 if (glyph->type == CHAR_GLYPH
16607 && glyph->u.ch < 0x80
16608 && glyph->u.ch >= ' ')
16609 s[i] = glyph->u.ch;
16610 else
16611 s[i] = '.';
16612 }
16613
16614 s[i] = '\0';
16615 fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
16616 }
16617 }
16618 }
16619
16620
16621 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
16622 Sdump_glyph_matrix, 0, 1, "p",
16623 doc: 16624 16625 16626 )
16627 (glyphs)
16628 Lisp_Object glyphs;
16629 {
16630 struct window *w = XWINDOW (selected_window);
16631 struct buffer *buffer = XBUFFER (w->buffer);
16632
16633 fprintf (stderr, "PT = %d, BEGV = %d. ZV = %d\n",
16634 BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
16635 fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
16636 w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
16637 fprintf (stderr, "=============================================\n");
16638 dump_glyph_matrix (w->current_matrix,
16639 NILP (glyphs) ? 0 : XINT (glyphs));
16640 return Qnil;
16641 }
16642
16643
16644 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
16645 Sdump_frame_glyph_matrix, 0, 0, "", doc: )
16646 ()
16647 {
16648 struct frame *f = XFRAME (selected_frame);
16649 dump_glyph_matrix (f->current_matrix, 1);
16650 return Qnil;
16651 }
16652
16653
16654 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "",
16655 doc: 16656 16657 16658 )
16659 (row, glyphs)
16660 Lisp_Object row, glyphs;
16661 {
16662 struct glyph_matrix *matrix;
16663 int vpos;
16664
16665 CHECK_NUMBER (row);
16666 matrix = XWINDOW (selected_window)->current_matrix;
16667 vpos = XINT (row);
16668 if (vpos >= 0 && vpos < matrix->nrows)
16669 dump_glyph_row (MATRIX_ROW (matrix, vpos),
16670 vpos,
16671 INTEGERP (glyphs) ? XINT (glyphs) : 2);
16672 return Qnil;
16673 }
16674
16675
16676 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "",
16677 doc: 16678 16679 16680 )
16681 (row, glyphs)
16682 Lisp_Object row, glyphs;
16683 {
16684 struct frame *sf = SELECTED_FRAME ();
16685 struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
16686 int vpos;
16687
16688 CHECK_NUMBER (row);
16689 vpos = XINT (row);
16690 if (vpos >= 0 && vpos < m->nrows)
16691 dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
16692 INTEGERP (glyphs) ? XINT (glyphs) : 2);
16693 return Qnil;
16694 }
16695
16696
16697 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
16698 doc: 16699 )
16700 (arg)
16701 Lisp_Object arg;
16702 {
16703 if (NILP (arg))
16704 trace_redisplay_p = !trace_redisplay_p;
16705 else
16706 {
16707 arg = Fprefix_numeric_value (arg);
16708 trace_redisplay_p = XINT (arg) > 0;
16709 }
16710
16711 return Qnil;
16712 }
16713
16714
16715 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
16716 doc: 16717 )
16718 (nargs, args)
16719 int nargs;
16720 Lisp_Object *args;
16721 {
16722 Lisp_Object s = Fformat (nargs, args);
16723 fprintf (stderr, "%s", SDATA (s));
16724 return Qnil;
16725 }
16726
16727 #endif
16728
16729
16730
16731 16732 16733
16734
16735 16736
16737
16738 static struct glyph_row *
16739 get_overlay_arrow_glyph_row (w, overlay_arrow_string)
16740 struct window *w;
16741 Lisp_Object overlay_arrow_string;
16742 {
16743 struct frame *f = XFRAME (WINDOW_FRAME (w));
16744 struct buffer *buffer = XBUFFER (w->buffer);
16745 struct buffer *old = current_buffer;
16746 const unsigned char *arrow_string = SDATA (overlay_arrow_string);
16747 int arrow_len = SCHARS (overlay_arrow_string);
16748 const unsigned char *arrow_end = arrow_string + arrow_len;
16749 const unsigned char *p;
16750 struct it it;
16751 int multibyte_p;
16752 int n_glyphs_before;
16753
16754 set_buffer_temp (buffer);
16755 init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
16756 it.glyph_row->used[TEXT_AREA] = 0;
16757 SET_TEXT_POS (it.position, 0, 0);
16758
16759 multibyte_p = !NILP (buffer->enable_multibyte_characters);
16760 p = arrow_string;
16761 while (p < arrow_end)
16762 {
16763 Lisp_Object face, ilisp;
16764
16765
16766 if (multibyte_p)
16767 it.c = string_char_and_length (p, &it.len);
16768 else
16769 it.c = *p, it.len = 1;
16770 p += it.len;
16771
16772
16773 ilisp = make_number (p - arrow_string);
16774 face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
16775 it.face_id = compute_char_face (f, it.c, face);
16776
16777
16778 n_glyphs_before = it.glyph_row->used[TEXT_AREA];
16779 SET_TEXT_POS (it.position, -1, -1);
16780 PRODUCE_GLYPHS (&it);
16781
16782 16783
16784 if (it.current_x > it.last_visible_x)
16785 {
16786 it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
16787 break;
16788 }
16789 }
16790
16791 set_buffer_temp (old);
16792 return it.glyph_row;
16793 }
16794
16795
16796 16797 16798 16799 16800
16801
16802 static void
16803 insert_left_trunc_glyphs (it)
16804 struct it *it;
16805 {
16806 struct it truncate_it;
16807 struct glyph *from, *end, *to, *toend;
16808
16809 xassert (!FRAME_WINDOW_P (it->f));
16810
16811
16812 truncate_it = *it;
16813 truncate_it.current_x = 0;
16814 truncate_it.face_id = DEFAULT_FACE_ID;
16815 truncate_it.glyph_row = &scratch_glyph_row;
16816 truncate_it.glyph_row->used[TEXT_AREA] = 0;
16817 CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
16818 truncate_it.object = make_number (0);
16819 produce_special_glyphs (&truncate_it, IT_TRUNCATION);
16820
16821
16822 if (!it->glyph_row->reversed_p)
16823 {
16824 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
16825 end = from + truncate_it.glyph_row->used[TEXT_AREA];
16826 to = it->glyph_row->glyphs[TEXT_AREA];
16827 toend = to + it->glyph_row->used[TEXT_AREA];
16828
16829 while (from < end)
16830 *to++ = *from++;
16831
16832
16833 while (to < toend && CHAR_GLYPH_PADDING_P (*to))
16834 {
16835 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
16836 while (from < end)
16837 *to++ = *from++;
16838 }
16839
16840 if (to > toend)
16841 it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
16842 }
16843 else
16844 {
16845 16846
16847 end = truncate_it.glyph_row->glyphs[TEXT_AREA];
16848 from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
16849 toend = it->glyph_row->glyphs[TEXT_AREA];
16850 to = toend + it->glyph_row->used[TEXT_AREA] - 1;
16851
16852 while (from >= end && to >= toend)
16853 *to-- = *from--;
16854 while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
16855 {
16856 from =
16857 truncate_it.glyph_row->glyphs[TEXT_AREA]
16858 + truncate_it.glyph_row->used[TEXT_AREA] - 1;
16859 while (from >= end && to >= toend)
16860 *to-- = *from--;
16861 }
16862 if (from >= end)
16863 {
16864 16865
16866 int move_by = from - end + 1;
16867 struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
16868 struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
16869
16870 for ( ; g >= g0; g--)
16871 g[move_by] = *g;
16872 while (from >= end)
16873 *to-- = *from--;
16874 it->glyph_row->used[TEXT_AREA] += move_by;
16875 }
16876 }
16877 }
16878
16879
16880 16881 16882 16883 16884 16885 16886 16887 16888 16889 16890 16891 16892 16893 16894 16895
16896
16897 static void
16898 compute_line_metrics (it)
16899 struct it *it;
16900 {
16901 struct glyph_row *row = it->glyph_row;
16902 int area, i;
16903
16904 if (FRAME_WINDOW_P (it->f))
16905 {
16906 int i, min_y, max_y;
16907
16908 16909 16910
16911 if (row->height == 0)
16912 {
16913 if (it->max_ascent + it->max_descent == 0)
16914 it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
16915 row->ascent = it->max_ascent;
16916 row->height = it->max_ascent + it->max_descent;
16917 row->phys_ascent = it->max_phys_ascent;
16918 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
16919 row->extra_line_spacing = it->max_extra_line_spacing;
16920 }
16921
16922
16923 row->pixel_width = row->x;
16924 for (i = 0; i < row->used[TEXT_AREA]; ++i)
16925 row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
16926
16927 xassert (row->pixel_width >= 0);
16928 xassert (row->ascent >= 0 && row->height > 0);
16929
16930 row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
16931 || MATRIX_ROW_OVERLAPS_PRED_P (row));
16932
16933 16934 16935
16936 if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
16937 && row->phys_ascent > row->ascent)
16938 {
16939 row->height += row->phys_ascent - row->ascent;
16940 row->ascent = row->phys_ascent;
16941 }
16942
16943
16944 row->visible_height = row->height;
16945
16946 min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
16947 max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
16948
16949 if (row->y < min_y)
16950 row->visible_height -= min_y - row->y;
16951 if (row->y + row->height > max_y)
16952 row->visible_height -= row->y + row->height - max_y;
16953 }
16954 else
16955 {
16956 row->pixel_width = row->used[TEXT_AREA];
16957 if (row->continued_p)
16958 row->pixel_width -= it->continuation_pixel_width;
16959 else if (row->truncated_on_right_p)
16960 row->pixel_width -= it->truncation_pixel_width;
16961 row->ascent = row->phys_ascent = 0;
16962 row->height = row->phys_height = row->visible_height = 1;
16963 row->extra_line_spacing = 0;
16964 }
16965
16966
16967 row->hash = 0;
16968 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16969 for (i = 0; i < row->used[area]; ++i)
16970 row->hash = ((((row->hash << 4) + (row->hash >> 24)) & 0x0fffffff)
16971 + row->glyphs[area][i].u.val
16972 + row->glyphs[area][i].face_id
16973 + row->glyphs[area][i].padding_p
16974 + (row->glyphs[area][i].type << 2));
16975
16976 it->max_ascent = it->max_descent = 0;
16977 it->max_phys_ascent = it->max_phys_descent = 0;
16978 }
16979
16980
16981 16982 16983 16984 16985 16986 16987 16988 16989 16990 16991
16992
16993 static int
16994 append_space_for_newline (it, default_face_p)
16995 struct it *it;
16996 int default_face_p;
16997 {
16998 if (FRAME_WINDOW_P (it->f))
16999 {
17000 int n = it->glyph_row->used[TEXT_AREA];
17001
17002 if (it->glyph_row->glyphs[TEXT_AREA] + n
17003 < it->glyph_row->glyphs[1 + TEXT_AREA])
17004 {
17005 17006 17007 17008
17009 enum display_element_type saved_what = it->what;
17010 int saved_c = it->c, saved_len = it->len;
17011 int saved_x = it->current_x;
17012 int saved_face_id = it->face_id;
17013 struct text_pos saved_pos;
17014 Lisp_Object saved_object;
17015 struct face *face;
17016
17017 saved_object = it->object;
17018 saved_pos = it->position;
17019
17020 it->what = IT_CHARACTER;
17021 bzero (&it->position, sizeof it->position);
17022 it->object = make_number (0);
17023 it->c = ' ';
17024 it->len = 1;
17025
17026 if (default_face_p)
17027 it->face_id = DEFAULT_FACE_ID;
17028 else if (it->face_before_selective_p)
17029 it->face_id = it->saved_face_id;
17030 face = FACE_FROM_ID (it->f, it->face_id);
17031 it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
17032
17033 PRODUCE_GLYPHS (it);
17034
17035 it->override_ascent = -1;
17036 it->constrain_row_ascent_descent_p = 0;
17037 it->current_x = saved_x;
17038 it->object = saved_object;
17039 it->position = saved_pos;
17040 it->what = saved_what;
17041 it->face_id = saved_face_id;
17042 it->len = saved_len;
17043 it->c = saved_c;
17044 return 1;
17045 }
17046 }
17047
17048 return 0;
17049 }
17050
17051
17052 17053 17054 17055 17056 17057
17058
17059 static void
17060 extend_face_to_end_of_line (it)
17061 struct it *it;
17062 {
17063 struct face *face;
17064 struct frame *f = it->f;
17065
17066 17067 17068 17069 17070
17071 if (it->current_x >= it->last_visible_x
17072 + (!FRAME_WINDOW_P (f)
17073 && it->glyph_row->reversed_p
17074 && !it->glyph_row->continued_p))
17075 return;
17076
17077 17078 17079
17080 if (it->face_before_selective_p)
17081 face = FACE_FROM_ID (f, it->saved_face_id);
17082 else
17083 face = FACE_FROM_ID (f, it->face_id);
17084
17085 if (FRAME_WINDOW_P (f)
17086 && it->glyph_row->displays_text_p
17087 && face->box == FACE_NO_BOX
17088 && face->background == FRAME_BACKGROUND_PIXEL (f)
17089 && !face->stipple
17090 && !it->glyph_row->reversed_p)
17091 return;
17092
17093 17094
17095 it->glyph_row->fill_line_p = 1;
17096
17097 17098 17099 17100 17101
17102 if (!ASCII_CHAR_P (it->c))
17103 {
17104 it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
17105 }
17106
17107 if (FRAME_WINDOW_P (f))
17108 {
17109 17110
17111 if (it->glyph_row->used[TEXT_AREA] == 0)
17112 {
17113 it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
17114 it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
17115 it->glyph_row->used[TEXT_AREA] = 1;
17116 }
17117 #ifdef HAVE_WINDOW_SYSTEM
17118 if (it->glyph_row->reversed_p)
17119 {
17120 17121 17122 17123 17124
17125 struct font *font = face->font ? face->font : FRAME_FONT (f);
17126 struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
17127 struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
17128 struct glyph *g;
17129 int row_width, stretch_ascent, stretch_width;
17130 struct text_pos saved_pos;
17131 int saved_face_id, saved_avoid_cursor;
17132
17133 for (row_width = 0, g = row_start; g < row_end; g++)
17134 row_width += g->pixel_width;
17135 stretch_width = window_box_width (it->w, TEXT_AREA) - row_width;
17136 if (stretch_width > 0)
17137 {
17138 stretch_ascent =
17139 (((it->ascent + it->descent)
17140 * FONT_BASE (font)) / FONT_HEIGHT (font));
17141 saved_pos = it->position;
17142 bzero (&it->position, sizeof it->position);
17143 saved_avoid_cursor = it->avoid_cursor_p;
17144 it->avoid_cursor_p = 1;
17145 saved_face_id = it->face_id;
17146 17147 17148
17149 if (it->glyph_row->ends_at_zv_p)
17150 it->face_id = DEFAULT_FACE_ID;
17151 else
17152 it->face_id = face->id;
17153 append_stretch_glyph (it, make_number (0), stretch_width,
17154 it->ascent + it->descent, stretch_ascent);
17155 it->position = saved_pos;
17156 it->avoid_cursor_p = saved_avoid_cursor;
17157 it->face_id = saved_face_id;
17158 }
17159 }
17160 #endif
17161 }
17162 else
17163 {
17164
17165 int saved_x = it->current_x;
17166 struct text_pos saved_pos;
17167 Lisp_Object saved_object;
17168 enum display_element_type saved_what = it->what;
17169 int saved_face_id = it->face_id;
17170
17171 saved_object = it->object;
17172 saved_pos = it->position;
17173
17174 it->what = IT_CHARACTER;
17175 bzero (&it->position, sizeof it->position);
17176 it->object = make_number (0);
17177 it->c = ' ';
17178 it->len = 1;
17179 17180 17181
17182 if (it->glyph_row->ends_at_zv_p)
17183 it->face_id = DEFAULT_FACE_ID;
17184 else
17185 it->face_id = face->id;
17186
17187 PRODUCE_GLYPHS (it);
17188
17189 while (it->current_x <= it->last_visible_x)
17190 PRODUCE_GLYPHS (it);
17191
17192 17193
17194 it->current_x = saved_x;
17195 it->object = saved_object;
17196 it->position = saved_pos;
17197 it->what = saved_what;
17198 it->face_id = saved_face_id;
17199 }
17200 }
17201
17202
17203 17204
17205
17206 static int
17207 trailing_whitespace_p (charpos)
17208 int charpos;
17209 {
17210 int bytepos = CHAR_TO_BYTE (charpos);
17211 int c = 0;
17212
17213 while (bytepos < ZV_BYTE
17214 && (c = FETCH_CHAR (bytepos),
17215 c == ' ' || c == '\t'))
17216 ++bytepos;
17217
17218 if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
17219 {
17220 if (bytepos != PT_BYTE)
17221 return 1;
17222 }
17223 return 0;
17224 }
17225
17226
17227
17228
17229 void
17230 highlight_trailing_whitespace (f, row)
17231 struct frame *f;
17232 struct glyph_row *row;
17233 {
17234 int used = row->used[TEXT_AREA];
17235
17236 if (used)
17237 {
17238 struct glyph *start = row->glyphs[TEXT_AREA];
17239 struct glyph *glyph = start + used - 1;
17240
17241 if (row->reversed_p)
17242 {
17243 17244
17245 glyph = start;
17246 start = row->glyphs[TEXT_AREA] + used - 1;
17247 }
17248
17249 17250 17251 17252
17253 if (!row->reversed_p)
17254 {
17255 while (glyph >= start
17256 && glyph->type == CHAR_GLYPH
17257 && INTEGERP (glyph->object))
17258 --glyph;
17259 }
17260 else
17261 {
17262 while (glyph <= start
17263 && glyph->type == CHAR_GLYPH
17264 && INTEGERP (glyph->object))
17265 ++glyph;
17266 }
17267
17268 17269 17270
17271 if ((row->reversed_p ? glyph <= start : glyph >= start)
17272 && BUFFERP (glyph->object)
17273 && (glyph->type == STRETCH_GLYPH
17274 || (glyph->type == CHAR_GLYPH
17275 && glyph->u.ch == ' '))
17276 && trailing_whitespace_p (glyph->charpos))
17277 {
17278 int face_id = lookup_named_face (f, Qtrailing_whitespace, 0);
17279 if (face_id < 0)
17280 return;
17281
17282 if (!row->reversed_p)
17283 {
17284 while (glyph >= start
17285 && BUFFERP (glyph->object)
17286 && (glyph->type == STRETCH_GLYPH
17287 || (glyph->type == CHAR_GLYPH
17288 && glyph->u.ch == ' ')))
17289 (glyph--)->face_id = face_id;
17290 }
17291 else
17292 {
17293 while (glyph <= start
17294 && BUFFERP (glyph->object)
17295 && (glyph->type == STRETCH_GLYPH
17296 || (glyph->type == CHAR_GLYPH
17297 && glyph->u.ch == ' ')))
17298 (glyph++)->face_id = face_id;
17299 }
17300 }
17301 }
17302 }
17303
17304
17305 17306
17307
17308 static int
17309 cursor_row_p (w, row)
17310 struct window *w;
17311 struct glyph_row *row;
17312 {
17313 int cursor_row_p = 1;
17314
17315 if (PT == CHARPOS (row->end.pos))
17316 {
17317 17318 17319 17320 17321 17322
17323 if (CHARPOS (row->end.string_pos) >= 0)
17324 {
17325 if (row->continued_p)
17326 cursor_row_p = 1;
17327 else
17328 {
17329
17330 struct glyph *beg = row->glyphs[TEXT_AREA];
17331 struct glyph *end = beg + row->used[TEXT_AREA] - 1;
17332 struct glyph *glyph;
17333
17334 cursor_row_p = 0;
17335 for (glyph = end; glyph >= beg; --glyph)
17336 if (STRINGP (glyph->object))
17337 {
17338 Lisp_Object prop
17339 = Fget_char_property (make_number (PT),
17340 Qdisplay, Qnil);
17341 cursor_row_p =
17342 (!NILP (prop)
17343 && display_prop_string_p (prop, glyph->object));
17344 break;
17345 }
17346 }
17347 }
17348 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
17349 {
17350 17351 17352 17353
17354 if (!row->ends_in_ellipsis_p)
17355 cursor_row_p = row->continued_p;
17356 else
17357 17358 17359 17360
17361 cursor_row_p = 0;
17362 }
17363 17364
17365 else if (row->ends_at_zv_p)
17366 cursor_row_p = 1;
17367 else
17368 cursor_row_p = 0;
17369 }
17370
17371 return cursor_row_p;
17372 }
17373
17374
17375
17376 17377 17378
17379
17380 static int
17381 push_display_prop (struct it *it, Lisp_Object prop)
17382 {
17383 push_it (it);
17384
17385 if (STRINGP (prop))
17386 {
17387 if (SCHARS (prop) == 0)
17388 {
17389 pop_it (it);
17390 return 0;
17391 }
17392
17393 it->string = prop;
17394 it->multibyte_p = STRING_MULTIBYTE (it->string);
17395 it->current.overlay_string_index = -1;
17396 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
17397 it->end_charpos = it->string_nchars = SCHARS (it->string);
17398 it->method = GET_FROM_STRING;
17399 it->stop_charpos = 0;
17400 }
17401 else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
17402 {
17403 it->method = GET_FROM_STRETCH;
17404 it->object = prop;
17405 }
17406 #ifdef HAVE_WINDOW_SYSTEM
17407 else if (IMAGEP (prop))
17408 {
17409 it->what = IT_IMAGE;
17410 it->image_id = lookup_image (it->f, prop);
17411 it->method = GET_FROM_IMAGE;
17412 }
17413 #endif
17414 else
17415 {
17416 pop_it (it);
17417 return 0;
17418 }
17419
17420 return 1;
17421 }
17422
17423
17424
17425 static Lisp_Object
17426 get_it_property (it, prop)
17427 struct it *it;
17428 Lisp_Object prop;
17429 {
17430 Lisp_Object position;
17431
17432 if (STRINGP (it->object))
17433 position = make_number (IT_STRING_CHARPOS (*it));
17434 else if (BUFFERP (it->object))
17435 position = make_number (IT_CHARPOS (*it));
17436 else
17437 return Qnil;
17438
17439 return Fget_char_property (position, prop, it->object);
17440 }
17441
17442
17443
17444 static void
17445 handle_line_prefix (struct it *it)
17446 {
17447 Lisp_Object prefix;
17448 if (it->continuation_lines_width > 0)
17449 {
17450 prefix = get_it_property (it, Qwrap_prefix);
17451 if (NILP (prefix))
17452 prefix = Vwrap_prefix;
17453 }
17454 else
17455 {
17456 prefix = get_it_property (it, Qline_prefix);
17457 if (NILP (prefix))
17458 prefix = Vline_prefix;
17459 }
17460 if (! NILP (prefix) && push_display_prop (it, prefix))
17461 {
17462 17463 17464
17465 it->line_wrap = TRUNCATE;
17466 it->avoid_cursor_p = 1;
17467 }
17468 }
17469
17470
17471
17472 17473 17474 17475
17476 static void
17477 unproduce_glyphs (it, n)
17478 struct it *it;
17479 int n;
17480 {
17481 struct glyph *glyph, *end;
17482
17483 xassert (it->glyph_row);
17484 xassert (it->glyph_row->reversed_p);
17485 xassert (it->area == TEXT_AREA);
17486 xassert (n <= it->glyph_row->used[TEXT_AREA]);
17487
17488 if (n > it->glyph_row->used[TEXT_AREA])
17489 n = it->glyph_row->used[TEXT_AREA];
17490 glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
17491 end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
17492 for ( ; glyph < end; glyph++)
17493 glyph[-n] = *glyph;
17494 }
17495
17496 17497
17498 static void
17499 find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos)
17500 struct it *it;
17501 struct glyph_row *row;
17502 EMACS_INT min_pos, min_bpos, max_pos, max_bpos;
17503 {
17504 17505
17506
17507 17508
17509 if (min_pos <= ZV)
17510 SET_TEXT_POS (row->minpos, min_pos, min_bpos);
17511 else
17512 {
17513 17514 17515
17516 row->minpos = row->start.pos;
17517 max_pos = CHARPOS (it->current.pos);
17518 max_bpos = BYTEPOS (it->current.pos);
17519 }
17520
17521 if (!max_pos)
17522 abort ();
17523
17524 17525 17526 17527 17528 17529 17530 17531 17532 17533 17534 17535 17536 17537 17538
17539 if (row->ends_at_zv_p)
17540 row->maxpos = it->current.pos;
17541 else if (row->used[TEXT_AREA])
17542 {
17543 if (row->ends_in_newline_from_string_p)
17544 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17545 else if (CHARPOS (it->eol_pos) > 0)
17546 SET_TEXT_POS (row->maxpos,
17547 CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
17548 else if (row->continued_p)
17549 {
17550 17551 17552 17553 17554 17555
17556 if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
17557 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17558 else
17559 {
17560 INC_BOTH (max_pos, max_bpos);
17561 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17562 }
17563 }
17564 else if (row->truncated_on_right_p)
17565 17566 17567
17568 row->maxpos = it->current.pos;
17569 else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
17570
17571 row->maxpos = row->minpos;
17572 else
17573 abort ();
17574 }
17575 else
17576 row->maxpos = it->current.pos;
17577 }
17578
17579 17580 17581 17582 17583
17584
17585 static int
17586 display_line (it)
17587 struct it *it;
17588 {
17589 struct glyph_row *row = it->glyph_row;
17590 Lisp_Object overlay_arrow_string;
17591 struct it wrap_it;
17592 int may_wrap = 0, wrap_x;
17593 int wrap_row_used = -1, wrap_row_ascent, wrap_row_height;
17594 int wrap_row_phys_ascent, wrap_row_phys_height;
17595 int wrap_row_extra_line_spacing;
17596 EMACS_INT wrap_row_min_pos, wrap_row_min_bpos;
17597 EMACS_INT wrap_row_max_pos, wrap_row_max_bpos;
17598 int cvpos;
17599 EMACS_INT min_pos = ZV + 1, min_bpos, max_pos = 0, max_bpos;
17600
17601
17602 xassert (it->hpos == 0 && it->current_x == 0);
17603
17604 if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
17605 >= it->w->desired_matrix->nrows)
17606 {
17607 it->w->nrows_scale_factor++;
17608 fonts_changed_p = 1;
17609 return 0;
17610 }
17611
17612
17613 it->w->region_showing = it->region_beg_charpos > 0 ? Qt : Qnil;
17614
17615
17616 prepare_desired_row (row);
17617
17618 row->y = it->current_y;
17619 row->start = it->start;
17620 row->continuation_lines_width = it->continuation_lines_width;
17621 row->displays_text_p = 1;
17622 row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
17623 it->starts_in_middle_of_char_p = 0;
17624
17625 17626 17627 17628 17629
17630 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
17631
17632 17633 17634
17635 if (it->current_x < it->first_visible_x)
17636 {
17637 move_it_in_display_line_to (it, ZV, it->first_visible_x,
17638 MOVE_TO_POS | MOVE_TO_X);
17639 }
17640 else
17641 {
17642 17643 17644
17645 handle_line_prefix (it);
17646 }
17647
17648 17649
17650 row->ascent = it->max_ascent;
17651 row->height = it->max_ascent + it->max_descent;
17652 row->phys_ascent = it->max_phys_ascent;
17653 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
17654 row->extra_line_spacing = it->max_extra_line_spacing;
17655
17656
17657 #define RECORD_MAX_MIN_POS(IT) \
17658 do \
17659 { \
17660 if (IT_CHARPOS (*(IT)) < min_pos) \
17661 { \
17662 min_pos = IT_CHARPOS (*(IT)); \
17663 min_bpos = IT_BYTEPOS (*(IT)); \
17664 } \
17665 if (IT_CHARPOS (*(IT)) > max_pos) \
17666 { \
17667 max_pos = IT_CHARPOS (*(IT)); \
17668 max_bpos = IT_BYTEPOS (*(IT)); \
17669 } \
17670 } \
17671 while (0)
17672
17673 17674
17675 while (1)
17676 {
17677 int n_glyphs_before, hpos_before, x_before;
17678 int x, i, nglyphs;
17679 int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
17680
17681 17682
17683 if (!get_next_display_element (it))
17684 {
17685 17686 17687 17688
17689 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
17690 row->exact_window_width_line_p = 1;
17691 else if ((append_space_for_newline (it, 1) && row->used[TEXT_AREA] == 1)
17692 || row->used[TEXT_AREA] == 0)
17693 {
17694 row->glyphs[TEXT_AREA]->charpos = -1;
17695 row->displays_text_p = 0;
17696
17697 if (!NILP (XBUFFER (it->w->buffer)->indicate_empty_lines)
17698 && (!MINI_WINDOW_P (it->w)
17699 || (minibuf_level && EQ (it->window, minibuf_window))))
17700 row->indicate_empty_line_p = 1;
17701 }
17702
17703 it->continuation_lines_width = 0;
17704 row->ends_at_zv_p = 1;
17705 17706 17707 17708
17709 if (row->reversed_p)
17710 extend_face_to_end_of_line (it);
17711 break;
17712 }
17713
17714 17715
17716 n_glyphs_before = row->used[TEXT_AREA];
17717 x = it->current_x;
17718
17719 17720
17721 if (it->line_wrap != TRUNCATE)
17722 {
17723 ascent = it->max_ascent;
17724 descent = it->max_descent;
17725 phys_ascent = it->max_phys_ascent;
17726 phys_descent = it->max_phys_descent;
17727
17728 if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
17729 {
17730 if (IT_DISPLAYING_WHITESPACE (it))
17731 may_wrap = 1;
17732 else if (may_wrap)
17733 {
17734 wrap_it = *it;
17735 wrap_x = x;
17736 wrap_row_used = row->used[TEXT_AREA];
17737 wrap_row_ascent = row->ascent;
17738 wrap_row_height = row->height;
17739 wrap_row_phys_ascent = row->phys_ascent;
17740 wrap_row_phys_height = row->phys_height;
17741 wrap_row_extra_line_spacing = row->extra_line_spacing;
17742 wrap_row_min_pos = min_pos;
17743 wrap_row_min_bpos = min_bpos;
17744 wrap_row_max_pos = max_pos;
17745 wrap_row_max_bpos = max_bpos;
17746 may_wrap = 0;
17747 }
17748 }
17749 }
17750
17751 PRODUCE_GLYPHS (it);
17752
17753 17754
17755 if (it->area != TEXT_AREA)
17756 {
17757 row->ascent = max (row->ascent, it->max_ascent);
17758 row->height = max (row->height, it->max_ascent + it->max_descent);
17759 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
17760 row->phys_height = max (row->phys_height,
17761 it->max_phys_ascent + it->max_phys_descent);
17762 row->extra_line_spacing = max (row->extra_line_spacing,
17763 it->max_extra_line_spacing);
17764 set_iterator_to_next (it, 1);
17765 continue;
17766 }
17767
17768 17769 17770 17771 17772 17773 17774 17775 17776
17777 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
17778 hpos_before = it->hpos;
17779 x_before = x;
17780
17781 if (
17782 nglyphs > 0
17783
17784 && it->current_x < it->last_visible_x)
17785 {
17786 it->hpos += nglyphs;
17787 row->ascent = max (row->ascent, it->max_ascent);
17788 row->height = max (row->height, it->max_ascent + it->max_descent);
17789 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
17790 row->phys_height = max (row->phys_height,
17791 it->max_phys_ascent + it->max_phys_descent);
17792 row->extra_line_spacing = max (row->extra_line_spacing,
17793 it->max_extra_line_spacing);
17794 if (it->current_x - it->pixel_width < it->first_visible_x)
17795 row->x = x - it->first_visible_x;
17796 17797
17798 if (it->bidi_p)
17799 RECORD_MAX_MIN_POS (it);
17800 }
17801 else
17802 {
17803 int new_x;
17804 struct glyph *glyph;
17805
17806 for (i = 0; i < nglyphs; ++i, x = new_x)
17807 {
17808 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
17809 new_x = x + glyph->pixel_width;
17810
17811 if (
17812 it->line_wrap != TRUNCATE
17813 && (
17814 new_x > it->last_visible_x
17815
17816 || (new_x == it->last_visible_x
17817 && FRAME_WINDOW_P (it->f))))
17818 {
17819
17820
17821 if (it->hpos == 0
17822 || (new_x == it->last_visible_x
17823 && FRAME_WINDOW_P (it->f)))
17824 {
17825 17826 17827 17828
17829 row->continued_p = 1;
17830 it->current_x = new_x;
17831 it->continuation_lines_width += new_x;
17832 ++it->hpos;
17833 17834 17835
17836 if (it->bidi_p)
17837 RECORD_MAX_MIN_POS (it);
17838 if (i == nglyphs - 1)
17839 {
17840 17841
17842 if (wrap_row_used > 0
17843 17844 17845 17846 17847
17848 && (!may_wrap
17849 || IT_DISPLAYING_WHITESPACE (it)))
17850 goto back_to_wrap;
17851
17852 set_iterator_to_next (it, 1);
17853 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
17854 {
17855 if (!get_next_display_element (it))
17856 {
17857 row->exact_window_width_line_p = 1;
17858 it->continuation_lines_width = 0;
17859 row->continued_p = 0;
17860 row->ends_at_zv_p = 1;
17861 }
17862 else if (ITERATOR_AT_END_OF_LINE_P (it))
17863 {
17864 row->continued_p = 0;
17865 row->exact_window_width_line_p = 1;
17866 }
17867 }
17868 }
17869 }
17870 else if (CHAR_GLYPH_PADDING_P (*glyph)
17871 && !FRAME_WINDOW_P (it->f))
17872 {
17873 17874 17875
17876 if (row->reversed_p)
17877 unproduce_glyphs (it, row->used[TEXT_AREA]
17878 - n_glyphs_before);
17879 row->used[TEXT_AREA] = n_glyphs_before;
17880
17881 17882
17883 while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
17884 < row->glyphs[1 + TEXT_AREA])
17885 produce_special_glyphs (it, IT_CONTINUATION);
17886
17887 row->continued_p = 1;
17888 it->current_x = x_before;
17889 it->continuation_lines_width += x_before;
17890
17891 17892
17893 it->max_ascent = ascent;
17894 it->max_descent = descent;
17895 it->max_phys_ascent = phys_ascent;
17896 it->max_phys_descent = phys_descent;
17897 }
17898 else if (wrap_row_used > 0)
17899 {
17900 back_to_wrap:
17901 if (row->reversed_p)
17902 unproduce_glyphs (it,
17903 row->used[TEXT_AREA] - wrap_row_used);
17904 *it = wrap_it;
17905 it->continuation_lines_width += wrap_x;
17906 row->used[TEXT_AREA] = wrap_row_used;
17907 row->ascent = wrap_row_ascent;
17908 row->height = wrap_row_height;
17909 row->phys_ascent = wrap_row_phys_ascent;
17910 row->phys_height = wrap_row_phys_height;
17911 row->extra_line_spacing = wrap_row_extra_line_spacing;
17912 min_pos = wrap_row_min_pos;
17913 min_bpos = wrap_row_min_bpos;
17914 max_pos = wrap_row_max_pos;
17915 max_bpos = wrap_row_max_bpos;
17916 row->continued_p = 1;
17917 row->ends_at_zv_p = 0;
17918 row->exact_window_width_line_p = 0;
17919 it->continuation_lines_width += x;
17920
17921 17922
17923 extend_face_to_end_of_line (it);
17924 }
17925 else if (it->c == '\t' && FRAME_WINDOW_P (it->f))
17926 {
17927 17928 17929 17930 17931
17932 it->continuation_lines_width += it->last_visible_x;
17933 row->ends_in_middle_of_char_p = 1;
17934 row->continued_p = 1;
17935 glyph->pixel_width = it->last_visible_x - x;
17936 it->starts_in_middle_of_char_p = 1;
17937 }
17938 else
17939 {
17940 17941 17942
17943 if (row->reversed_p)
17944 unproduce_glyphs (it, row->used[TEXT_AREA]
17945 - (n_glyphs_before + i));
17946 row->used[TEXT_AREA] = n_glyphs_before + i;
17947
17948
17949 if (!FRAME_WINDOW_P (it->f))
17950 produce_special_glyphs (it, IT_CONTINUATION);
17951 row->continued_p = 1;
17952
17953 it->current_x = x_before;
17954 it->continuation_lines_width += x;
17955 extend_face_to_end_of_line (it);
17956
17957 if (nglyphs > 1 && i > 0)
17958 {
17959 row->ends_in_middle_of_char_p = 1;
17960 it->starts_in_middle_of_char_p = 1;
17961 }
17962
17963 17964
17965 it->max_ascent = ascent;
17966 it->max_descent = descent;
17967 it->max_phys_ascent = phys_ascent;
17968 it->max_phys_descent = phys_descent;
17969 }
17970
17971 break;
17972 }
17973 else if (new_x > it->first_visible_x)
17974 {
17975
17976 ++it->hpos;
17977
17978 17979 17980
17981 if (it->bidi_p)
17982 RECORD_MAX_MIN_POS (it);
17983
17984 if (x < it->first_visible_x)
17985 17986
17987 row->x = x - it->first_visible_x;
17988 }
17989 else
17990 {
17991 17992 17993 17994 17995
17996 xassert (it->first_visible_x <= it->last_visible_x);
17997 }
17998 }
17999
18000 row->ascent = max (row->ascent, it->max_ascent);
18001 row->height = max (row->height, it->max_ascent + it->max_descent);
18002 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
18003 row->phys_height = max (row->phys_height,
18004 it->max_phys_ascent + it->max_phys_descent);
18005 row->extra_line_spacing = max (row->extra_line_spacing,
18006 it->max_extra_line_spacing);
18007
18008
18009 if (row->continued_p || row->ends_at_zv_p)
18010 break;
18011 }
18012
18013 at_end_of_line:
18014 18015 18016
18017 if (ITERATOR_AT_END_OF_LINE_P (it))
18018 {
18019 int used_before = row->used[TEXT_AREA];
18020
18021 row->ends_in_newline_from_string_p = STRINGP (it->object);
18022
18023 18024
18025 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
18026 append_space_for_newline (it, 0);
18027
18028
18029 extend_face_to_end_of_line (it);
18030
18031
18032 if (used_before == 0)
18033 row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
18034
18035 18036
18037 it->eol_pos = it->current.pos;
18038
18039
18040 set_iterator_to_next (it, 1);
18041 it->continuation_lines_width = 0;
18042 break;
18043 }
18044
18045 18046
18047 set_iterator_to_next (it, 1);
18048
18049 18050
18051 if (it->line_wrap == TRUNCATE
18052 && (FRAME_WINDOW_P (it->f)
18053 ? (it->current_x >= it->last_visible_x)
18054 : (it->current_x > it->last_visible_x)))
18055 {
18056
18057 if (!FRAME_WINDOW_P (it->f))
18058 {
18059 int i, n;
18060
18061 if (!row->reversed_p)
18062 {
18063 for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
18064 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
18065 break;
18066 }
18067 else
18068 {
18069 for (i = 0; i < row->used[TEXT_AREA]; i++)
18070 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
18071 break;
18072 18073 18074 18075 18076
18077 unproduce_glyphs (it, i + 1);
18078
18079 i = row->used[TEXT_AREA] - (i + 1);
18080 }
18081
18082 for (n = row->used[TEXT_AREA]; i < n; ++i)
18083 {
18084 row->used[TEXT_AREA] = i;
18085 produce_special_glyphs (it, IT_TRUNCATION);
18086 }
18087 }
18088 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
18089 {
18090
18091 if (!get_next_display_element (it))
18092 {
18093 it->continuation_lines_width = 0;
18094 row->ends_at_zv_p = 1;
18095 row->exact_window_width_line_p = 1;
18096 break;
18097 }
18098 if (ITERATOR_AT_END_OF_LINE_P (it))
18099 {
18100 row->exact_window_width_line_p = 1;
18101 goto at_end_of_line;
18102 }
18103 }
18104
18105 row->truncated_on_right_p = 1;
18106 it->continuation_lines_width = 0;
18107 reseat_at_next_visible_line_start (it, 0);
18108 row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
18109 it->hpos = hpos_before;
18110 it->current_x = x_before;
18111 break;
18112 }
18113 }
18114
18115 18116
18117 if (it->first_visible_x
18118 && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
18119 {
18120 if (!FRAME_WINDOW_P (it->f))
18121 insert_left_trunc_glyphs (it);
18122 row->truncated_on_left_p = 1;
18123 }
18124
18125 18126 18127 18128
18129 if ((row->displays_text_p || !overlay_arrow_seen)
18130 && (overlay_arrow_string = overlay_arrow_at_row (it, row),
18131 !NILP (overlay_arrow_string)))
18132 {
18133
18134 if (STRINGP (overlay_arrow_string))
18135 {
18136 struct glyph_row *arrow_row
18137 = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
18138 struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
18139 struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
18140 struct glyph *p = row->glyphs[TEXT_AREA];
18141 struct glyph *p2, *end;
18142
18143
18144 while (glyph < arrow_end)
18145 *p++ = *glyph++;
18146
18147
18148 p2 = p;
18149 end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
18150 while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
18151 ++p2;
18152 if (p2 > p)
18153 {
18154 while (p2 < end)
18155 *p++ = *p2++;
18156 row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
18157 }
18158 }
18159 else
18160 {
18161 xassert (INTEGERP (overlay_arrow_string));
18162 row->overlay_arrow_bitmap = XINT (overlay_arrow_string);
18163 }
18164 overlay_arrow_seen = 1;
18165 }
18166
18167
18168 compute_line_metrics (it);
18169
18170
18171 row->end = it->current;
18172 if (!it->bidi_p)
18173 {
18174 row->minpos = row->start.pos;
18175 row->maxpos = row->end.pos;
18176 }
18177 else
18178 {
18179 18180 18181 18182
18183 find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
18184 }
18185
18186
18187 row->ends_in_ellipsis_p
18188 = (it->method == GET_FROM_DISPLAY_VECTOR
18189 && it->ellipsis_p);
18190
18191
18192 row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
18193 row->left_user_fringe_face_id = it->left_user_fringe_face_id;
18194 row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
18195 row->right_user_fringe_face_id = it->right_user_fringe_face_id;
18196
18197 it->left_user_fringe_bitmap = 0;
18198 it->left_user_fringe_face_id = 0;
18199 it->right_user_fringe_bitmap = 0;
18200 it->right_user_fringe_face_id = 0;
18201
18202
18203 cvpos = it->w->cursor.vpos;
18204 if ((cvpos < 0
18205 18206 18207 18208 18209 18210
18211 18212
18213 || (it->bidi_p
18214 && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
18215 && PT >= MATRIX_ROW_START_CHARPOS (row)
18216 && PT <= MATRIX_ROW_END_CHARPOS (row)
18217 && cursor_row_p (it->w, row))
18218 set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
18219
18220
18221 if (!NILP (Vshow_trailing_whitespace))
18222 highlight_trailing_whitespace (it->f, it->glyph_row);
18223
18224 18225 18226 18227
18228 it->current_x = it->hpos = 0;
18229 it->current_y += row->height;
18230 SET_TEXT_POS (it->eol_pos, 0, 0);
18231 ++it->vpos;
18232 ++it->glyph_row;
18233 18234 18235 18236
18237 if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
18238 it->glyph_row->reversed_p = row->reversed_p;
18239 it->start = row->end;
18240 return row->displays_text_p;
18241
18242 #undef RECORD_MAX_MIN_POS
18243 }
18244
18245 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
18246 Scurrent_bidi_paragraph_direction, 0, 1, 0,
18247 doc: 18248 18249 18250 18251 18252 18253 18254 18255 18256 )
18257 (buffer)
18258 Lisp_Object buffer;
18259 {
18260 struct buffer *buf;
18261 struct buffer *old;
18262
18263 if (NILP (buffer))
18264 buf = current_buffer;
18265 else
18266 {
18267 CHECK_BUFFER (buffer);
18268 buf = XBUFFER (buffer);
18269 old = current_buffer;
18270 }
18271
18272 if (NILP (buf->bidi_display_reordering))
18273 return Qleft_to_right;
18274 else if (!NILP (buf->bidi_paragraph_direction))
18275 return buf->bidi_paragraph_direction;
18276 else
18277 {
18278 18279 18280
18281 struct bidi_it itb;
18282 EMACS_INT pos = BUF_PT (buf);
18283 EMACS_INT bytepos = BUF_PT_BYTE (buf);
18284
18285 if (buf != current_buffer)
18286 set_buffer_temp (buf);
18287
18288 if (pos >= ZV && pos > BEGV)
18289 {
18290 pos--;
18291 bytepos = CHAR_TO_BYTE (pos);
18292 }
18293 while (FETCH_BYTE (bytepos) == '\n')
18294 {
18295 if (bytepos <= BEGV_BYTE)
18296 break;
18297 bytepos--;
18298 pos--;
18299 }
18300 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
18301 bytepos--;
18302 itb.charpos = pos;
18303 itb.bytepos = bytepos;
18304 itb.first_elt = 1;
18305
18306 bidi_paragraph_init (NEUTRAL_DIR, &itb);
18307 if (buf != current_buffer)
18308 set_buffer_temp (old);
18309 switch (itb.paragraph_dir)
18310 {
18311 case L2R:
18312 return Qleft_to_right;
18313 break;
18314 case R2L:
18315 return Qright_to_left;
18316 break;
18317 default:
18318 abort ();
18319 }
18320 }
18321 }
18322
18323
18324
18325 18326 18327
18328
18329 18330 18331 18332 18333 18334 18335 18336 18337
18338
18339 static void
18340 display_menu_bar (w)
18341 struct window *w;
18342 {
18343 struct frame *f = XFRAME (WINDOW_FRAME (w));
18344 struct it it;
18345 Lisp_Object items;
18346 int i;
18347
18348
18349 #ifdef HAVE_NTGUI
18350 if (FRAME_W32_P (f))
18351 return;
18352 #endif
18353 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
18354 if (FRAME_X_P (f))
18355 return;
18356 #endif
18357
18358 #ifdef HAVE_NS
18359 if (FRAME_NS_P (f))
18360 return;
18361 #endif
18362
18363 #ifdef USE_X_TOOLKIT
18364 xassert (!FRAME_WINDOW_P (f));
18365 init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
18366 it.first_visible_x = 0;
18367 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
18368 #else
18369 if (FRAME_WINDOW_P (f))
18370 {
18371 18372
18373 struct window *menu_w;
18374 xassert (WINDOWP (f->menu_bar_window));
18375 menu_w = XWINDOW (f->menu_bar_window);
18376 init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
18377 MENU_FACE_ID);
18378 it.first_visible_x = 0;
18379 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
18380 }
18381 else
18382 {
18383 18384
18385 init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
18386 MENU_FACE_ID);
18387 it.first_visible_x = 0;
18388 it.last_visible_x = FRAME_COLS (f);
18389 }
18390 #endif
18391
18392 if (! mode_line_inverse_video)
18393
18394 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
18395
18396
18397 for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
18398 {
18399 struct glyph_row *row = it.glyph_row + i;
18400 clear_glyph_row (row);
18401 row->enabled_p = 1;
18402 row->full_width_p = 1;
18403 }
18404
18405
18406 items = FRAME_MENU_BAR_ITEMS (it.f);
18407 for (i = 0; i < XVECTOR (items)->size; i += 4)
18408 {
18409 Lisp_Object string;
18410
18411
18412 string = AREF (items, i + 1);
18413 if (NILP (string))
18414 break;
18415
18416
18417 ASET (items, i + 3, make_number (it.hpos));
18418
18419
18420 if (it.current_x < it.last_visible_x)
18421 display_string (NULL, string, Qnil, 0, 0, &it,
18422 SCHARS (string) + 1, 0, 0, -1);
18423 }
18424
18425
18426 if (it.current_x < it.last_visible_x)
18427 display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
18428
18429
18430 compute_line_metrics (&it);
18431 }
18432
18433
18434
18435 18436 18437
18438
18439 18440 18441 18442
18443
18444 static int
18445 redisplay_mode_lines (window, force)
18446 Lisp_Object window;
18447 int force;
18448 {
18449 int nwindows = 0;
18450
18451 while (!NILP (window))
18452 {
18453 struct window *w = XWINDOW (window);
18454
18455 if (WINDOWP (w->hchild))
18456 nwindows += redisplay_mode_lines (w->hchild, force);
18457 else if (WINDOWP (w->vchild))
18458 nwindows += redisplay_mode_lines (w->vchild, force);
18459 else if (force
18460 || FRAME_GARBAGED_P (XFRAME (w->frame))
18461 || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
18462 {
18463 struct text_pos lpoint;
18464 struct buffer *old = current_buffer;
18465
18466
18467 SET_TEXT_POS (lpoint, PT, PT_BYTE);
18468 set_buffer_internal_1 (XBUFFER (w->buffer));
18469
18470 18471
18472 if (!EQ (window, selected_window))
18473 {
18474 struct text_pos pt;
18475
18476 SET_TEXT_POS_FROM_MARKER (pt, w->pointm);
18477 if (CHARPOS (pt) < BEGV)
18478 TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
18479 else if (CHARPOS (pt) > (ZV - 1))
18480 TEMP_SET_PT_BOTH (ZV, ZV_BYTE);
18481 else
18482 TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
18483 }
18484
18485
18486 clear_glyph_matrix (w->desired_matrix);
18487 if (display_mode_lines (w))
18488 {
18489 ++nwindows;
18490 w->must_be_updated_p = 1;
18491 }
18492
18493
18494 set_buffer_internal_1 (old);
18495 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
18496 }
18497
18498 window = w->next;
18499 }
18500
18501 return nwindows;
18502 }
18503
18504
18505 18506
18507
18508 static int
18509 display_mode_lines (w)
18510 struct window *w;
18511 {
18512 Lisp_Object old_selected_window, old_selected_frame;
18513 int n = 0;
18514
18515 old_selected_frame = selected_frame;
18516 selected_frame = w->frame;
18517 old_selected_window = selected_window;
18518 XSETWINDOW (selected_window, w);
18519
18520
18521 line_number_displayed = 0;
18522 w->column_number_displayed = Qnil;
18523
18524 if (WINDOW_WANTS_MODELINE_P (w))
18525 {
18526 struct window *sel_w = XWINDOW (old_selected_window);
18527
18528
18529 display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
18530 current_buffer->mode_line_format);
18531 ++n;
18532 }
18533
18534 if (WINDOW_WANTS_HEADER_LINE_P (w))
18535 {
18536 display_mode_line (w, HEADER_LINE_FACE_ID,
18537 current_buffer->header_line_format);
18538 ++n;
18539 }
18540
18541 selected_frame = old_selected_frame;
18542 selected_window = old_selected_window;
18543 return n;
18544 }
18545
18546
18547 18548 18549 18550 18551
18552
18553 static int
18554 display_mode_line (w, face_id, format)
18555 struct window *w;
18556 enum face_id face_id;
18557 Lisp_Object format;
18558 {
18559 struct it it;
18560 struct face *face;
18561 int count = SPECPDL_INDEX ();
18562
18563 init_iterator (&it, w, -1, -1, NULL, face_id);
18564 18565
18566 it.glyph_row->enabled_p = 0;
18567 prepare_desired_row (it.glyph_row);
18568
18569 it.glyph_row->mode_line_p = 1;
18570
18571 if (! mode_line_inverse_video)
18572
18573 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
18574
18575 record_unwind_protect (unwind_format_mode_line,
18576 format_mode_line_unwind_data (NULL, Qnil, 0));
18577
18578 mode_line_target = MODE_LINE_DISPLAY;
18579
18580 18581 18582
18583 push_kboard (FRAME_KBOARD (it.f));
18584 record_unwind_save_match_data ();
18585 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
18586 pop_kboard ();
18587
18588 unbind_to (count, Qnil);
18589
18590
18591 display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
18592
18593 compute_line_metrics (&it);
18594 it.glyph_row->full_width_p = 1;
18595 it.glyph_row->continued_p = 0;
18596 it.glyph_row->truncated_on_left_p = 0;
18597 it.glyph_row->truncated_on_right_p = 0;
18598
18599
18600 face = FACE_FROM_ID (it.f, face_id);
18601 extend_face_to_end_of_line (&it);
18602 if (face->box != FACE_NO_BOX)
18603 {
18604 struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
18605 + it.glyph_row->used[TEXT_AREA] - 1);
18606 last->right_box_line_p = 1;
18607 }
18608
18609 return it.glyph_row->height;
18610 }
18611
18612 18613
18614
18615 static Lisp_Object
18616 move_elt_to_front (elt, list)
18617 Lisp_Object elt, list;
18618 {
18619 register Lisp_Object tail, prev;
18620 register Lisp_Object tem;
18621
18622 tail = list;
18623 prev = Qnil;
18624 while (CONSP (tail))
18625 {
18626 tem = XCAR (tail);
18627
18628 if (EQ (elt, tem))
18629 {
18630
18631 if (NILP (prev))
18632 list = XCDR (tail);
18633 else
18634 Fsetcdr (prev, XCDR (tail));
18635
18636
18637 Fsetcdr (tail, list);
18638 return tail;
18639 }
18640 else
18641 prev = tail;
18642 tail = XCDR (tail);
18643 QUIT;
18644 }
18645
18646
18647 return list;
18648 }
18649
18650 18651 18652 18653 18654 18655 18656 18657 18658 18659 18660 18661 18662 18663 18664 18665 18666 18667 18668 18669 18670 18671 18672
18673
18674 static int
18675 display_mode_element (it, depth, field_width, precision, elt, props, risky)
18676 struct it *it;
18677 int depth;
18678 int field_width, precision;
18679 Lisp_Object elt, props;
18680 int risky;
18681 {
18682 int n = 0, field, prec;
18683 int literal = 0;
18684
18685 tail_recurse:
18686 if (depth > 100)
18687 elt = build_string ("*too-deep*");
18688
18689 depth++;
18690
18691 switch (SWITCH_ENUM_CAST (XTYPE (elt)))
18692 {
18693 case Lisp_String:
18694 {
18695
18696 unsigned char c;
18697 int offset = 0;
18698
18699 if (SCHARS (elt) > 0
18700 && (!NILP (props) || risky))
18701 {
18702 Lisp_Object oprops, aelt;
18703 oprops = Ftext_properties_at (make_number (0), elt);
18704
18705 18706 18707
18708
18709 if (NILP (Fequal (props, oprops)) || risky)
18710 {
18711 18712
18713 if (! NILP (oprops) && !risky)
18714 {
18715 Lisp_Object tem;
18716
18717 oprops = Fcopy_sequence (oprops);
18718 tem = props;
18719 while (CONSP (tem))
18720 {
18721 oprops = Fplist_put (oprops, XCAR (tem),
18722 XCAR (XCDR (tem)));
18723 tem = XCDR (XCDR (tem));
18724 }
18725 props = oprops;
18726 }
18727
18728 aelt = Fassoc (elt, mode_line_proptrans_alist);
18729 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
18730 {
18731 18732
18733 elt = XCAR (aelt);
18734 mode_line_proptrans_alist
18735 = move_elt_to_front (aelt, mode_line_proptrans_alist);
18736 }
18737 else
18738 {
18739 Lisp_Object tem;
18740
18741 18742
18743 if (! NILP (aelt))
18744 mode_line_proptrans_alist
18745 = Fdelq (aelt, mode_line_proptrans_alist);
18746
18747 elt = Fcopy_sequence (elt);
18748 Fset_text_properties (make_number (0), Flength (elt),
18749 props, elt);
18750
18751 mode_line_proptrans_alist
18752 = Fcons (Fcons (elt, props),
18753 mode_line_proptrans_alist);
18754 18755
18756 tem = Fnthcdr (make_number (50),
18757 mode_line_proptrans_alist);
18758 if (! NILP (tem))
18759 XSETCDR (tem, Qnil);
18760 }
18761 }
18762 }
18763
18764 offset = 0;
18765
18766 if (literal)
18767 {
18768 prec = precision - n;
18769 switch (mode_line_target)
18770 {
18771 case MODE_LINE_NOPROP:
18772 case MODE_LINE_TITLE:
18773 n += store_mode_line_noprop (SDATA (elt), -1, prec);
18774 break;
18775 case MODE_LINE_STRING:
18776 n += store_mode_line_string (NULL, elt, 1, 0, prec, Qnil);
18777 break;
18778 case MODE_LINE_DISPLAY:
18779 n += display_string (NULL, elt, Qnil, 0, 0, it,
18780 0, prec, 0, STRING_MULTIBYTE (elt));
18781 break;
18782 }
18783
18784 break;
18785 }
18786
18787
18788
18789 while ((precision <= 0 || n < precision)
18790 && SREF (elt, offset) != 0
18791 && (mode_line_target != MODE_LINE_DISPLAY
18792 || it->current_x < it->last_visible_x))
18793 {
18794 int last_offset = offset;
18795
18796
18797 while ((c = SREF (elt, offset++)) != '\0' && c != '%')
18798 ;
18799
18800 if (offset - 1 != last_offset)
18801 {
18802 int nchars, nbytes;
18803
18804 18805 18806
18807 offset--;
18808
18809 prec = c_string_width (SDATA (elt) + last_offset,
18810 offset - last_offset, precision - n,
18811 &nchars, &nbytes);
18812
18813 switch (mode_line_target)
18814 {
18815 case MODE_LINE_NOPROP:
18816 case MODE_LINE_TITLE:
18817 n += store_mode_line_noprop (SDATA (elt) + last_offset, 0, prec);
18818 break;
18819 case MODE_LINE_STRING:
18820 {
18821 int bytepos = last_offset;
18822 int charpos = string_byte_to_char (elt, bytepos);
18823 int endpos = (precision <= 0
18824 ? string_byte_to_char (elt, offset)
18825 : charpos + nchars);
18826
18827 n += store_mode_line_string (NULL,
18828 Fsubstring (elt, make_number (charpos),
18829 make_number (endpos)),
18830 0, 0, 0, Qnil);
18831 }
18832 break;
18833 case MODE_LINE_DISPLAY:
18834 {
18835 int bytepos = last_offset;
18836 int charpos = string_byte_to_char (elt, bytepos);
18837
18838 if (precision <= 0)
18839 nchars = string_byte_to_char (elt, offset) - charpos;
18840 n += display_string (NULL, elt, Qnil, 0, charpos,
18841 it, 0, nchars, 0,
18842 STRING_MULTIBYTE (elt));
18843 }
18844 break;
18845 }
18846 }
18847 else
18848 {
18849 int percent_position = offset;
18850
18851 18852
18853 field = 0;
18854 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
18855 field = field * 10 + c - '0';
18856
18857
18858 if (field_width - n > 0 && field > field_width - n)
18859 field = field_width - n;
18860
18861
18862 prec = precision - n;
18863
18864 if (c == 'M')
18865 n += display_mode_element (it, depth, field, prec,
18866 Vglobal_mode_string, props,
18867 risky);
18868 else if (c != 0)
18869 {
18870 int multibyte;
18871 int bytepos, charpos;
18872 unsigned char *spec;
18873 Lisp_Object string;
18874
18875 bytepos = percent_position;
18876 charpos = (STRING_MULTIBYTE (elt)
18877 ? string_byte_to_char (elt, bytepos)
18878 : bytepos);
18879 spec = decode_mode_spec (it->w, c, field, prec, &string);
18880 multibyte = STRINGP (string) && STRING_MULTIBYTE (string);
18881
18882 switch (mode_line_target)
18883 {
18884 case MODE_LINE_NOPROP:
18885 case MODE_LINE_TITLE:
18886 n += store_mode_line_noprop (spec, field, prec);
18887 break;
18888 case MODE_LINE_STRING:
18889 {
18890 int len = strlen (spec);
18891 Lisp_Object tem = make_string (spec, len);
18892 props = Ftext_properties_at (make_number (charpos), elt);
18893
18894 n += store_mode_line_string (NULL, tem, 0, field, prec, props);
18895 }
18896 break;
18897 case MODE_LINE_DISPLAY:
18898 {
18899 int nglyphs_before, nwritten;
18900
18901 nglyphs_before = it->glyph_row->used[TEXT_AREA];
18902 nwritten = display_string (spec, string, elt,
18903 charpos, 0, it,
18904 field, prec, 0,
18905 multibyte);
18906
18907 18908 18909
18910 if (nwritten > 0)
18911 {
18912 struct glyph *glyph
18913 = (it->glyph_row->glyphs[TEXT_AREA]
18914 + nglyphs_before);
18915 int i;
18916
18917 for (i = 0; i < nwritten; ++i)
18918 {
18919 glyph[i].object = elt;
18920 glyph[i].charpos = charpos;
18921 }
18922
18923 n += nwritten;
18924 }
18925 }
18926 break;
18927 }
18928 }
18929 else
18930 break;
18931 }
18932 }
18933 }
18934 break;
18935
18936 case Lisp_Symbol:
18937 18938 18939 18940
18941 {
18942 register Lisp_Object tem;
18943
18944 18945
18946 if (NILP (Fget (elt, Qrisky_local_variable)))
18947 risky = 1;
18948
18949 tem = Fboundp (elt);
18950 if (!NILP (tem))
18951 {
18952 tem = Fsymbol_value (elt);
18953 18954
18955 if (STRINGP (tem))
18956 literal = 1;
18957
18958 if (!EQ (tem, elt))
18959 {
18960
18961 elt = tem;
18962 goto tail_recurse;
18963 }
18964 }
18965 }
18966 break;
18967
18968 case Lisp_Cons:
18969 {
18970 register Lisp_Object car, tem;
18971
18972 18973 18974 18975 18976 18977 18978 18979 18980
18981 car = XCAR (elt);
18982 if (EQ (car, QCeval))
18983 {
18984 18985
18986
18987 if (risky)
18988 break;
18989
18990 if (CONSP (XCDR (elt)))
18991 {
18992 Lisp_Object spec;
18993 spec = safe_eval (XCAR (XCDR (elt)));
18994 n += display_mode_element (it, depth, field_width - n,
18995 precision - n, spec, props,
18996 risky);
18997 }
18998 }
18999 else if (EQ (car, QCpropertize))
19000 {
19001 19002
19003
19004 if (risky)
19005 break;
19006
19007 if (CONSP (XCDR (elt)))
19008 n += display_mode_element (it, depth, field_width - n,
19009 precision - n, XCAR (XCDR (elt)),
19010 XCDR (XCDR (elt)), risky);
19011 }
19012 else if (SYMBOLP (car))
19013 {
19014 tem = Fboundp (car);
19015 elt = XCDR (elt);
19016 if (!CONSP (elt))
19017 goto invalid;
19018 19019
19020 if (!NILP (tem))
19021 {
19022 tem = Fsymbol_value (car);
19023 if (!NILP (tem))
19024 {
19025 elt = XCAR (elt);
19026 goto tail_recurse;
19027 }
19028 }
19029 19030 19031
19032 elt = XCDR (elt);
19033 if (NILP (elt))
19034 break;
19035 else if (!CONSP (elt))
19036 goto invalid;
19037 elt = XCAR (elt);
19038 goto tail_recurse;
19039 }
19040 else if (INTEGERP (car))
19041 {
19042 register int lim = XINT (car);
19043 elt = XCDR (elt);
19044 if (lim < 0)
19045 {
19046
19047 if (precision <= 0)
19048 precision = -lim;
19049 else
19050 precision = min (precision, -lim);
19051 }
19052 else if (lim > 0)
19053 {
19054 19055
19056 if (precision > 0)
19057 lim = min (precision, lim);
19058
19059 19060 19061
19062 field_width = max (lim, field_width);
19063 }
19064 goto tail_recurse;
19065 }
19066 else if (STRINGP (car) || CONSP (car))
19067 {
19068 Lisp_Object halftail = elt;
19069 int len = 0;
19070
19071 while (CONSP (elt)
19072 && (precision <= 0 || n < precision))
19073 {
19074 n += display_mode_element (it, depth,
19075 19076
19077 (! CONSP (XCDR (elt))
19078 ? field_width - n
19079 : 0),
19080 precision - n, XCAR (elt),
19081 props, risky);
19082 elt = XCDR (elt);
19083 len++;
19084 if ((len & 1) == 0)
19085 halftail = XCDR (halftail);
19086
19087 if (EQ (halftail, elt))
19088 break;
19089 }
19090 }
19091 }
19092 break;
19093
19094 default:
19095 invalid:
19096 elt = build_string ("*invalid*");
19097 goto tail_recurse;
19098 }
19099
19100
19101 if (field_width > 0 && n < field_width)
19102 {
19103 switch (mode_line_target)
19104 {
19105 case MODE_LINE_NOPROP:
19106 case MODE_LINE_TITLE:
19107 n += store_mode_line_noprop ("", field_width - n, 0);
19108 break;
19109 case MODE_LINE_STRING:
19110 n += store_mode_line_string ("", Qnil, 0, field_width - n, 0, Qnil);
19111 break;
19112 case MODE_LINE_DISPLAY:
19113 n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
19114 0, 0, 0);
19115 break;
19116 }
19117 }
19118
19119 return n;
19120 }
19121
19122 19123 19124 19125 19126 19127 19128 19129 19130 19131 19132 19133 19134 19135 19136 19137 19138 19139
19140
19141 static int
19142 store_mode_line_string (string, lisp_string, copy_string, field_width, precision, props)
19143 char *string;
19144 Lisp_Object lisp_string;
19145 int copy_string;
19146 int field_width;
19147 int precision;
19148 Lisp_Object props;
19149 {
19150 int len;
19151 int n = 0;
19152
19153 if (string != NULL)
19154 {
19155 len = strlen (string);
19156 if (precision > 0 && len > precision)
19157 len = precision;
19158 lisp_string = make_string (string, len);
19159 if (NILP (props))
19160 props = mode_line_string_face_prop;
19161 else if (!NILP (mode_line_string_face))
19162 {
19163 Lisp_Object face = Fplist_get (props, Qface);
19164 props = Fcopy_sequence (props);
19165 if (NILP (face))
19166 face = mode_line_string_face;
19167 else
19168 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
19169 props = Fplist_put (props, Qface, face);
19170 }
19171 Fadd_text_properties (make_number (0), make_number (len),
19172 props, lisp_string);
19173 }
19174 else
19175 {
19176 len = XFASTINT (Flength (lisp_string));
19177 if (precision > 0 && len > precision)
19178 {
19179 len = precision;
19180 lisp_string = Fsubstring (lisp_string, make_number (0), make_number (len));
19181 precision = -1;
19182 }
19183 if (!NILP (mode_line_string_face))
19184 {
19185 Lisp_Object face;
19186 if (NILP (props))
19187 props = Ftext_properties_at (make_number (0), lisp_string);
19188 face = Fplist_get (props, Qface);
19189 if (NILP (face))
19190 face = mode_line_string_face;
19191 else
19192 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
19193 props = Fcons (Qface, Fcons (face, Qnil));
19194 if (copy_string)
19195 lisp_string = Fcopy_sequence (lisp_string);
19196 }
19197 if (!NILP (props))
19198 Fadd_text_properties (make_number (0), make_number (len),
19199 props, lisp_string);
19200 }
19201
19202 if (len > 0)
19203 {
19204 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
19205 n += len;
19206 }
19207
19208 if (field_width > len)
19209 {
19210 field_width -= len;
19211 lisp_string = Fmake_string (make_number (field_width), make_number (' '));
19212 if (!NILP (props))
19213 Fadd_text_properties (make_number (0), make_number (field_width),
19214 props, lisp_string);
19215 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
19216 n += field_width;
19217 }
19218
19219 return n;
19220 }
19221
19222
19223 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
19224 1, 4, 0,
19225 doc: 19226 19227 19228 19229 19230 19231 19232 19233 19234 19235 19236 19237 19238 )
19239 (format, face, window, buffer)
19240 Lisp_Object format, face, window, buffer;
19241 {
19242 struct it it;
19243 int len;
19244 struct window *w;
19245 struct buffer *old_buffer = NULL;
19246 int face_id = -1;
19247 int no_props = INTEGERP (face);
19248 int count = SPECPDL_INDEX ();
19249 Lisp_Object str;
19250 int string_start = 0;
19251
19252 if (NILP (window))
19253 window = selected_window;
19254 CHECK_WINDOW (window);
19255 w = XWINDOW (window);
19256
19257 if (NILP (buffer))
19258 buffer = w->buffer;
19259 CHECK_BUFFER (buffer);
19260
19261 19262
19263 if (NILP (format) || noninteractive)
19264 return empty_unibyte_string;
19265
19266 if (no_props)
19267 face = Qnil;
19268
19269 if (!NILP (face))
19270 {
19271 if (EQ (face, Qt))
19272 face = (EQ (window, selected_window) ? Qmode_line : Qmode_line_inactive);
19273 face_id = lookup_named_face (XFRAME (WINDOW_FRAME (w)), face, 0);
19274 }
19275
19276 if (face_id < 0)
19277 face_id = DEFAULT_FACE_ID;
19278
19279 if (XBUFFER (buffer) != current_buffer)
19280 old_buffer = current_buffer;
19281
19282 19283
19284 record_unwind_protect (unwind_format_mode_line,
19285 format_mode_line_unwind_data
19286 (old_buffer, selected_window, 1));
19287 mode_line_proptrans_alist = Qnil;
19288
19289 Fselect_window (window, Qt);
19290 if (old_buffer)
19291 set_buffer_internal_1 (XBUFFER (buffer));
19292
19293 init_iterator (&it, w, -1, -1, NULL, face_id);
19294
19295 if (no_props)
19296 {
19297 mode_line_target = MODE_LINE_NOPROP;
19298 mode_line_string_face_prop = Qnil;
19299 mode_line_string_list = Qnil;
19300 string_start = MODE_LINE_NOPROP_LEN (0);
19301 }
19302 else
19303 {
19304 mode_line_target = MODE_LINE_STRING;
19305 mode_line_string_list = Qnil;
19306 mode_line_string_face = face;
19307 mode_line_string_face_prop
19308 = (NILP (face) ? Qnil : Fcons (Qface, Fcons (face, Qnil)));
19309 }
19310
19311 push_kboard (FRAME_KBOARD (it.f));
19312 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
19313 pop_kboard ();
19314
19315 if (no_props)
19316 {
19317 len = MODE_LINE_NOPROP_LEN (string_start);
19318 str = make_string (mode_line_noprop_buf + string_start, len);
19319 }
19320 else
19321 {
19322 mode_line_string_list = Fnreverse (mode_line_string_list);
19323 str = Fmapconcat (intern ("identity"), mode_line_string_list,
19324 empty_unibyte_string);
19325 }
19326
19327 unbind_to (count, Qnil);
19328 return str;
19329 }
19330
19331 19332
19333
19334 static void
19335 pint2str (buf, width, d)
19336 register char *buf;
19337 register int width;
19338 register int d;
19339 {
19340 register char *p = buf;
19341
19342 if (d <= 0)
19343 *p++ = '0';
19344 else
19345 {
19346 while (d > 0)
19347 {
19348 *p++ = d % 10 + '0';
19349 d /= 10;
19350 }
19351 }
19352
19353 for (width -= (int) (p - buf); width > 0; --width)
19354 *p++ = ' ';
19355 *p-- = '\0';
19356 while (p > buf)
19357 {
19358 d = *buf;
19359 *buf++ = *p;
19360 *p-- = d;
19361 }
19362 }
19363
19364 19365 19366
19367
19368 static const char power_letter[] =
19369 {
19370 0,
19371 'k',
19372 'M',
19373 'G',
19374 'T',
19375 'P',
19376 'E',
19377 'Z',
19378 'Y'
19379 };
19380
19381 static void
19382 pint2hrstr (buf, width, d)
19383 char *buf;
19384 int width;
19385 int d;
19386 {
19387 19388
19389 int quotient = d;
19390 int remainder = 0;
19391
19392 int tenths = -1;
19393 int exponent = 0;
19394
19395
19396 int length;
19397
19398 char * psuffix;
19399 char * p;
19400
19401 if (1000 <= quotient)
19402 {
19403
19404 do
19405 {
19406 remainder = quotient % 1000;
19407 quotient /= 1000;
19408 exponent++;
19409 }
19410 while (1000 <= quotient);
19411
19412
19413 if (quotient <= 9)
19414 {
19415 tenths = remainder / 100;
19416 if (50 <= remainder % 100)
19417 {
19418 if (tenths < 9)
19419 tenths++;
19420 else
19421 {
19422 quotient++;
19423 if (quotient == 10)
19424 tenths = -1;
19425 else
19426 tenths = 0;
19427 }
19428 }
19429 }
19430 else
19431 if (500 <= remainder)
19432 {
19433 if (quotient < 999)
19434 quotient++;
19435 else
19436 {
19437 quotient = 1;
19438 exponent++;
19439 tenths = 0;
19440 }
19441 }
19442 }
19443
19444
19445 if (tenths == -1 && quotient <= 99)
19446 if (quotient <= 9)
19447 length = 1;
19448 else
19449 length = 2;
19450 else
19451 length = 3;
19452 p = psuffix = buf + max (width, length);
19453
19454
19455 if (exponent)
19456 *psuffix++ = power_letter[exponent];
19457 *psuffix = '\0';
19458
19459
19460 if (tenths >= 0)
19461 {
19462 *--p = '0' + tenths;
19463 *--p = '.';
19464 }
19465
19466
19467 do
19468 {
19469 int digit = quotient % 10;
19470 *--p = '0' + digit;
19471 }
19472 while ((quotient /= 10) != 0);
19473
19474
19475 while (buf < p)
19476 *--p = ' ';
19477 }
19478
19479 19480 19481
19482
19483 static unsigned char invalid_eol_type[] = "(*invalid*)";
19484
19485 static char *
19486 decode_mode_spec_coding (coding_system, buf, eol_flag)
19487 Lisp_Object coding_system;
19488 register char *buf;
19489 int eol_flag;
19490 {
19491 Lisp_Object val;
19492 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
19493 const unsigned char *eol_str;
19494 int eol_str_len;
19495
19496 Lisp_Object eoltype;
19497
19498 val = CODING_SYSTEM_SPEC (coding_system);
19499 eoltype = Qnil;
19500
19501 if (!VECTORP (val))
19502 {
19503 if (multibyte)
19504 *buf++ = '-';
19505 if (eol_flag)
19506 eoltype = eol_mnemonic_undecided;
19507
19508 }
19509 else
19510 {
19511 Lisp_Object attrs;
19512 Lisp_Object eolvalue;
19513
19514 attrs = AREF (val, 0);
19515 eolvalue = AREF (val, 2);
19516
19517 if (multibyte)
19518 *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs));
19519
19520 if (eol_flag)
19521 {
19522
19523
19524 if (NILP (eolvalue))
19525 eoltype = eol_mnemonic_undecided;
19526 else if (VECTORP (eolvalue))
19527 eoltype = eol_mnemonic_undecided;
19528 else
19529 eoltype = (EQ (eolvalue, Qunix)
19530 ? eol_mnemonic_unix
19531 : (EQ (eolvalue, Qdos) == 1
19532 ? eol_mnemonic_dos : eol_mnemonic_mac));
19533 }
19534 }
19535
19536 if (eol_flag)
19537 {
19538
19539 if (STRINGP (eoltype))
19540 {
19541 eol_str = SDATA (eoltype);
19542 eol_str_len = SBYTES (eoltype);
19543 }
19544 else if (CHARACTERP (eoltype))
19545 {
19546 unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
19547 eol_str_len = CHAR_STRING (XINT (eoltype), tmp);
19548 eol_str = tmp;
19549 }
19550 else
19551 {
19552 eol_str = invalid_eol_type;
19553 eol_str_len = sizeof (invalid_eol_type) - 1;
19554 }
19555 bcopy (eol_str, buf, eol_str_len);
19556 buf += eol_str_len;
19557 }
19558
19559 return buf;
19560 }
19561
19562 19563 19564 19565 19566 19567 19568 19569
19570
19571 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
19572
19573 static char *
19574 decode_mode_spec (w, c, field_width, precision, string)
19575 struct window *w;
19576 register int c;
19577 int field_width, precision;
19578 Lisp_Object *string;
19579 {
19580 Lisp_Object obj;
19581 struct frame *f = XFRAME (WINDOW_FRAME (w));
19582 char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
19583 struct buffer *b = current_buffer;
19584
19585 obj = Qnil;
19586 *string = Qnil;
19587
19588 switch (c)
19589 {
19590 case '*':
19591 if (!NILP (b->read_only))
19592 return "%";
19593 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19594 return "*";
19595 return "-";
19596
19597 case '+':
19598
19599 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19600 return "*";
19601 if (!NILP (b->read_only))
19602 return "%";
19603 return "-";
19604
19605 case '&':
19606
19607 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19608 return "*";
19609 return "-";
19610
19611 case '%':
19612 return "%";
19613
19614 case '[':
19615 {
19616 int i;
19617 char *p;
19618
19619 if (command_loop_level > 5)
19620 return "[[[... ";
19621 p = decode_mode_spec_buf;
19622 for (i = 0; i < command_loop_level; i++)
19623 *p++ = '[';
19624 *p = 0;
19625 return decode_mode_spec_buf;
19626 }
19627
19628 case ']':
19629 {
19630 int i;
19631 char *p;
19632
19633 if (command_loop_level > 5)
19634 return " ...]]]";
19635 p = decode_mode_spec_buf;
19636 for (i = 0; i < command_loop_level; i++)
19637 *p++ = ']';
19638 *p = 0;
19639 return decode_mode_spec_buf;
19640 }
19641
19642 case '-':
19643 {
19644 register int i;
19645
19646
19647 if (mode_line_target == MODE_LINE_NOPROP ||
19648 mode_line_target == MODE_LINE_STRING)
19649 return "--";
19650 if (field_width <= 0
19651 || field_width > sizeof (lots_of_dashes))
19652 {
19653 for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
19654 decode_mode_spec_buf[i] = '-';
19655 decode_mode_spec_buf[i] = '\0';
19656 return decode_mode_spec_buf;
19657 }
19658 else
19659 return lots_of_dashes;
19660 }
19661
19662 case 'b':
19663 obj = b->name;
19664 break;
19665
19666 case 'c':
19667 19668 19669 19670 19671
19672 if (mode_line_target == MODE_LINE_TITLE)
19673 return "";
19674 else
19675 {
19676 int col = (int) current_column ();
19677 w->column_number_displayed = make_number (col);
19678 pint2str (decode_mode_spec_buf, field_width, col);
19679 return decode_mode_spec_buf;
19680 }
19681
19682 case 'e':
19683 #ifndef SYSTEM_MALLOC
19684 {
19685 if (NILP (Vmemory_full))
19686 return "";
19687 else
19688 return "!MEM FULL! ";
19689 }
19690 #else
19691 return "";
19692 #endif
19693
19694 case 'F':
19695
19696 if (!NILP (f->title))
19697 return (char *) SDATA (f->title);
19698 if (f->explicit_name || ! FRAME_WINDOW_P (f))
19699 return (char *) SDATA (f->name);
19700 return "Emacs";
19701
19702 case 'f':
19703 obj = b->filename;
19704 break;
19705
19706 case 'i':
19707 {
19708 int size = ZV - BEGV;
19709 pint2str (decode_mode_spec_buf, field_width, size);
19710 return decode_mode_spec_buf;
19711 }
19712
19713 case 'I':
19714 {
19715 int size = ZV - BEGV;
19716 pint2hrstr (decode_mode_spec_buf, field_width, size);
19717 return decode_mode_spec_buf;
19718 }
19719
19720 case 'l':
19721 {
19722 int startpos, startpos_byte, line, linepos, linepos_byte;
19723 int topline, nlines, junk, height;
19724
19725
19726 if (mode_line_target == MODE_LINE_TITLE)
19727 return "";
19728
19729 startpos = XMARKER (w->start)->charpos;
19730 startpos_byte = marker_byte_position (w->start);
19731 height = WINDOW_TOTAL_LINES (w);
19732
19733 19734
19735 if (EQ (w->base_line_pos, w->buffer))
19736 goto no_value;
19737
19738 else if (BUFFERP (w->base_line_pos))
19739 w->base_line_pos = Qnil;
19740
19741
19742 if (INTEGERP (Vline_number_display_limit)
19743 && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
19744 {
19745 w->base_line_pos = Qnil;
19746 w->base_line_number = Qnil;
19747 goto no_value;
19748 }
19749
19750 if (INTEGERP (w->base_line_number)
19751 && INTEGERP (w->base_line_pos)
19752 && XFASTINT (w->base_line_pos) <= startpos)
19753 {
19754 line = XFASTINT (w->base_line_number);
19755 linepos = XFASTINT (w->base_line_pos);
19756 linepos_byte = buf_charpos_to_bytepos (b, linepos);
19757 }
19758 else
19759 {
19760 line = 1;
19761 linepos = BUF_BEGV (b);
19762 linepos_byte = BUF_BEGV_BYTE (b);
19763 }
19764
19765
19766 nlines = display_count_lines (linepos, linepos_byte,
19767 startpos_byte,
19768 startpos, &junk);
19769
19770 topline = nlines + line;
19771
19772 19773 19774 19775
19776 if (startpos == BUF_BEGV (b))
19777 {
19778 w->base_line_number = make_number (topline);
19779 w->base_line_pos = make_number (BUF_BEGV (b));
19780 }
19781 else if (nlines < height + 25 || nlines > height * 3 + 50
19782 || linepos == BUF_BEGV (b))
19783 {
19784 int limit = BUF_BEGV (b);
19785 int limit_byte = BUF_BEGV_BYTE (b);
19786 int position;
19787 int distance = (height * 2 + 30) * line_number_display_limit_width;
19788
19789 if (startpos - distance > limit)
19790 {
19791 limit = startpos - distance;
19792 limit_byte = CHAR_TO_BYTE (limit);
19793 }
19794
19795 nlines = display_count_lines (startpos, startpos_byte,
19796 limit_byte,
19797 - (height * 2 + 30),
19798 &position);
19799 19800 19801
19802 if (position == limit_byte && limit == startpos - distance)
19803 {
19804 w->base_line_pos = w->buffer;
19805 w->base_line_number = Qnil;
19806 goto no_value;
19807 }
19808
19809 w->base_line_number = make_number (topline - nlines);
19810 w->base_line_pos = make_number (BYTE_TO_CHAR (position));
19811 }
19812
19813
19814 nlines = display_count_lines (startpos, startpos_byte,
19815 PT_BYTE, PT, &junk);
19816
19817
19818 line_number_displayed = 1;
19819
19820
19821 pint2str (decode_mode_spec_buf, field_width, topline + nlines);
19822 return decode_mode_spec_buf;
19823 no_value:
19824 {
19825 char* p = decode_mode_spec_buf;
19826 int pad = field_width - 2;
19827 while (pad-- > 0)
19828 *p++ = ' ';
19829 *p++ = '?';
19830 *p++ = '?';
19831 *p = '\0';
19832 return decode_mode_spec_buf;
19833 }
19834 }
19835 break;
19836
19837 case 'm':
19838 obj = b->mode_name;
19839 break;
19840
19841 case 'n':
19842 if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
19843 return " Narrow";
19844 break;
19845
19846 case 'p':
19847 {
19848 int pos = marker_position (w->start);
19849 int total = BUF_ZV (b) - BUF_BEGV (b);
19850
19851 if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
19852 {
19853 if (pos <= BUF_BEGV (b))
19854 return "All";
19855 else
19856 return "Bottom";
19857 }
19858 else if (pos <= BUF_BEGV (b))
19859 return "Top";
19860 else
19861 {
19862 if (total > 1000000)
19863
19864 total = ((pos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
19865 else
19866 total = ((pos - BUF_BEGV (b)) * 100 + total - 1) / total;
19867 19868
19869 if (total == 100)
19870 total = 99;
19871 sprintf (decode_mode_spec_buf, "%2d%%", total);
19872 return decode_mode_spec_buf;
19873 }
19874 }
19875
19876
19877 case 'P':
19878 {
19879 int toppos = marker_position (w->start);
19880 int botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
19881 int total = BUF_ZV (b) - BUF_BEGV (b);
19882
19883 if (botpos >= BUF_ZV (b))
19884 {
19885 if (toppos <= BUF_BEGV (b))
19886 return "All";
19887 else
19888 return "Bottom";
19889 }
19890 else
19891 {
19892 if (total > 1000000)
19893
19894 total = ((botpos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
19895 else
19896 total = ((botpos - BUF_BEGV (b)) * 100 + total - 1) / total;
19897 19898
19899 if (total == 100)
19900 total = 99;
19901 if (toppos <= BUF_BEGV (b))
19902 sprintf (decode_mode_spec_buf, "Top%2d%%", total);
19903 else
19904 sprintf (decode_mode_spec_buf, "%2d%%", total);
19905 return decode_mode_spec_buf;
19906 }
19907 }
19908
19909 case 's':
19910
19911 obj = Fget_buffer_process (Fcurrent_buffer ());
19912 if (NILP (obj))
19913 return "no process";
19914 #ifdef subprocesses
19915 obj = Fsymbol_name (Fprocess_status (obj));
19916 #endif
19917 break;
19918
19919 case '@':
19920 {
19921 int count = inhibit_garbage_collection ();
19922 Lisp_Object val = call1 (intern ("file-remote-p"),
19923 current_buffer->directory);
19924 unbind_to (count, Qnil);
19925
19926 if (NILP (val))
19927 return "-";
19928 else
19929 return "@";
19930 }
19931
19932 case 't':
19933 #ifdef MODE_LINE_BINARY_TEXT
19934 return MODE_LINE_BINARY_TEXT (b);
19935 #else
19936 return "T";
19937 #endif
19938
19939 case 'z':
19940
19941 case 'Z':
19942
19943 {
19944 int eol_flag = (c == 'Z');
19945 char *p = decode_mode_spec_buf;
19946
19947 if (! FRAME_WINDOW_P (f))
19948 {
19949 19950
19951 p = decode_mode_spec_coding (CODING_ID_NAME
19952 (FRAME_KEYBOARD_CODING (f)->id),
19953 p, 0);
19954 p = decode_mode_spec_coding (CODING_ID_NAME
19955 (FRAME_TERMINAL_CODING (f)->id),
19956 p, 0);
19957 }
19958 p = decode_mode_spec_coding (b->buffer_file_coding_system,
19959 p, eol_flag);
19960
19961 #if 0
19962 #ifdef subprocesses
19963 obj = Fget_buffer_process (Fcurrent_buffer ());
19964 if (PROCESSP (obj))
19965 {
19966 p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
19967 p, eol_flag);
19968 p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
19969 p, eol_flag);
19970 }
19971 #endif
19972 #endif
19973 *p = 0;
19974 return decode_mode_spec_buf;
19975 }
19976 }
19977
19978 if (STRINGP (obj))
19979 {
19980 *string = obj;
19981 return (char *) SDATA (obj);
19982 }
19983 else
19984 return "";
19985 }
19986
19987
19988 19989 19990 19991 19992
19993
19994 static int
19995 display_count_lines (start, start_byte, limit_byte, count, byte_pos_ptr)
19996 int start, start_byte, limit_byte, count;
19997 int *byte_pos_ptr;
19998 {
19999 register unsigned char *cursor;
20000 unsigned char *base;
20001
20002 register int ceiling;
20003 register unsigned char *ceiling_addr;
20004 int orig_count = count;
20005
20006 20007
20008 int selective_display = (!NILP (current_buffer->selective_display)
20009 && !INTEGERP (current_buffer->selective_display));
20010
20011 if (count > 0)
20012 {
20013 while (start_byte < limit_byte)
20014 {
20015 ceiling = BUFFER_CEILING_OF (start_byte);
20016 ceiling = min (limit_byte - 1, ceiling);
20017 ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
20018 base = (cursor = BYTE_POS_ADDR (start_byte));
20019 while (1)
20020 {
20021 if (selective_display)
20022 while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
20023 ;
20024 else
20025 while (*cursor != '\n' && ++cursor != ceiling_addr)
20026 ;
20027
20028 if (cursor != ceiling_addr)
20029 {
20030 if (--count == 0)
20031 {
20032 start_byte += cursor - base + 1;
20033 *byte_pos_ptr = start_byte;
20034 return orig_count;
20035 }
20036 else
20037 if (++cursor == ceiling_addr)
20038 break;
20039 }
20040 else
20041 break;
20042 }
20043 start_byte += cursor - base;
20044 }
20045 }
20046 else
20047 {
20048 while (start_byte > limit_byte)
20049 {
20050 ceiling = BUFFER_FLOOR_OF (start_byte - 1);
20051 ceiling = max (limit_byte, ceiling);
20052 ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
20053 base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
20054 while (1)
20055 {
20056 if (selective_display)
20057 while (--cursor != ceiling_addr
20058 && *cursor != '\n' && *cursor != 015)
20059 ;
20060 else
20061 while (--cursor != ceiling_addr && *cursor != '\n')
20062 ;
20063
20064 if (cursor != ceiling_addr)
20065 {
20066 if (++count == 0)
20067 {
20068 start_byte += cursor - base + 1;
20069 *byte_pos_ptr = start_byte;
20070 20071
20072 return - orig_count - 1;
20073 }
20074 }
20075 else
20076 break;
20077 }
20078 20079
20080 start_byte += cursor - base + 1;
20081 }
20082 }
20083
20084 *byte_pos_ptr = limit_byte;
20085
20086 if (count < 0)
20087 return - orig_count + count;
20088 return orig_count - count;
20089
20090 }
20091
20092
20093
20094 20095 20096
20097
20098 20099 20100 20101 20102 20103 20104 20105 20106 20107 20108 20109 20110 20111 20112 20113 20114 20115 20116 20117 20118 20119 20120 20121 20122 20123 20124 20125 20126 20127 20128 20129 20130 20131 20132 20133 20134
20135
20136 static int
20137 display_string (string, lisp_string, face_string, face_string_pos,
20138 start, it, field_width, precision, max_x, multibyte)
20139 unsigned char *string;
20140 Lisp_Object lisp_string;
20141 Lisp_Object face_string;
20142 EMACS_INT face_string_pos;
20143 EMACS_INT start;
20144 struct it *it;
20145 int field_width, precision, max_x;
20146 int multibyte;
20147 {
20148 int hpos_at_start = it->hpos;
20149 int saved_face_id = it->face_id;
20150 struct glyph_row *row = it->glyph_row;
20151
20152 20153
20154 reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string, start,
20155 precision, field_width, multibyte);
20156 if (string && STRINGP (lisp_string))
20157 20158
20159 it->stop_charpos = -1;
20160
20161 20162
20163 if (STRINGP (face_string))
20164 {
20165 EMACS_INT endptr;
20166 struct face *face;
20167
20168 it->face_id
20169 = face_at_string_position (it->w, face_string, face_string_pos,
20170 0, it->region_beg_charpos,
20171 it->region_end_charpos,
20172 &endptr, it->base_face_id, 0);
20173 face = FACE_FROM_ID (it->f, it->face_id);
20174 it->face_box_p = face->box != FACE_NO_BOX;
20175 }
20176
20177 20178
20179 if (max_x <= 0)
20180 max_x = it->last_visible_x;
20181 else
20182 max_x = min (max_x, it->last_visible_x);
20183
20184 20185
20186 if (it->current_x < it->first_visible_x)
20187 move_it_in_display_line_to (it, 100000, it->first_visible_x,
20188 MOVE_TO_POS | MOVE_TO_X);
20189
20190 row->ascent = it->max_ascent;
20191 row->height = it->max_ascent + it->max_descent;
20192 row->phys_ascent = it->max_phys_ascent;
20193 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
20194 row->extra_line_spacing = it->max_extra_line_spacing;
20195
20196 20197
20198 while (it->current_x < max_x)
20199 {
20200 int x_before, x, n_glyphs_before, i, nglyphs;
20201
20202
20203 if (!get_next_display_element (it))
20204 break;
20205
20206
20207 x_before = it->current_x;
20208 n_glyphs_before = it->glyph_row->used[TEXT_AREA];
20209 PRODUCE_GLYPHS (it);
20210
20211 nglyphs = it->glyph_row->used[TEXT_AREA] - n_glyphs_before;
20212 i = 0;
20213 x = x_before;
20214 while (i < nglyphs)
20215 {
20216 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
20217
20218 if (it->line_wrap != TRUNCATE
20219 && x + glyph->pixel_width > max_x)
20220 {
20221
20222 if (CHAR_GLYPH_PADDING_P (*glyph))
20223 {
20224
20225 it->glyph_row->used[TEXT_AREA] = n_glyphs_before;
20226 it->current_x = x_before;
20227 }
20228 else
20229 {
20230 it->glyph_row->used[TEXT_AREA] = n_glyphs_before + i;
20231 it->current_x = x;
20232 }
20233 break;
20234 }
20235 else if (x + glyph->pixel_width >= it->first_visible_x)
20236 {
20237
20238 ++it->hpos;
20239 if (x < it->first_visible_x)
20240 it->glyph_row->x = x - it->first_visible_x;
20241 }
20242 else
20243 {
20244 20245
20246 abort ();
20247 }
20248
20249 row->ascent = max (row->ascent, it->max_ascent);
20250 row->height = max (row->height, it->max_ascent + it->max_descent);
20251 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
20252 row->phys_height = max (row->phys_height,
20253 it->max_phys_ascent + it->max_phys_descent);
20254 row->extra_line_spacing = max (row->extra_line_spacing,
20255 it->max_extra_line_spacing);
20256 x += glyph->pixel_width;
20257 ++i;
20258 }
20259
20260
20261 if (i < nglyphs)
20262 break;
20263
20264
20265 if (ITERATOR_AT_END_OF_LINE_P (it))
20266 {
20267 it->continuation_lines_width = 0;
20268 break;
20269 }
20270
20271 set_iterator_to_next (it, 1);
20272
20273
20274 if (it->line_wrap == TRUNCATE
20275 && it->current_x >= it->last_visible_x)
20276 {
20277 20278
20279 if (IT_CHARPOS (*it) < it->string_nchars)
20280 {
20281 if (!FRAME_WINDOW_P (it->f))
20282 {
20283 int i, n;
20284
20285 if (it->current_x > it->last_visible_x)
20286 {
20287 for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
20288 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
20289 break;
20290 for (n = row->used[TEXT_AREA]; i < n; ++i)
20291 {
20292 row->used[TEXT_AREA] = i;
20293 produce_special_glyphs (it, IT_TRUNCATION);
20294 }
20295 }
20296 produce_special_glyphs (it, IT_TRUNCATION);
20297 }
20298 it->glyph_row->truncated_on_right_p = 1;
20299 }
20300 break;
20301 }
20302 }
20303
20304
20305 if (it->first_visible_x
20306 && IT_CHARPOS (*it) > 0)
20307 {
20308 if (!FRAME_WINDOW_P (it->f))
20309 insert_left_trunc_glyphs (it);
20310 it->glyph_row->truncated_on_left_p = 1;
20311 }
20312
20313 it->face_id = saved_face_id;
20314
20315
20316 return it->hpos - hpos_at_start;
20317 }
20318
20319
20320
20321 20322 20323 20324 20325 20326 20327
20328
20329 int
20330 invisible_p (propval, list)
20331 register Lisp_Object propval;
20332 Lisp_Object list;
20333 {
20334 register Lisp_Object tail, proptail;
20335
20336 for (tail = list; CONSP (tail); tail = XCDR (tail))
20337 {
20338 register Lisp_Object tem;
20339 tem = XCAR (tail);
20340 if (EQ (propval, tem))
20341 return 1;
20342 if (CONSP (tem) && EQ (propval, XCAR (tem)))
20343 return NILP (XCDR (tem)) ? 1 : 2;
20344 }
20345
20346 if (CONSP (propval))
20347 {
20348 for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
20349 {
20350 Lisp_Object propelt;
20351 propelt = XCAR (proptail);
20352 for (tail = list; CONSP (tail); tail = XCDR (tail))
20353 {
20354 register Lisp_Object tem;
20355 tem = XCAR (tail);
20356 if (EQ (propelt, tem))
20357 return 1;
20358 if (CONSP (tem) && EQ (propelt, XCAR (tem)))
20359 return NILP (XCDR (tem)) ? 1 : 2;
20360 }
20361 }
20362 }
20363
20364 return 0;
20365 }
20366
20367 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
20368 doc: 20369 20370 20371 20372 20373 20374 )
20375 (pos_or_prop)
20376 Lisp_Object pos_or_prop;
20377 {
20378 Lisp_Object prop
20379 = (NATNUMP (pos_or_prop) || MARKERP (pos_or_prop)
20380 ? Fget_char_property (pos_or_prop, Qinvisible, Qnil)
20381 : pos_or_prop);
20382 int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
20383 return (invis == 0 ? Qnil
20384 : invis == 1 ? Qt
20385 : make_number (invis));
20386 }
20387
20388 20389 20390 20391 20392 20393 20394 20395 20396 20397 20398 20399 20400 20401 20402 20403 20404 20405 20406 20407 20408 20409 20410 20411 20412 20413 20414 20415 20416 20417 20418 20419 20420 20421 20422 20423 20424 20425 20426 20427 20428 20429 20430 20431 20432 20433 20434 20435 20436 20437 20438 20439 20440 20441 20442 20443 20444 20445 20446 20447 20448 20449 20450 20451 20452 20453
20454
20455 #define NUMVAL(X) \
20456 ((INTEGERP (X) || FLOATP (X)) \
20457 ? XFLOATINT (X) \
20458 : - 1)
20459
20460 int
20461 calc_pixel_width_or_height (res, it, prop, font, width_p, align_to)
20462 double *res;
20463 struct it *it;
20464 Lisp_Object prop;
20465 struct font *font;
20466 int width_p, *align_to;
20467 {
20468 double pixels;
20469
20470 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
20471 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
20472
20473 if (NILP (prop))
20474 return OK_PIXELS (0);
20475
20476 xassert (FRAME_LIVE_P (it->f));
20477
20478 if (SYMBOLP (prop))
20479 {
20480 if (SCHARS (SYMBOL_NAME (prop)) == 2)
20481 {
20482 char *unit = SDATA (SYMBOL_NAME (prop));
20483
20484 if (unit[0] == 'i' && unit[1] == 'n')
20485 pixels = 1.0;
20486 else if (unit[0] == 'm' && unit[1] == 'm')
20487 pixels = 25.4;
20488 else if (unit[0] == 'c' && unit[1] == 'm')
20489 pixels = 2.54;
20490 else
20491 pixels = 0;
20492 if (pixels > 0)
20493 {
20494 double ppi;
20495 #ifdef HAVE_WINDOW_SYSTEM
20496 if (FRAME_WINDOW_P (it->f)
20497 && (ppi = (width_p
20498 ? FRAME_X_DISPLAY_INFO (it->f)->resx
20499 : FRAME_X_DISPLAY_INFO (it->f)->resy),
20500 ppi > 0))
20501 return OK_PIXELS (ppi / pixels);
20502 #endif
20503
20504 if ((ppi = NUMVAL (Vdisplay_pixels_per_inch), ppi > 0)
20505 || (CONSP (Vdisplay_pixels_per_inch)
20506 && (ppi = (width_p
20507 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch))
20508 : NUMVAL (XCDR (Vdisplay_pixels_per_inch))),
20509 ppi > 0)))
20510 return OK_PIXELS (ppi / pixels);
20511
20512 return 0;
20513 }
20514 }
20515
20516 #ifdef HAVE_WINDOW_SYSTEM
20517 if (EQ (prop, Qheight))
20518 return OK_PIXELS (font ? FONT_HEIGHT (font) : FRAME_LINE_HEIGHT (it->f));
20519 if (EQ (prop, Qwidth))
20520 return OK_PIXELS (font ? FONT_WIDTH (font) : FRAME_COLUMN_WIDTH (it->f));
20521 #else
20522 if (EQ (prop, Qheight) || EQ (prop, Qwidth))
20523 return OK_PIXELS (1);
20524 #endif
20525
20526 if (EQ (prop, Qtext))
20527 return OK_PIXELS (width_p
20528 ? window_box_width (it->w, TEXT_AREA)
20529 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
20530
20531 if (align_to && *align_to < 0)
20532 {
20533 *res = 0;
20534 if (EQ (prop, Qleft))
20535 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA));
20536 if (EQ (prop, Qright))
20537 return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
20538 if (EQ (prop, Qcenter))
20539 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
20540 + window_box_width (it->w, TEXT_AREA) / 2);
20541 if (EQ (prop, Qleft_fringe))
20542 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20543 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
20544 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
20545 if (EQ (prop, Qright_fringe))
20546 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20547 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
20548 : window_box_right_offset (it->w, TEXT_AREA));
20549 if (EQ (prop, Qleft_margin))
20550 return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
20551 if (EQ (prop, Qright_margin))
20552 return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
20553 if (EQ (prop, Qscroll_bar))
20554 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
20555 ? 0
20556 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
20557 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20558 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
20559 : 0)));
20560 }
20561 else
20562 {
20563 if (EQ (prop, Qleft_fringe))
20564 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
20565 if (EQ (prop, Qright_fringe))
20566 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
20567 if (EQ (prop, Qleft_margin))
20568 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
20569 if (EQ (prop, Qright_margin))
20570 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
20571 if (EQ (prop, Qscroll_bar))
20572 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
20573 }
20574
20575 prop = Fbuffer_local_value (prop, it->w->buffer);
20576 }
20577
20578 if (INTEGERP (prop) || FLOATP (prop))
20579 {
20580 int base_unit = (width_p
20581 ? FRAME_COLUMN_WIDTH (it->f)
20582 : FRAME_LINE_HEIGHT (it->f));
20583 return OK_PIXELS (XFLOATINT (prop) * base_unit);
20584 }
20585
20586 if (CONSP (prop))
20587 {
20588 Lisp_Object car = XCAR (prop);
20589 Lisp_Object cdr = XCDR (prop);
20590
20591 if (SYMBOLP (car))
20592 {
20593 #ifdef HAVE_WINDOW_SYSTEM
20594 if (FRAME_WINDOW_P (it->f)
20595 && valid_image_p (prop))
20596 {
20597 int id = lookup_image (it->f, prop);
20598 struct image *img = IMAGE_FROM_ID (it->f, id);
20599
20600 return OK_PIXELS (width_p ? img->width : img->height);
20601 }
20602 #endif
20603 if (EQ (car, Qplus) || EQ (car, Qminus))
20604 {
20605 int first = 1;
20606 double px;
20607
20608 pixels = 0;
20609 while (CONSP (cdr))
20610 {
20611 if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
20612 font, width_p, align_to))
20613 return 0;
20614 if (first)
20615 pixels = (EQ (car, Qplus) ? px : -px), first = 0;
20616 else
20617 pixels += px;
20618 cdr = XCDR (cdr);
20619 }
20620 if (EQ (car, Qminus))
20621 pixels = -pixels;
20622 return OK_PIXELS (pixels);
20623 }
20624
20625 car = Fbuffer_local_value (car, it->w->buffer);
20626 }
20627
20628 if (INTEGERP (car) || FLOATP (car))
20629 {
20630 double fact;
20631 pixels = XFLOATINT (car);
20632 if (NILP (cdr))
20633 return OK_PIXELS (pixels);
20634 if (calc_pixel_width_or_height (&fact, it, cdr,
20635 font, width_p, align_to))
20636 return OK_PIXELS (pixels * fact);
20637 return 0;
20638 }
20639
20640 return 0;
20641 }
20642
20643 return 0;
20644 }
20645
20646
20647 20648 20649
20650
20651 #ifdef HAVE_WINDOW_SYSTEM
20652
20653 #if GLYPH_DEBUG
20654
20655 void
20656 dump_glyph_string (s)
20657 struct glyph_string *s;
20658 {
20659 fprintf (stderr, "glyph string\n");
20660 fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
20661 s->x, s->y, s->width, s->height);
20662 fprintf (stderr, " ybase = %d\n", s->ybase);
20663 fprintf (stderr, " hl = %d\n", s->hl);
20664 fprintf (stderr, " left overhang = %d, right = %d\n",
20665 s->left_overhang, s->right_overhang);
20666 fprintf (stderr, " nchars = %d\n", s->nchars);
20667 fprintf (stderr, " extends to end of line = %d\n",
20668 s->extends_to_end_of_line_p);
20669 fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
20670 fprintf (stderr, " bg width = %d\n", s->background_width);
20671 }
20672
20673 #endif
20674
20675 20676 20677 20678 20679 20680 20681
20682
20683 #ifdef HAVE_NTGUI
20684 #define OPTIONAL_HDC(hdc) hdc,
20685 #define DECLARE_HDC(hdc) HDC hdc;
20686 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
20687 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
20688 #endif
20689
20690 #ifndef OPTIONAL_HDC
20691 #define OPTIONAL_HDC(hdc)
20692 #define DECLARE_HDC(hdc)
20693 #define ALLOCATE_HDC(hdc, f)
20694 #define RELEASE_HDC(hdc, f)
20695 #endif
20696
20697 static void
20698 init_glyph_string (s, OPTIONAL_HDC (hdc) char2b, w, row, area, start, hl)
20699 struct glyph_string *s;
20700 DECLARE_HDC (hdc)
20701 XChar2b *char2b;
20702 struct window *w;
20703 struct glyph_row *row;
20704 enum glyph_row_area area;
20705 int start;
20706 enum draw_glyphs_face hl;
20707 {
20708 bzero (s, sizeof *s);
20709 s->w = w;
20710 s->f = XFRAME (w->frame);
20711 #ifdef HAVE_NTGUI
20712 s->hdc = hdc;
20713 #endif
20714 s->display = FRAME_X_DISPLAY (s->f);
20715 s->window = FRAME_X_WINDOW (s->f);
20716 s->char2b = char2b;
20717 s->hl = hl;
20718 s->row = row;
20719 s->area = area;
20720 s->first_glyph = row->glyphs[area] + start;
20721 s->height = row->height;
20722 s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
20723 s->ybase = s->y + row->ascent;
20724 }
20725
20726
20727 20728
20729
20730 static INLINE void
20731 append_glyph_string_lists (head, tail, h, t)
20732 struct glyph_string **head, **tail;
20733 struct glyph_string *h, *t;
20734 {
20735 if (h)
20736 {
20737 if (*head)
20738 (*tail)->next = h;
20739 else
20740 *head = h;
20741 h->prev = *tail;
20742 *tail = t;
20743 }
20744 }
20745
20746
20747 20748 20749
20750
20751 static INLINE void
20752 prepend_glyph_string_lists (head, tail, h, t)
20753 struct glyph_string **head, **tail;
20754 struct glyph_string *h, *t;
20755 {
20756 if (h)
20757 {
20758 if (*head)
20759 (*head)->prev = t;
20760 else
20761 *tail = t;
20762 t->next = *head;
20763 *head = h;
20764 }
20765 }
20766
20767
20768 20769
20770
20771 static INLINE void
20772 append_glyph_string (head, tail, s)
20773 struct glyph_string **head, **tail;
20774 struct glyph_string *s;
20775 {
20776 s->next = s->prev = NULL;
20777 append_glyph_string_lists (head, tail, s, s);
20778 }
20779
20780
20781 20782 20783 20784 20785 20786
20787
20788 static INLINE struct face *
20789 get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p, display_p)
20790 struct frame *f;
20791 int c, face_id;
20792 XChar2b *char2b;
20793 int multibyte_p, display_p;
20794 {
20795 struct face *face = FACE_FROM_ID (f, face_id);
20796
20797 if (face->font)
20798 {
20799 unsigned code = face->font->driver->encode_char (face->font, c);
20800
20801 if (code != FONT_INVALID_CODE)
20802 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
20803 else
20804 STORE_XCHAR2B (char2b, 0, 0);
20805 }
20806
20807
20808 #ifdef HAVE_X_WINDOWS
20809 if (display_p)
20810 #endif
20811 {
20812 xassert (face != NULL);
20813 PREPARE_FACE_FOR_DISPLAY (f, face);
20814 }
20815
20816 return face;
20817 }
20818
20819
20820 20821 20822
20823
20824 static INLINE struct face *
20825 get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
20826 struct frame *f;
20827 struct glyph *glyph;
20828 XChar2b *char2b;
20829 int *two_byte_p;
20830 {
20831 struct face *face;
20832
20833 xassert (glyph->type == CHAR_GLYPH);
20834 face = FACE_FROM_ID (f, glyph->face_id);
20835
20836 if (two_byte_p)
20837 *two_byte_p = 0;
20838
20839 if (face->font)
20840 {
20841 unsigned code = face->font->driver->encode_char (face->font, glyph->u.ch);
20842
20843 if (code != FONT_INVALID_CODE)
20844 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
20845 else
20846 STORE_XCHAR2B (char2b, 0, 0);
20847 }
20848
20849
20850 xassert (face != NULL);
20851 PREPARE_FACE_FOR_DISPLAY (f, face);
20852 return face;
20853 }
20854
20855
20856 20857 20858 20859 20860 20861 20862 20863 20864
20865
20866 static int
20867 fill_composite_glyph_string (s, base_face, overlaps)
20868 struct glyph_string *s;
20869 struct face *base_face;
20870 int overlaps;
20871 {
20872 int i;
20873 20874 20875
20876 struct face *face;
20877
20878 xassert (s);
20879
20880 s->for_overlaps = overlaps;
20881 s->face = NULL;
20882 s->font = NULL;
20883 for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
20884 {
20885 int c = COMPOSITION_GLYPH (s->cmp, i);
20886
20887 if (c != '\t')
20888 {
20889 int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
20890 -1, Qnil);
20891
20892 face = get_char_face_and_encoding (s->f, c, face_id,
20893 s->char2b + i, 1, 1);
20894 if (face)
20895 {
20896 if (! s->face)
20897 {
20898 s->face = face;
20899 s->font = s->face->font;
20900 }
20901 else if (s->face != face)
20902 break;
20903 }
20904 }
20905 ++s->nchars;
20906 }
20907 s->cmp_to = i;
20908
20909 20910
20911 s->width = s->first_glyph->pixel_width;
20912
20913 20914 20915 20916
20917 if (s->font == NULL)
20918 {
20919 s->font_not_found_p = 1;
20920 s->font = FRAME_FONT (s->f);
20921 }
20922
20923
20924 s->ybase += s->first_glyph->voffset;
20925
20926
20927 s->two_byte_p = 1;
20928
20929 return s->cmp_to;
20930 }
20931
20932 static int
20933 fill_gstring_glyph_string (s, face_id, start, end, overlaps)
20934 struct glyph_string *s;
20935 int face_id;
20936 int start, end, overlaps;
20937 {
20938 struct glyph *glyph, *last;
20939 Lisp_Object lgstring;
20940 int i;
20941
20942 s->for_overlaps = overlaps;
20943 glyph = s->row->glyphs[s->area] + start;
20944 last = s->row->glyphs[s->area] + end;
20945 s->cmp_id = glyph->u.cmp.id;
20946 s->cmp_from = glyph->u.cmp.from;
20947 s->cmp_to = glyph->u.cmp.to + 1;
20948 s->face = FACE_FROM_ID (s->f, face_id);
20949 lgstring = composition_gstring_from_id (s->cmp_id);
20950 s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
20951 glyph++;
20952 while (glyph < last
20953 && glyph->u.cmp.automatic
20954 && glyph->u.cmp.id == s->cmp_id
20955 && s->cmp_to == glyph->u.cmp.from)
20956 s->cmp_to = (glyph++)->u.cmp.to + 1;
20957
20958 for (i = s->cmp_from; i < s->cmp_to; i++)
20959 {
20960 Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
20961 unsigned code = LGLYPH_CODE (lglyph);
20962
20963 STORE_XCHAR2B ((s->char2b + i), code >> 8, code & 0xFF);
20964 }
20965 s->width = composition_gstring_width (lgstring, s->cmp_from, s->cmp_to, NULL);
20966 return glyph - s->row->glyphs[s->area];
20967 }
20968
20969
20970 20971 20972 20973 20974 20975 20976 20977
20978
20979 static int
20980 fill_glyph_string (s, face_id, start, end, overlaps)
20981 struct glyph_string *s;
20982 int face_id;
20983 int start, end, overlaps;
20984 {
20985 struct glyph *glyph, *last;
20986 int voffset;
20987 int glyph_not_available_p;
20988
20989 xassert (s->f == XFRAME (s->w->frame));
20990 xassert (s->nchars == 0);
20991 xassert (start >= 0 && end > start);
20992
20993 s->for_overlaps = overlaps;
20994 glyph = s->row->glyphs[s->area] + start;
20995 last = s->row->glyphs[s->area] + end;
20996 voffset = glyph->voffset;
20997 s->padding_p = glyph->padding_p;
20998 glyph_not_available_p = glyph->glyph_not_available_p;
20999
21000 while (glyph < last
21001 && glyph->type == CHAR_GLYPH
21002 && glyph->voffset == voffset
21003
21004 && glyph->face_id == face_id
21005 && glyph->glyph_not_available_p == glyph_not_available_p)
21006 {
21007 int two_byte_p;
21008
21009 s->face = get_glyph_face_and_encoding (s->f, glyph,
21010 s->char2b + s->nchars,
21011 &two_byte_p);
21012 s->two_byte_p = two_byte_p;
21013 ++s->nchars;
21014 xassert (s->nchars <= end - start);
21015 s->width += glyph->pixel_width;
21016 if (glyph++->padding_p != s->padding_p)
21017 break;
21018 }
21019
21020 s->font = s->face->font;
21021
21022 21023 21024 21025
21026 if (s->font == NULL || glyph_not_available_p)
21027 {
21028 s->font_not_found_p = 1;
21029 s->font = FRAME_FONT (s->f);
21030 }
21031
21032
21033 s->ybase += voffset;
21034
21035 xassert (s->face && s->face->gc);
21036 return glyph - s->row->glyphs[s->area];
21037 }
21038
21039
21040
21041
21042 static void
21043 fill_image_glyph_string (s)
21044 struct glyph_string *s;
21045 {
21046 xassert (s->first_glyph->type == IMAGE_GLYPH);
21047 s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
21048 xassert (s->img);
21049 s->slice = s->first_glyph->slice;
21050 s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
21051 s->font = s->face->font;
21052 s->width = s->first_glyph->pixel_width;
21053
21054
21055 s->ybase += s->first_glyph->voffset;
21056 }
21057
21058
21059 21060 21061 21062 21063 21064 21065
21066
21067 static int
21068 fill_stretch_glyph_string (s, row, area, start, end)
21069 struct glyph_string *s;
21070 struct glyph_row *row;
21071 enum glyph_row_area area;
21072 int start, end;
21073 {
21074 struct glyph *glyph, *last;
21075 int voffset, face_id;
21076
21077 xassert (s->first_glyph->type == STRETCH_GLYPH);
21078
21079 glyph = s->row->glyphs[s->area] + start;
21080 last = s->row->glyphs[s->area] + end;
21081 face_id = glyph->face_id;
21082 s->face = FACE_FROM_ID (s->f, face_id);
21083 s->font = s->face->font;
21084 s->width = glyph->pixel_width;
21085 s->nchars = 1;
21086 voffset = glyph->voffset;
21087
21088 for (++glyph;
21089 (glyph < last
21090 && glyph->type == STRETCH_GLYPH
21091 && glyph->voffset == voffset
21092 && glyph->face_id == face_id);
21093 ++glyph)
21094 s->width += glyph->pixel_width;
21095
21096
21097 s->ybase += voffset;
21098
21099 21100
21101 xassert (s->face);
21102 return glyph - s->row->glyphs[s->area];
21103 }
21104
21105 static struct font_metrics *
21106 get_per_char_metric (f, font, char2b)
21107 struct frame *f;
21108 struct font *font;
21109 XChar2b *char2b;
21110 {
21111 static struct font_metrics metrics;
21112 unsigned code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
21113
21114 if (! font || code == FONT_INVALID_CODE)
21115 return NULL;
21116 font->driver->text_extents (font, &code, 1, &metrics);
21117 return &metrics;
21118 }
21119
21120 21121 21122 21123
21124
21125 void
21126 x_get_glyph_overhangs (glyph, f, left, right)
21127 struct glyph *glyph;
21128 struct frame *f;
21129 int *left, *right;
21130 {
21131 *left = *right = 0;
21132
21133 if (glyph->type == CHAR_GLYPH)
21134 {
21135 struct face *face;
21136 XChar2b char2b;
21137 struct font_metrics *pcm;
21138
21139 face = get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
21140 if (face->font && (pcm = get_per_char_metric (f, face->font, &char2b)))
21141 {
21142 if (pcm->rbearing > pcm->width)
21143 *right = pcm->rbearing - pcm->width;
21144 if (pcm->lbearing < 0)
21145 *left = -pcm->lbearing;
21146 }
21147 }
21148 else if (glyph->type == COMPOSITE_GLYPH)
21149 {
21150 if (! glyph->u.cmp.automatic)
21151 {
21152 struct composition *cmp = composition_table[glyph->u.cmp.id];
21153
21154 if (cmp->rbearing > cmp->pixel_width)
21155 *right = cmp->rbearing - cmp->pixel_width;
21156 if (cmp->lbearing < 0)
21157 *left = - cmp->lbearing;
21158 }
21159 else
21160 {
21161 Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
21162 struct font_metrics metrics;
21163
21164 composition_gstring_width (gstring, glyph->u.cmp.from,
21165 glyph->u.cmp.to + 1, &metrics);
21166 if (metrics.rbearing > metrics.width)
21167 *right = metrics.rbearing - metrics.width;
21168 if (metrics.lbearing < 0)
21169 *left = - metrics.lbearing;
21170 }
21171 }
21172 }
21173
21174
21175 21176 21177
21178
21179 static int
21180 left_overwritten (s)
21181 struct glyph_string *s;
21182 {
21183 int k;
21184
21185 if (s->left_overhang)
21186 {
21187 int x = 0, i;
21188 struct glyph *glyphs = s->row->glyphs[s->area];
21189 int first = s->first_glyph - glyphs;
21190
21191 for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
21192 x -= glyphs[i].pixel_width;
21193
21194 k = i + 1;
21195 }
21196 else
21197 k = -1;
21198
21199 return k;
21200 }
21201
21202
21203 21204 21205
21206
21207 static int
21208 left_overwriting (s)
21209 struct glyph_string *s;
21210 {
21211 int i, k, x;
21212 struct glyph *glyphs = s->row->glyphs[s->area];
21213 int first = s->first_glyph - glyphs;
21214
21215 k = -1;
21216 x = 0;
21217 for (i = first - 1; i >= 0; --i)
21218 {
21219 int left, right;
21220 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
21221 if (x + right > 0)
21222 k = i;
21223 x -= glyphs[i].pixel_width;
21224 }
21225
21226 return k;
21227 }
21228
21229
21230 21231 21232
21233
21234 static int
21235 right_overwritten (s)
21236 struct glyph_string *s;
21237 {
21238 int k = -1;
21239
21240 if (s->right_overhang)
21241 {
21242 int x = 0, i;
21243 struct glyph *glyphs = s->row->glyphs[s->area];
21244 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
21245 int end = s->row->used[s->area];
21246
21247 for (i = first; i < end && s->right_overhang > x; ++i)
21248 x += glyphs[i].pixel_width;
21249
21250 k = i;
21251 }
21252
21253 return k;
21254 }
21255
21256
21257 21258 21259
21260
21261 static int
21262 right_overwriting (s)
21263 struct glyph_string *s;
21264 {
21265 int i, k, x;
21266 int end = s->row->used[s->area];
21267 struct glyph *glyphs = s->row->glyphs[s->area];
21268 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
21269
21270 k = -1;
21271 x = 0;
21272 for (i = first; i < end; ++i)
21273 {
21274 int left, right;
21275 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
21276 if (x - left < 0)
21277 k = i;
21278 x += glyphs[i].pixel_width;
21279 }
21280
21281 return k;
21282 }
21283
21284
21285 21286 21287
21288
21289 static INLINE void
21290 set_glyph_string_background_width (s, start, last_x)
21291 struct glyph_string *s;
21292 int start;
21293 int last_x;
21294 {
21295 21296
21297
21298 if (start == s->row->used[s->area]
21299 && s->area == TEXT_AREA
21300 && ((s->row->fill_line_p
21301 && (s->hl == DRAW_NORMAL_TEXT
21302 || s->hl == DRAW_IMAGE_RAISED
21303 || s->hl == DRAW_IMAGE_SUNKEN))
21304 || s->hl == DRAW_MOUSE_FACE))
21305 s->extends_to_end_of_line_p = 1;
21306
21307 21308 21309
21310 if (s->extends_to_end_of_line_p)
21311 s->background_width = last_x - s->x + 1;
21312 else
21313 s->background_width = s->width;
21314 }
21315
21316
21317 21318 21319
21320
21321 static void
21322 compute_overhangs_and_x (s, x, backward_p)
21323 struct glyph_string *s;
21324 int x;
21325 int backward_p;
21326 {
21327 if (backward_p)
21328 {
21329 while (s)
21330 {
21331 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
21332 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
21333 x -= s->width;
21334 s->x = x;
21335 s = s->prev;
21336 }
21337 }
21338 else
21339 {
21340 while (s)
21341 {
21342 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
21343 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
21344 s->x = x;
21345 x += s->width;
21346 s = s->next;
21347 }
21348 }
21349 }
21350
21351
21352
21353 21354 21355 21356 21357
21358
21359 #ifdef HAVE_NTGUI
21360 21361
21362 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21363 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
21364 #else
21365 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21366 init_glyph_string (s, char2b, w, row, area, start, hl)
21367 #endif
21368
21369 21370 21371 21372 21373 21374 21375
21376
21377 21378
21379 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21380 do \
21381 { \
21382 s = (struct glyph_string *) alloca (sizeof *s); \
21383 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
21384 START = fill_stretch_glyph_string (s, row, area, START, END); \
21385 append_glyph_string (&HEAD, &TAIL, s); \
21386 s->x = (X); \
21387 } \
21388 while (0)
21389
21390
21391 21392 21393 21394 21395 21396 21397
21398
21399 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21400 do \
21401 { \
21402 s = (struct glyph_string *) alloca (sizeof *s); \
21403 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
21404 fill_image_glyph_string (s); \
21405 append_glyph_string (&HEAD, &TAIL, s); \
21406 ++START; \
21407 s->x = (X); \
21408 } \
21409 while (0)
21410
21411
21412 21413 21414 21415 21416 21417 21418 21419
21420
21421 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
21422 do \
21423 { \
21424 int face_id; \
21425 XChar2b *char2b; \
21426 \
21427 face_id = (row)->glyphs[area][START].face_id; \
21428 \
21429 s = (struct glyph_string *) alloca (sizeof *s); \
21430 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
21431 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21432 append_glyph_string (&HEAD, &TAIL, s); \
21433 s->x = (X); \
21434 START = fill_glyph_string (s, face_id, START, END, overlaps); \
21435 } \
21436 while (0)
21437
21438
21439 21440 21441 21442 21443 21444 21445 21446
21447
21448 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21449 do { \
21450 int face_id = (row)->glyphs[area][START].face_id; \
21451 struct face *base_face = FACE_FROM_ID (f, face_id); \
21452 int cmp_id = (row)->glyphs[area][START].u.cmp.id; \
21453 struct composition *cmp = composition_table[cmp_id]; \
21454 XChar2b *char2b; \
21455 struct glyph_string *first_s; \
21456 int n; \
21457 \
21458 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
21459 \
21460 21461 \
21462 for (n = 0; n < cmp->glyph_len;) \
21463 { \
21464 s = (struct glyph_string *) alloca (sizeof *s); \
21465 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21466 append_glyph_string (&(HEAD), &(TAIL), s); \
21467 s->cmp = cmp; \
21468 s->cmp_from = n; \
21469 s->x = (X); \
21470 if (n == 0) \
21471 first_s = s; \
21472 n = fill_composite_glyph_string (s, base_face, overlaps); \
21473 } \
21474 \
21475 ++START; \
21476 s = first_s; \
21477 } while (0)
21478
21479
21480 21481
21482
21483 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21484 do { \
21485 int face_id; \
21486 XChar2b *char2b; \
21487 Lisp_Object gstring; \
21488 \
21489 face_id = (row)->glyphs[area][START].face_id; \
21490 gstring = (composition_gstring_from_id \
21491 ((row)->glyphs[area][START].u.cmp.id)); \
21492 s = (struct glyph_string *) alloca (sizeof *s); \
21493 char2b = (XChar2b *) alloca ((sizeof *char2b) \
21494 * LGSTRING_GLYPH_LEN (gstring)); \
21495 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21496 append_glyph_string (&(HEAD), &(TAIL), s); \
21497 s->x = (X); \
21498 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
21499 } while (0)
21500
21501
21502 21503 21504 21505 21506 21507 21508 21509 21510
21511
21512 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
21513 do \
21514 { \
21515 HEAD = TAIL = NULL; \
21516 while (START < END) \
21517 { \
21518 struct glyph *first_glyph = (row)->glyphs[area] + START; \
21519 switch (first_glyph->type) \
21520 { \
21521 case CHAR_GLYPH: \
21522 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
21523 HL, X, LAST_X); \
21524 break; \
21525 \
21526 case COMPOSITE_GLYPH: \
21527 if (first_glyph->u.cmp.automatic) \
21528 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
21529 HL, X, LAST_X); \
21530 else \
21531 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
21532 HL, X, LAST_X); \
21533 break; \
21534 \
21535 case STRETCH_GLYPH: \
21536 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
21537 HL, X, LAST_X); \
21538 break; \
21539 \
21540 case IMAGE_GLYPH: \
21541 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
21542 HL, X, LAST_X); \
21543 break; \
21544 \
21545 default: \
21546 abort (); \
21547 } \
21548 \
21549 if (s) \
21550 { \
21551 set_glyph_string_background_width (s, START, LAST_X); \
21552 (X) += s->width; \
21553 } \
21554 } \
21555 } while (0)
21556
21557
21558 21559 21560 21561 21562 21563 21564 21565 21566 21567 21568 21569 21570 21571 21572 21573 21574 21575 21576 21577 21578
21579
21580 static int
21581 draw_glyphs (w, x, row, area, start, end, hl, overlaps)
21582 struct window *w;
21583 int x;
21584 struct glyph_row *row;
21585 enum glyph_row_area area;
21586 EMACS_INT start, end;
21587 enum draw_glyphs_face hl;
21588 int overlaps;
21589 {
21590 struct glyph_string *head, *tail;
21591 struct glyph_string *s;
21592 struct glyph_string *clip_head = NULL, *clip_tail = NULL;
21593 int i, j, x_reached, last_x, area_left = 0;
21594 struct frame *f = XFRAME (WINDOW_FRAME (w));
21595 DECLARE_HDC (hdc);
21596
21597 ALLOCATE_HDC (hdc, f);
21598
21599
21600 end = min (end, row->used[area]);
21601 start = max (0, start);
21602 start = min (end, start);
21603
21604 21605
21606 if (row->full_width_p)
21607 {
21608 21609
21610 area_left = WINDOW_LEFT_EDGE_X (w);
21611 last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
21612 }
21613 else
21614 {
21615 area_left = window_box_left (w, area);
21616 last_x = area_left + window_box_width (w, area);
21617 }
21618 x += area_left;
21619
21620 21621 21622 21623
21624 i = start;
21625 BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
21626 if (tail)
21627 x_reached = tail->x + tail->background_width;
21628 else
21629 x_reached = x;
21630
21631 21632 21633
21634 if (head && !overlaps && row->contains_overlapping_glyphs_p)
21635 {
21636 struct glyph_string *h, *t;
21637 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
21638 int mouse_beg_col, mouse_end_col, check_mouse_face = 0;
21639 int dummy_x = 0;
21640
21641 21642
21643 if (area == TEXT_AREA && row->mouse_face_p)
21644 {
21645 struct glyph_row *mouse_beg_row, *mouse_end_row;
21646
21647 mouse_beg_row = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
21648 mouse_end_row = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
21649
21650 if (row >= mouse_beg_row && row <= mouse_end_row)
21651 {
21652 check_mouse_face = 1;
21653 mouse_beg_col = (row == mouse_beg_row)
21654 ? dpyinfo->mouse_face_beg_col : 0;
21655 mouse_end_col = (row == mouse_end_row)
21656 ? dpyinfo->mouse_face_end_col
21657 : row->used[TEXT_AREA];
21658 }
21659 }
21660
21661
21662 if (FRAME_RIF (f)->compute_glyph_string_overhangs)
21663 for (s = head; s; s = s->next)
21664 FRAME_RIF (f)->compute_glyph_string_overhangs (s);
21665
21666 21667 21668 21669 21670
21671 i = left_overwritten (head);
21672 if (i >= 0)
21673 {
21674 enum draw_glyphs_face overlap_hl;
21675
21676 21677 21678 21679 21680 21681 21682
21683 if (check_mouse_face
21684 && mouse_beg_col < start && mouse_end_col > i)
21685 overlap_hl = DRAW_MOUSE_FACE;
21686 else
21687 overlap_hl = DRAW_NORMAL_TEXT;
21688
21689 j = i;
21690 BUILD_GLYPH_STRINGS (j, start, h, t,
21691 overlap_hl, dummy_x, last_x);
21692 start = i;
21693 compute_overhangs_and_x (t, head->x, 1);
21694 prepend_glyph_string_lists (&head, &tail, h, t);
21695 clip_head = head;
21696 }
21697
21698 21699 21700 21701 21702 21703 21704
21705 i = left_overwriting (head);
21706 if (i >= 0)
21707 {
21708 enum draw_glyphs_face overlap_hl;
21709
21710 if (check_mouse_face
21711 && mouse_beg_col < start && mouse_end_col > i)
21712 overlap_hl = DRAW_MOUSE_FACE;
21713 else
21714 overlap_hl = DRAW_NORMAL_TEXT;
21715
21716 clip_head = head;
21717 BUILD_GLYPH_STRINGS (i, start, h, t,
21718 overlap_hl, dummy_x, last_x);
21719 for (s = h; s; s = s->next)
21720 s->background_filled_p = 1;
21721 compute_overhangs_and_x (t, head->x, 1);
21722 prepend_glyph_string_lists (&head, &tail, h, t);
21723 }
21724
21725 21726 21727 21728
21729 i = right_overwritten (tail);
21730 if (i >= 0)
21731 {
21732 enum draw_glyphs_face overlap_hl;
21733
21734 if (check_mouse_face
21735 && mouse_beg_col < i && mouse_end_col > end)
21736 overlap_hl = DRAW_MOUSE_FACE;
21737 else
21738 overlap_hl = DRAW_NORMAL_TEXT;
21739
21740 BUILD_GLYPH_STRINGS (end, i, h, t,
21741 overlap_hl, x, last_x);
21742 21743
21744 compute_overhangs_and_x (h, tail->x + tail->width, 0);
21745 append_glyph_string_lists (&head, &tail, h, t);
21746 clip_tail = tail;
21747 }
21748
21749 21750 21751 21752 21753
21754 i = right_overwriting (tail);
21755 if (i >= 0)
21756 {
21757 enum draw_glyphs_face overlap_hl;
21758 if (check_mouse_face
21759 && mouse_beg_col < i && mouse_end_col > end)
21760 overlap_hl = DRAW_MOUSE_FACE;
21761 else
21762 overlap_hl = DRAW_NORMAL_TEXT;
21763
21764 clip_tail = tail;
21765 i++;
21766 BUILD_GLYPH_STRINGS (end, i, h, t,
21767 overlap_hl, x, last_x);
21768 for (s = h; s; s = s->next)
21769 s->background_filled_p = 1;
21770 compute_overhangs_and_x (h, tail->x + tail->width, 0);
21771 append_glyph_string_lists (&head, &tail, h, t);
21772 }
21773 if (clip_head || clip_tail)
21774 for (s = head; s; s = s->next)
21775 {
21776 s->clip_head = clip_head;
21777 s->clip_tail = clip_tail;
21778 }
21779 }
21780
21781
21782 for (s = head; s; s = s->next)
21783 FRAME_RIF (f)->draw_glyph_string (s);
21784
21785 #ifndef HAVE_NS
21786 21787
21788 if (area == TEXT_AREA
21789 && !row->full_width_p
21790 21791 21792
21793 && !overlaps)
21794 {
21795 int x0 = clip_head ? clip_head->x : (head ? head->x : x);
21796 int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
21797 : (tail ? tail->x + tail->background_width : x));
21798 x0 -= area_left;
21799 x1 -= area_left;
21800
21801 notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
21802 row->y, MATRIX_ROW_BOTTOM_Y (row));
21803 }
21804 #endif
21805
21806 21807
21808 if (row->full_width_p)
21809 x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
21810 else
21811 x_reached -= area_left;
21812
21813 RELEASE_HDC (hdc, f);
21814
21815 return x_reached;
21816 }
21817
21818 21819
21820
21821 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
21822 { \
21823 if (!fonts_changed_p \
21824 && (it->glyph_row->glyphs[area] \
21825 < it->glyph_row->glyphs[area + 1])) \
21826 { \
21827 it->w->ncols_scale_factor++; \
21828 fonts_changed_p = 1; \
21829 } \
21830 }
21831
21832 21833
21834
21835 static INLINE void
21836 append_glyph (it)
21837 struct it *it;
21838 {
21839 struct glyph *glyph;
21840 enum glyph_row_area area = it->area;
21841
21842 xassert (it->glyph_row);
21843 xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
21844
21845 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
21846 if (glyph < it->glyph_row->glyphs[area + 1])
21847 {
21848 21849
21850 if (it->glyph_row->reversed_p && area == TEXT_AREA)
21851 {
21852 struct glyph *g;
21853
21854
21855 for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
21856 g[1] = *g;
21857 glyph = it->glyph_row->glyphs[area];
21858 }
21859 glyph->charpos = CHARPOS (it->position);
21860 glyph->object = it->object;
21861 if (it->pixel_width > 0)
21862 {
21863 glyph->pixel_width = it->pixel_width;
21864 glyph->padding_p = 0;
21865 }
21866 else
21867 {
21868 21869
21870 glyph->pixel_width = 1;
21871 glyph->padding_p = 1;
21872 }
21873 glyph->ascent = it->ascent;
21874 glyph->descent = it->descent;
21875 glyph->voffset = it->voffset;
21876 glyph->type = CHAR_GLYPH;
21877 glyph->avoid_cursor_p = it->avoid_cursor_p;
21878 glyph->multibyte_p = it->multibyte_p;
21879 glyph->left_box_line_p = it->start_of_box_run_p;
21880 glyph->right_box_line_p = it->end_of_box_run_p;
21881 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
21882 || it->phys_descent > it->descent);
21883 glyph->glyph_not_available_p = it->glyph_not_available_p;
21884 glyph->face_id = it->face_id;
21885 glyph->u.ch = it->char_to_display;
21886 glyph->slice = null_glyph_slice;
21887 glyph->font_type = FONT_TYPE_UNKNOWN;
21888 if (it->bidi_p)
21889 {
21890 glyph->resolved_level = it->bidi_it.resolved_level;
21891 if ((it->bidi_it.type & 7) != it->bidi_it.type)
21892 abort ();
21893 glyph->bidi_type = it->bidi_it.type;
21894 }
21895 else
21896 {
21897 glyph->resolved_level = 0;
21898 glyph->bidi_type = UNKNOWN_BT;
21899 }
21900 ++it->glyph_row->used[area];
21901 }
21902 else
21903 IT_EXPAND_MATRIX_WIDTH (it, area);
21904 }
21905
21906 21907 21908
21909
21910 static INLINE void
21911 append_composite_glyph (it)
21912 struct it *it;
21913 {
21914 struct glyph *glyph;
21915 enum glyph_row_area area = it->area;
21916
21917 xassert (it->glyph_row);
21918
21919 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
21920 if (glyph < it->glyph_row->glyphs[area + 1])
21921 {
21922 21923
21924 if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
21925 {
21926 struct glyph *g;
21927
21928
21929 for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
21930 g[1] = *g;
21931 glyph = it->glyph_row->glyphs[it->area];
21932 }
21933 glyph->charpos = it->cmp_it.charpos;
21934 glyph->object = it->object;
21935 glyph->pixel_width = it->pixel_width;
21936 glyph->ascent = it->ascent;
21937 glyph->descent = it->descent;
21938 glyph->voffset = it->voffset;
21939 glyph->type = COMPOSITE_GLYPH;
21940 if (it->cmp_it.ch < 0)
21941 {
21942 glyph->u.cmp.automatic = 0;
21943 glyph->u.cmp.id = it->cmp_it.id;
21944 }
21945 else
21946 {
21947 glyph->u.cmp.automatic = 1;
21948 glyph->u.cmp.id = it->cmp_it.id;
21949 glyph->u.cmp.from = it->cmp_it.from;
21950 glyph->u.cmp.to = it->cmp_it.to - 1;
21951 }
21952 glyph->avoid_cursor_p = it->avoid_cursor_p;
21953 glyph->multibyte_p = it->multibyte_p;
21954 glyph->left_box_line_p = it->start_of_box_run_p;
21955 glyph->right_box_line_p = it->end_of_box_run_p;
21956 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
21957 || it->phys_descent > it->descent);
21958 glyph->padding_p = 0;
21959 glyph->glyph_not_available_p = 0;
21960 glyph->face_id = it->face_id;
21961 glyph->slice = null_glyph_slice;
21962 glyph->font_type = FONT_TYPE_UNKNOWN;
21963 if (it->bidi_p)
21964 {
21965 glyph->resolved_level = it->bidi_it.resolved_level;
21966 if ((it->bidi_it.type & 7) != it->bidi_it.type)
21967 abort ();
21968 glyph->bidi_type = it->bidi_it.type;
21969 }
21970 ++it->glyph_row->used[area];
21971 }
21972 else
21973 IT_EXPAND_MATRIX_WIDTH (it, area);
21974 }
21975
21976
21977 21978
21979
21980 static INLINE void
21981 take_vertical_position_into_account (it)
21982 struct it *it;
21983 {
21984 if (it->voffset)
21985 {
21986 if (it->voffset < 0)
21987 21988
21989 it->ascent -= it->voffset;
21990 else
21991 21992
21993 it->descent += it->voffset;
21994 }
21995 }
21996
21997
21998 21999 22000
22001
22002 static void
22003 produce_image_glyph (it)
22004 struct it *it;
22005 {
22006 struct image *img;
22007 struct face *face;
22008 int glyph_ascent, crop;
22009 struct glyph_slice slice;
22010
22011 xassert (it->what == IT_IMAGE);
22012
22013 face = FACE_FROM_ID (it->f, it->face_id);
22014 xassert (face);
22015
22016 PREPARE_FACE_FOR_DISPLAY (it->f, face);
22017
22018 if (it->image_id < 0)
22019 {
22020
22021 it->ascent = it->phys_ascent = 0;
22022 it->descent = it->phys_descent = 0;
22023 it->pixel_width = 0;
22024 it->nglyphs = 0;
22025 return;
22026 }
22027
22028 img = IMAGE_FROM_ID (it->f, it->image_id);
22029 xassert (img);
22030
22031 prepare_image_for_display (it->f, img);
22032
22033 slice.x = slice.y = 0;
22034 slice.width = img->width;
22035 slice.height = img->height;
22036
22037 if (INTEGERP (it->slice.x))
22038 slice.x = XINT (it->slice.x);
22039 else if (FLOATP (it->slice.x))
22040 slice.x = XFLOAT_DATA (it->slice.x) * img->width;
22041
22042 if (INTEGERP (it->slice.y))
22043 slice.y = XINT (it->slice.y);
22044 else if (FLOATP (it->slice.y))
22045 slice.y = XFLOAT_DATA (it->slice.y) * img->height;
22046
22047 if (INTEGERP (it->slice.width))
22048 slice.width = XINT (it->slice.width);
22049 else if (FLOATP (it->slice.width))
22050 slice.width = XFLOAT_DATA (it->slice.width) * img->width;
22051
22052 if (INTEGERP (it->slice.height))
22053 slice.height = XINT (it->slice.height);
22054 else if (FLOATP (it->slice.height))
22055 slice.height = XFLOAT_DATA (it->slice.height) * img->height;
22056
22057 if (slice.x >= img->width)
22058 slice.x = img->width;
22059 if (slice.y >= img->height)
22060 slice.y = img->height;
22061 if (slice.x + slice.width >= img->width)
22062 slice.width = img->width - slice.x;
22063 if (slice.y + slice.height > img->height)
22064 slice.height = img->height - slice.y;
22065
22066 if (slice.width == 0 || slice.height == 0)
22067 return;
22068
22069 it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
22070
22071 it->descent = slice.height - glyph_ascent;
22072 if (slice.y == 0)
22073 it->descent += img->vmargin;
22074 if (slice.y + slice.height == img->height)
22075 it->descent += img->vmargin;
22076 it->phys_descent = it->descent;
22077
22078 it->pixel_width = slice.width;
22079 if (slice.x == 0)
22080 it->pixel_width += img->hmargin;
22081 if (slice.x + slice.width == img->width)
22082 it->pixel_width += img->hmargin;
22083
22084 22085
22086 if (it->descent < 0)
22087 it->descent = 0;
22088
22089 it->nglyphs = 1;
22090
22091 if (face->box != FACE_NO_BOX)
22092 {
22093 if (face->box_line_width > 0)
22094 {
22095 if (slice.y == 0)
22096 it->ascent += face->box_line_width;
22097 if (slice.y + slice.height == img->height)
22098 it->descent += face->box_line_width;
22099 }
22100
22101 if (it->start_of_box_run_p && slice.x == 0)
22102 it->pixel_width += eabs (face->box_line_width);
22103 if (it->end_of_box_run_p && slice.x + slice.width == img->width)
22104 it->pixel_width += eabs (face->box_line_width);
22105 }
22106
22107 take_vertical_position_into_account (it);
22108
22109 22110
22111 if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
22112 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
22113 {
22114 it->pixel_width -= crop;
22115 slice.width -= crop;
22116 }
22117
22118 if (it->glyph_row)
22119 {
22120 struct glyph *glyph;
22121 enum glyph_row_area area = it->area;
22122
22123 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
22124 if (glyph < it->glyph_row->glyphs[area + 1])
22125 {
22126 glyph->charpos = CHARPOS (it->position);
22127 glyph->object = it->object;
22128 glyph->pixel_width = it->pixel_width;
22129 glyph->ascent = glyph_ascent;
22130 glyph->descent = it->descent;
22131 glyph->voffset = it->voffset;
22132 glyph->type = IMAGE_GLYPH;
22133 glyph->avoid_cursor_p = it->avoid_cursor_p;
22134 glyph->multibyte_p = it->multibyte_p;
22135 glyph->left_box_line_p = it->start_of_box_run_p;
22136 glyph->right_box_line_p = it->end_of_box_run_p;
22137 glyph->overlaps_vertically_p = 0;
22138 glyph->padding_p = 0;
22139 glyph->glyph_not_available_p = 0;
22140 glyph->face_id = it->face_id;
22141 glyph->u.img_id = img->id;
22142 glyph->slice = slice;
22143 glyph->font_type = FONT_TYPE_UNKNOWN;
22144 if (it->bidi_p)
22145 {
22146 glyph->resolved_level = it->bidi_it.resolved_level;
22147 if ((it->bidi_it.type & 7) != it->bidi_it.type)
22148 abort ();
22149 glyph->bidi_type = it->bidi_it.type;
22150 }
22151 ++it->glyph_row->used[area];
22152 }
22153 else
22154 IT_EXPAND_MATRIX_WIDTH (it, area);
22155 }
22156 }
22157
22158
22159 22160 22161
22162
22163 static void
22164 append_stretch_glyph (it, object, width, height, ascent)
22165 struct it *it;
22166 Lisp_Object object;
22167 int width, height;
22168 int ascent;
22169 {
22170 struct glyph *glyph;
22171 enum glyph_row_area area = it->area;
22172
22173 xassert (ascent >= 0 && ascent <= height);
22174
22175 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
22176 if (glyph < it->glyph_row->glyphs[area + 1])
22177 {
22178 22179
22180 if (it->glyph_row->reversed_p && area == TEXT_AREA)
22181 {
22182 struct glyph *g;
22183
22184
22185 for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
22186 g[1] = *g;
22187 glyph = it->glyph_row->glyphs[area];
22188 }
22189 glyph->charpos = CHARPOS (it->position);
22190 glyph->object = object;
22191 glyph->pixel_width = width;
22192 glyph->ascent = ascent;
22193 glyph->descent = height - ascent;
22194 glyph->voffset = it->voffset;
22195 glyph->type = STRETCH_GLYPH;
22196 glyph->avoid_cursor_p = it->avoid_cursor_p;
22197 glyph->multibyte_p = it->multibyte_p;
22198 glyph->left_box_line_p = it->start_of_box_run_p;
22199 glyph->right_box_line_p = it->end_of_box_run_p;
22200 glyph->overlaps_vertically_p = 0;
22201 glyph->padding_p = 0;
22202 glyph->glyph_not_available_p = 0;
22203 glyph->face_id = it->face_id;
22204 glyph->u.stretch.ascent = ascent;
22205 glyph->u.stretch.height = height;
22206 glyph->slice = null_glyph_slice;
22207 glyph->font_type = FONT_TYPE_UNKNOWN;
22208 if (it->bidi_p)
22209 {
22210 glyph->resolved_level = it->bidi_it.resolved_level;
22211 if ((it->bidi_it.type & 7) != it->bidi_it.type)
22212 abort ();
22213 glyph->bidi_type = it->bidi_it.type;
22214 }
22215 else
22216 {
22217 glyph->resolved_level = 0;
22218 glyph->bidi_type = UNKNOWN_BT;
22219 }
22220 ++it->glyph_row->used[area];
22221 }
22222 else
22223 IT_EXPAND_MATRIX_WIDTH (it, area);
22224 }
22225
22226
22227 22228 22229 22230 22231 22232 22233 22234 22235 22236 22237 22238 22239 22240 22241 22242 22243 22244 22245 22246 22247 22248 22249 22250 22251 22252 22253 22254 22255 22256
22257
22258 static void
22259 produce_stretch_glyph (it)
22260 struct it *it;
22261 {
22262
22263 Lisp_Object prop, plist;
22264 int width = 0, height = 0, align_to = -1;
22265 int zero_width_ok_p = 0, zero_height_ok_p = 0;
22266 int ascent = 0;
22267 double tem;
22268 struct face *face = FACE_FROM_ID (it->f, it->face_id);
22269 struct font *font = face->font ? face->font : FRAME_FONT (it->f);
22270
22271 PREPARE_FACE_FOR_DISPLAY (it->f, face);
22272
22273
22274 xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
22275 plist = XCDR (it->object);
22276
22277
22278 if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
22279 && calc_pixel_width_or_height (&tem, it, prop, font, 1, 0))
22280 {
22281
22282 zero_width_ok_p = 1;
22283 width = (int)tem;
22284 }
22285 else if (prop = Fplist_get (plist, QCrelative_width),
22286 NUMVAL (prop) > 0)
22287 {
22288 22289 22290
22291 struct it it2;
22292 unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
22293
22294 it2 = *it;
22295 if (it->multibyte_p)
22296 {
22297 int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
22298 - IT_BYTEPOS (*it));
22299 it2.c = STRING_CHAR_AND_LENGTH (p, it2.len);
22300 }
22301 else
22302 it2.c = *p, it2.len = 1;
22303
22304 it2.glyph_row = NULL;
22305 it2.what = IT_CHARACTER;
22306 x_produce_glyphs (&it2);
22307 width = NUMVAL (prop) * it2.pixel_width;
22308 }
22309 else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
22310 && calc_pixel_width_or_height (&tem, it, prop, font, 1, &align_to))
22311 {
22312 if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
22313 align_to = (align_to < 0
22314 ? 0
22315 : align_to - window_box_left_offset (it->w, TEXT_AREA));
22316 else if (align_to < 0)
22317 align_to = window_box_left_offset (it->w, TEXT_AREA);
22318 width = max (0, (int)tem + align_to - it->current_x);
22319 zero_width_ok_p = 1;
22320 }
22321 else
22322
22323 width = FRAME_COLUMN_WIDTH (it->f);
22324
22325 if (width <= 0 && (width < 0 || !zero_width_ok_p))
22326 width = 1;
22327
22328
22329 if ((prop = Fplist_get (plist, QCheight), !NILP (prop))
22330 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
22331 {
22332 height = (int)tem;
22333 zero_height_ok_p = 1;
22334 }
22335 else if (prop = Fplist_get (plist, QCrelative_height),
22336 NUMVAL (prop) > 0)
22337 height = FONT_HEIGHT (font) * NUMVAL (prop);
22338 else
22339 height = FONT_HEIGHT (font);
22340
22341 if (height <= 0 && (height < 0 || !zero_height_ok_p))
22342 height = 1;
22343
22344 22345 22346
22347 if (prop = Fplist_get (plist, QCascent),
22348 NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
22349 ascent = height * NUMVAL (prop) / 100.0;
22350 else if (!NILP (prop)
22351 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
22352 ascent = min (max (0, (int)tem), height);
22353 else
22354 ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
22355
22356 if (width > 0 && it->line_wrap != TRUNCATE
22357 && it->current_x + width > it->last_visible_x)
22358 width = it->last_visible_x - it->current_x - 1;
22359
22360 if (width > 0 && height > 0 && it->glyph_row)
22361 {
22362 Lisp_Object object = it->stack[it->sp - 1].string;
22363 if (!STRINGP (object))
22364 object = it->w->buffer;
22365 append_stretch_glyph (it, object, width, height, ascent);
22366 }
22367
22368 it->pixel_width = width;
22369 it->ascent = it->phys_ascent = ascent;
22370 it->descent = it->phys_descent = height - it->ascent;
22371 it->nglyphs = width > 0 && height > 0 ? 1 : 0;
22372
22373 take_vertical_position_into_account (it);
22374 }
22375
22376 22377 22378 22379 22380 22381 22382
22383
22384
22385 static Lisp_Object
22386 calc_line_height_property (it, val, font, boff, override)
22387 struct it *it;
22388 Lisp_Object val;
22389 struct font *font;
22390 int boff, override;
22391 {
22392 Lisp_Object face_name = Qnil;
22393 int ascent, descent, height;
22394
22395 if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
22396 return val;
22397
22398 if (CONSP (val))
22399 {
22400 face_name = XCAR (val);
22401 val = XCDR (val);
22402 if (!NUMBERP (val))
22403 val = make_number (1);
22404 if (NILP (face_name))
22405 {
22406 height = it->ascent + it->descent;
22407 goto scale;
22408 }
22409 }
22410
22411 if (NILP (face_name))
22412 {
22413 font = FRAME_FONT (it->f);
22414 boff = FRAME_BASELINE_OFFSET (it->f);
22415 }
22416 else if (EQ (face_name, Qt))
22417 {
22418 override = 0;
22419 }
22420 else
22421 {
22422 int face_id;
22423 struct face *face;
22424
22425 face_id = lookup_named_face (it->f, face_name, 0);
22426 if (face_id < 0)
22427 return make_number (-1);
22428
22429 face = FACE_FROM_ID (it->f, face_id);
22430 font = face->font;
22431 if (font == NULL)
22432 return make_number (-1);
22433 boff = font->baseline_offset;
22434 if (font->vertical_centering)
22435 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22436 }
22437
22438 ascent = FONT_BASE (font) + boff;
22439 descent = FONT_DESCENT (font) - boff;
22440
22441 if (override)
22442 {
22443 it->override_ascent = ascent;
22444 it->override_descent = descent;
22445 it->override_boff = boff;
22446 }
22447
22448 height = ascent + descent;
22449
22450 scale:
22451 if (FLOATP (val))
22452 height = (int)(XFLOAT_DATA (val) * height);
22453 else if (INTEGERP (val))
22454 height *= XINT (val);
22455
22456 return make_number (height);
22457 }
22458
22459
22460 22461 22462 22463
22464
22465 void
22466 x_produce_glyphs (it)
22467 struct it *it;
22468 {
22469 int extra_line_spacing = it->extra_line_spacing;
22470
22471 it->glyph_not_available_p = 0;
22472
22473 if (it->what == IT_CHARACTER)
22474 {
22475 XChar2b char2b;
22476 struct font *font;
22477 struct face *face = FACE_FROM_ID (it->f, it->face_id);
22478 struct font_metrics *pcm;
22479 int font_not_found_p;
22480 int boff;
22481 22482 22483 22484 22485 22486 22487 22488 22489
22490 int saved_multibyte_p = it->multibyte_p;
22491
22492 22493
22494 it->char_to_display = it->c;
22495 if (!ASCII_BYTE_P (it->c)
22496 && ! it->multibyte_p)
22497 {
22498 if (SINGLE_BYTE_CHAR_P (it->c)
22499 && unibyte_display_via_language_environment)
22500 {
22501 struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
22502
22503 22504
22505 it->char_to_display = DECODE_CHAR (unibyte, it->c);
22506 it->multibyte_p = 1;
22507 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display,
22508 -1, Qnil);
22509 face = FACE_FROM_ID (it->f, it->face_id);
22510 }
22511 }
22512
22513
22514 get_char_face_and_encoding (it->f, it->char_to_display, it->face_id,
22515 &char2b, it->multibyte_p, 0);
22516 font = face->font;
22517
22518 font_not_found_p = font == NULL;
22519 if (font_not_found_p)
22520 {
22521 22522 22523
22524 struct face *no_font_face
22525 = FACE_FROM_ID (it->f,
22526 NILP (Vface_remapping_alist) ? DEFAULT_FACE_ID
22527 : lookup_basic_face (it->f, DEFAULT_FACE_ID));
22528 font = no_font_face->font;
22529 boff = font->baseline_offset;
22530 }
22531 else
22532 {
22533 boff = font->baseline_offset;
22534 if (font->vertical_centering)
22535 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22536 }
22537
22538 if (it->char_to_display >= ' '
22539 && (!it->multibyte_p || it->char_to_display < 128))
22540 {
22541
22542 int stretched_p;
22543
22544 it->nglyphs = 1;
22545
22546 pcm = get_per_char_metric (it->f, font, &char2b);
22547
22548 if (it->override_ascent >= 0)
22549 {
22550 it->ascent = it->override_ascent;
22551 it->descent = it->override_descent;
22552 boff = it->override_boff;
22553 }
22554 else
22555 {
22556 it->ascent = FONT_BASE (font) + boff;
22557 it->descent = FONT_DESCENT (font) - boff;
22558 }
22559
22560 if (pcm)
22561 {
22562 it->phys_ascent = pcm->ascent + boff;
22563 it->phys_descent = pcm->descent - boff;
22564 it->pixel_width = pcm->width;
22565 }
22566 else
22567 {
22568 it->glyph_not_available_p = 1;
22569 it->phys_ascent = it->ascent;
22570 it->phys_descent = it->descent;
22571 it->pixel_width = FONT_WIDTH (font);
22572 }
22573
22574 if (it->constrain_row_ascent_descent_p)
22575 {
22576 if (it->descent > it->max_descent)
22577 {
22578 it->ascent += it->descent - it->max_descent;
22579 it->descent = it->max_descent;
22580 }
22581 if (it->ascent > it->max_ascent)
22582 {
22583 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
22584 it->ascent = it->max_ascent;
22585 }
22586 it->phys_ascent = min (it->phys_ascent, it->ascent);
22587 it->phys_descent = min (it->phys_descent, it->descent);
22588 extra_line_spacing = 0;
22589 }
22590
22591 22592
22593 stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
22594 if (stretched_p)
22595 it->pixel_width *= XFLOATINT (it->space_width);
22596
22597 22598 22599
22600 if (face->box != FACE_NO_BOX)
22601 {
22602 int thick = face->box_line_width;
22603
22604 if (thick > 0)
22605 {
22606 it->ascent += thick;
22607 it->descent += thick;
22608 }
22609 else
22610 thick = -thick;
22611
22612 if (it->start_of_box_run_p)
22613 it->pixel_width += thick;
22614 if (it->end_of_box_run_p)
22615 it->pixel_width += thick;
22616 }
22617
22618 22619
22620 if (face->overline_p)
22621 it->ascent += overline_margin;
22622
22623 if (it->constrain_row_ascent_descent_p)
22624 {
22625 if (it->ascent > it->max_ascent)
22626 it->ascent = it->max_ascent;
22627 if (it->descent > it->max_descent)
22628 it->descent = it->max_descent;
22629 }
22630
22631 take_vertical_position_into_account (it);
22632
22633
22634 if (it->glyph_row)
22635 {
22636 if (stretched_p)
22637 {
22638 22639
22640 int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
22641 / FONT_HEIGHT (font));
22642 append_stretch_glyph (it, it->object, it->pixel_width,
22643 it->ascent + it->descent, ascent);
22644 }
22645 else
22646 append_glyph (it);
22647
22648 22649 22650
22651 if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
22652 it->glyph_row->contains_overlapping_glyphs_p = 1;
22653 }
22654 if (! stretched_p && it->pixel_width == 0)
22655 22656
22657 it->pixel_width = 1;
22658 }
22659 else if (it->char_to_display == '\n')
22660 {
22661 22662 22663
22664
22665 Lisp_Object height;
22666 Lisp_Object total_height = Qnil;
22667
22668 it->override_ascent = -1;
22669 it->pixel_width = 0;
22670 it->nglyphs = 0;
22671
22672 height = get_it_property(it, Qline_height);
22673
22674 if (CONSP (height)
22675 && CONSP (XCDR (height))
22676 && NILP (XCDR (XCDR (height))))
22677 {
22678 total_height = XCAR (XCDR (height));
22679 height = XCAR (height);
22680 }
22681 height = calc_line_height_property(it, height, font, boff, 1);
22682
22683 if (it->override_ascent >= 0)
22684 {
22685 it->ascent = it->override_ascent;
22686 it->descent = it->override_descent;
22687 boff = it->override_boff;
22688 }
22689 else
22690 {
22691 it->ascent = FONT_BASE (font) + boff;
22692 it->descent = FONT_DESCENT (font) - boff;
22693 }
22694
22695 if (EQ (height, Qt))
22696 {
22697 if (it->descent > it->max_descent)
22698 {
22699 it->ascent += it->descent - it->max_descent;
22700 it->descent = it->max_descent;
22701 }
22702 if (it->ascent > it->max_ascent)
22703 {
22704 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
22705 it->ascent = it->max_ascent;
22706 }
22707 it->phys_ascent = min (it->phys_ascent, it->ascent);
22708 it->phys_descent = min (it->phys_descent, it->descent);
22709 it->constrain_row_ascent_descent_p = 1;
22710 extra_line_spacing = 0;
22711 }
22712 else
22713 {
22714 Lisp_Object spacing;
22715
22716 it->phys_ascent = it->ascent;
22717 it->phys_descent = it->descent;
22718
22719 if ((it->max_ascent > 0 || it->max_descent > 0)
22720 && face->box != FACE_NO_BOX
22721 && face->box_line_width > 0)
22722 {
22723 it->ascent += face->box_line_width;
22724 it->descent += face->box_line_width;
22725 }
22726 if (!NILP (height)
22727 && XINT (height) > it->ascent + it->descent)
22728 it->ascent = XINT (height) - it->descent;
22729
22730 if (!NILP (total_height))
22731 spacing = calc_line_height_property(it, total_height, font, boff, 0);
22732 else
22733 {
22734 spacing = get_it_property(it, Qline_spacing);
22735 spacing = calc_line_height_property(it, spacing, font, boff, 0);
22736 }
22737 if (INTEGERP (spacing))
22738 {
22739 extra_line_spacing = XINT (spacing);
22740 if (!NILP (total_height))
22741 extra_line_spacing -= (it->phys_ascent + it->phys_descent);
22742 }
22743 }
22744 }
22745 else if (it->char_to_display == '\t')
22746 {
22747 if (font->space_width > 0)
22748 {
22749 int tab_width = it->tab_width * font->space_width;
22750 int x = it->current_x + it->continuation_lines_width;
22751 int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
22752
22753 22754 22755
22756 if (next_tab_x - x < font->space_width)
22757 next_tab_x += tab_width;
22758
22759 it->pixel_width = next_tab_x - x;
22760 it->nglyphs = 1;
22761 it->ascent = it->phys_ascent = FONT_BASE (font) + boff;
22762 it->descent = it->phys_descent = FONT_DESCENT (font) - boff;
22763
22764 if (it->glyph_row)
22765 {
22766 append_stretch_glyph (it, it->object, it->pixel_width,
22767 it->ascent + it->descent, it->ascent);
22768 }
22769 }
22770 else
22771 {
22772 it->pixel_width = 0;
22773 it->nglyphs = 1;
22774 }
22775 }
22776 else
22777 {
22778 22779 22780
22781
22782 22783 22784 22785 22786
22787
22788 pcm = get_per_char_metric (it->f, font, &char2b);
22789
22790 if (font_not_found_p || !pcm)
22791 {
22792 int char_width = CHAR_WIDTH (it->char_to_display);
22793
22794 if (char_width == 0)
22795 22796 22797
22798 char_width = 1;
22799 it->glyph_not_available_p = 1;
22800 it->pixel_width = font->space_width * char_width;
22801 it->phys_ascent = FONT_BASE (font) + boff;
22802 it->phys_descent = FONT_DESCENT (font) - boff;
22803 }
22804 else
22805 {
22806 it->pixel_width = pcm->width;
22807 it->phys_ascent = pcm->ascent + boff;
22808 it->phys_descent = pcm->descent - boff;
22809 if (it->glyph_row
22810 && (pcm->lbearing < 0
22811 || pcm->rbearing > pcm->width))
22812 it->glyph_row->contains_overlapping_glyphs_p = 1;
22813 }
22814 it->nglyphs = 1;
22815 it->ascent = FONT_BASE (font) + boff;
22816 it->descent = FONT_DESCENT (font) - boff;
22817 if (face->box != FACE_NO_BOX)
22818 {
22819 int thick = face->box_line_width;
22820
22821 if (thick > 0)
22822 {
22823 it->ascent += thick;
22824 it->descent += thick;
22825 }
22826 else
22827 thick = - thick;
22828
22829 if (it->start_of_box_run_p)
22830 it->pixel_width += thick;
22831 if (it->end_of_box_run_p)
22832 it->pixel_width += thick;
22833 }
22834
22835 22836
22837 if (face->overline_p)
22838 it->ascent += overline_margin;
22839
22840 take_vertical_position_into_account (it);
22841
22842 if (it->ascent < 0)
22843 it->ascent = 0;
22844 if (it->descent < 0)
22845 it->descent = 0;
22846
22847 if (it->glyph_row)
22848 append_glyph (it);
22849 if (it->pixel_width == 0)
22850 22851
22852 it->pixel_width = 1;
22853 }
22854 it->multibyte_p = saved_multibyte_p;
22855 }
22856 else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
22857 {
22858 22859 22860 22861 22862 22863 22864 22865
22866 struct face *face = FACE_FROM_ID (it->f, it->face_id);
22867 int boff;
22868 struct composition *cmp = composition_table[it->cmp_it.id];
22869 int glyph_len = cmp->glyph_len;
22870 struct font *font = face->font;
22871
22872 it->nglyphs = 1;
22873
22874 22875 22876 22877 22878 22879 22880
22881 if (! cmp->font || cmp->font != font)
22882 {
22883 22884 22885 22886
22887 int font_ascent, font_descent, font_height;
22888
22889 int leftmost, rightmost, lowest, highest;
22890 int lbearing, rbearing;
22891 int i, width, ascent, descent;
22892 int left_padded = 0, right_padded = 0;
22893 int c;
22894 XChar2b char2b;
22895 struct font_metrics *pcm;
22896 int font_not_found_p;
22897 int pos;
22898
22899 for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--)
22900 if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t')
22901 break;
22902 if (glyph_len < cmp->glyph_len)
22903 right_padded = 1;
22904 for (i = 0; i < glyph_len; i++)
22905 {
22906 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
22907 break;
22908 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
22909 }
22910 if (i > 0)
22911 left_padded = 1;
22912
22913 pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
22914 : IT_CHARPOS (*it));
22915
22916 font_not_found_p = font == NULL;
22917 if (font_not_found_p)
22918 {
22919 face = face->ascii_face;
22920 font = face->font;
22921 }
22922 boff = font->baseline_offset;
22923 if (font->vertical_centering)
22924 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22925 font_ascent = FONT_BASE (font) + boff;
22926 font_descent = FONT_DESCENT (font) - boff;
22927 font_height = FONT_HEIGHT (font);
22928
22929 cmp->font = (void *) font;
22930
22931 pcm = NULL;
22932 if (! font_not_found_p)
22933 {
22934 get_char_face_and_encoding (it->f, c, it->face_id,
22935 &char2b, it->multibyte_p, 0);
22936 pcm = get_per_char_metric (it->f, font, &char2b);
22937 }
22938
22939
22940 if (pcm)
22941 {
22942 width = pcm->width;
22943 ascent = pcm->ascent;
22944 descent = pcm->descent;
22945 lbearing = pcm->lbearing;
22946 rbearing = pcm->rbearing;
22947 }
22948 else
22949 {
22950 width = FONT_WIDTH (font);
22951 ascent = FONT_BASE (font);
22952 descent = FONT_DESCENT (font);
22953 lbearing = 0;
22954 rbearing = width;
22955 }
22956
22957 rightmost = width;
22958 leftmost = 0;
22959 lowest = - descent + boff;
22960 highest = ascent + boff;
22961
22962 if (! font_not_found_p
22963 && font->default_ascent
22964 && CHAR_TABLE_P (Vuse_default_ascent)
22965 && !NILP (Faref (Vuse_default_ascent,
22966 make_number (it->char_to_display))))
22967 highest = font->default_ascent + boff;
22968
22969 22970 22971
22972 cmp->offsets[i * 2] = 0;
22973 cmp->offsets[i * 2 + 1] = boff;
22974 cmp->lbearing = lbearing;
22975 cmp->rbearing = rbearing;
22976
22977
22978 for (i++; i < glyph_len; i++)
22979 {
22980 int left, right, btm, top;
22981 int ch = COMPOSITION_GLYPH (cmp, i);
22982 int face_id;
22983 struct face *this_face;
22984 int this_boff;
22985
22986 if (ch == '\t')
22987 ch = ' ';
22988 face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
22989 this_face = FACE_FROM_ID (it->f, face_id);
22990 font = this_face->font;
22991
22992 if (font == NULL)
22993 pcm = NULL;
22994 else
22995 {
22996 this_boff = font->baseline_offset;
22997 if (font->vertical_centering)
22998 this_boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22999 get_char_face_and_encoding (it->f, ch, face_id,
23000 &char2b, it->multibyte_p, 0);
23001 pcm = get_per_char_metric (it->f, font, &char2b);
23002 }
23003 if (! pcm)
23004 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
23005 else
23006 {
23007 width = pcm->width;
23008 ascent = pcm->ascent;
23009 descent = pcm->descent;
23010 lbearing = pcm->lbearing;
23011 rbearing = pcm->rbearing;
23012 if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
23013 {
23014 23015
23016 left = (leftmost + rightmost - width) / 2;
23017 btm = - descent + boff;
23018 if (font->relative_compose
23019 && (! CHAR_TABLE_P (Vignore_relative_composition)
23020 || NILP (Faref (Vignore_relative_composition,
23021 make_number (ch)))))
23022 {
23023
23024 if (- descent >= font->relative_compose)
23025
23026 btm = highest + 1;
23027 else if (ascent <= 0)
23028
23029 btm = lowest - 1 - ascent - descent;
23030 }
23031 }
23032 else
23033 {
23034 23035 23036 23037 23038 23039 23040 23041 23042 23043 23044 23045 23046 23047 23048
23049 int rule = COMPOSITION_RULE (cmp, i);
23050 int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
23051
23052 COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
23053 grefx = gref % 3, nrefx = nref % 3;
23054 grefy = gref / 3, nrefy = nref / 3;
23055 if (xoff)
23056 xoff = font_height * (xoff - 128) / 256;
23057 if (yoff)
23058 yoff = font_height * (yoff - 128) / 256;
23059
23060 left = (leftmost
23061 + grefx * (rightmost - leftmost) / 2
23062 - nrefx * width / 2
23063 + xoff);
23064
23065 btm = ((grefy == 0 ? highest
23066 : grefy == 1 ? 0
23067 : grefy == 2 ? lowest
23068 : (highest + lowest) / 2)
23069 - (nrefy == 0 ? ascent + descent
23070 : nrefy == 1 ? descent - boff
23071 : nrefy == 2 ? 0
23072 : (ascent + descent) / 2)
23073 + yoff);
23074 }
23075
23076 cmp->offsets[i * 2] = left;
23077 cmp->offsets[i * 2 + 1] = btm + descent;
23078
23079
23080 if (width > 0)
23081 {
23082 right = left + width;
23083 if (left < leftmost)
23084 leftmost = left;
23085 if (right > rightmost)
23086 rightmost = right;
23087 }
23088 top = btm + descent + ascent;
23089 if (top > highest)
23090 highest = top;
23091 if (btm < lowest)
23092 lowest = btm;
23093
23094 if (cmp->lbearing > left + lbearing)
23095 cmp->lbearing = left + lbearing;
23096 if (cmp->rbearing < left + rbearing)
23097 cmp->rbearing = left + rbearing;
23098 }
23099 }
23100
23101 23102 23103
23104 if (leftmost < 0)
23105 {
23106 for (i = 0; i < cmp->glyph_len; i++)
23107 cmp->offsets[i * 2] -= leftmost;
23108 rightmost -= leftmost;
23109 cmp->lbearing -= leftmost;
23110 cmp->rbearing -= leftmost;
23111 }
23112
23113 if (left_padded && cmp->lbearing < 0)
23114 {
23115 for (i = 0; i < cmp->glyph_len; i++)
23116 cmp->offsets[i * 2] -= cmp->lbearing;
23117 rightmost -= cmp->lbearing;
23118 cmp->rbearing -= cmp->lbearing;
23119 cmp->lbearing = 0;
23120 }
23121 if (right_padded && rightmost < cmp->rbearing)
23122 {
23123 rightmost = cmp->rbearing;
23124 }
23125
23126 cmp->pixel_width = rightmost;
23127 cmp->ascent = highest;
23128 cmp->descent = - lowest;
23129 if (cmp->ascent < font_ascent)
23130 cmp->ascent = font_ascent;
23131 if (cmp->descent < font_descent)
23132 cmp->descent = font_descent;
23133 }
23134
23135 if (it->glyph_row
23136 && (cmp->lbearing < 0
23137 || cmp->rbearing > cmp->pixel_width))
23138 it->glyph_row->contains_overlapping_glyphs_p = 1;
23139
23140 it->pixel_width = cmp->pixel_width;
23141 it->ascent = it->phys_ascent = cmp->ascent;
23142 it->descent = it->phys_descent = cmp->descent;
23143 if (face->box != FACE_NO_BOX)
23144 {
23145 int thick = face->box_line_width;
23146
23147 if (thick > 0)
23148 {
23149 it->ascent += thick;
23150 it->descent += thick;
23151 }
23152 else
23153 thick = - thick;
23154
23155 if (it->start_of_box_run_p)
23156 it->pixel_width += thick;
23157 if (it->end_of_box_run_p)
23158 it->pixel_width += thick;
23159 }
23160
23161 23162
23163 if (face->overline_p)
23164 it->ascent += overline_margin;
23165
23166 take_vertical_position_into_account (it);
23167 if (it->ascent < 0)
23168 it->ascent = 0;
23169 if (it->descent < 0)
23170 it->descent = 0;
23171
23172 if (it->glyph_row)
23173 append_composite_glyph (it);
23174 }
23175 else if (it->what == IT_COMPOSITION)
23176 {
23177
23178 struct face *face = FACE_FROM_ID (it->f, it->face_id);
23179 Lisp_Object gstring;
23180 struct font_metrics metrics;
23181
23182 gstring = composition_gstring_from_id (it->cmp_it.id);
23183 it->pixel_width
23184 = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
23185 &metrics);
23186 if (it->glyph_row
23187 && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
23188 it->glyph_row->contains_overlapping_glyphs_p = 1;
23189 it->ascent = it->phys_ascent = metrics.ascent;
23190 it->descent = it->phys_descent = metrics.descent;
23191 if (face->box != FACE_NO_BOX)
23192 {
23193 int thick = face->box_line_width;
23194
23195 if (thick > 0)
23196 {
23197 it->ascent += thick;
23198 it->descent += thick;
23199 }
23200 else
23201 thick = - thick;
23202
23203 if (it->start_of_box_run_p)
23204 it->pixel_width += thick;
23205 if (it->end_of_box_run_p)
23206 it->pixel_width += thick;
23207 }
23208 23209
23210 if (face->overline_p)
23211 it->ascent += overline_margin;
23212 take_vertical_position_into_account (it);
23213 if (it->ascent < 0)
23214 it->ascent = 0;
23215 if (it->descent < 0)
23216 it->descent = 0;
23217
23218 if (it->glyph_row)
23219 append_composite_glyph (it);
23220 }
23221 else if (it->what == IT_IMAGE)
23222 produce_image_glyph (it);
23223 else if (it->what == IT_STRETCH)
23224 produce_stretch_glyph (it);
23225
23226 23227
23228 xassert (it->ascent >= 0 && it->descent >= 0);
23229 if (it->area == TEXT_AREA)
23230 it->current_x += it->pixel_width;
23231
23232 if (extra_line_spacing > 0)
23233 {
23234 it->descent += extra_line_spacing;
23235 if (extra_line_spacing > it->max_extra_line_spacing)
23236 it->max_extra_line_spacing = extra_line_spacing;
23237 }
23238
23239 it->max_ascent = max (it->max_ascent, it->ascent);
23240 it->max_descent = max (it->max_descent, it->descent);
23241 it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
23242 it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
23243 }
23244
23245 23246 23247 23248 23249 23250
23251
23252 void
23253 x_write_glyphs (start, len)
23254 struct glyph *start;
23255 int len;
23256 {
23257 int x, hpos;
23258
23259 xassert (updated_window && updated_row);
23260 BLOCK_INPUT;
23261
23262
23263
23264 hpos = start - updated_row->glyphs[updated_area];
23265 x = draw_glyphs (updated_window, output_cursor.x,
23266 updated_row, updated_area,
23267 hpos, hpos + len,
23268 DRAW_NORMAL_TEXT, 0);
23269
23270
23271 if (updated_area == TEXT_AREA
23272 && updated_window->phys_cursor_on_p
23273 && updated_window->phys_cursor.vpos == output_cursor.vpos
23274 && updated_window->phys_cursor.hpos >= hpos
23275 && updated_window->phys_cursor.hpos < hpos + len)
23276 updated_window->phys_cursor_on_p = 0;
23277
23278 UNBLOCK_INPUT;
23279
23280
23281 output_cursor.hpos += len;
23282 output_cursor.x = x;
23283 }
23284
23285
23286 23287
23288
23289 void
23290 x_insert_glyphs (start, len)
23291 struct glyph *start;
23292 int len;
23293 {
23294 struct frame *f;
23295 struct window *w;
23296 int line_height, shift_by_width, shifted_region_width;
23297 struct glyph_row *row;
23298 struct glyph *glyph;
23299 int frame_x, frame_y;
23300 EMACS_INT hpos;
23301
23302 xassert (updated_window && updated_row);
23303 BLOCK_INPUT;
23304 w = updated_window;
23305 f = XFRAME (WINDOW_FRAME (w));
23306
23307
23308 row = updated_row;
23309 line_height = row->height;
23310
23311
23312 shift_by_width = 0;
23313 for (glyph = start; glyph < start + len; ++glyph)
23314 shift_by_width += glyph->pixel_width;
23315
23316
23317 shifted_region_width = (window_box_width (w, updated_area)
23318 - output_cursor.x
23319 - shift_by_width);
23320
23321
23322 frame_x = window_box_left (w, updated_area) + output_cursor.x;
23323 frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
23324
23325 FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
23326 line_height, shift_by_width);
23327
23328
23329 hpos = start - row->glyphs[updated_area];
23330 draw_glyphs (w, output_cursor.x, row, updated_area,
23331 hpos, hpos + len,
23332 DRAW_NORMAL_TEXT, 0);
23333
23334
23335 output_cursor.hpos += len;
23336 output_cursor.x += shift_by_width;
23337 UNBLOCK_INPUT;
23338 }
23339
23340
23341 23342 23343 23344 23345 23346 23347
23348
23349 void
23350 x_clear_end_of_line (to_x)
23351 int to_x;
23352 {
23353 struct frame *f;
23354 struct window *w = updated_window;
23355 int max_x, min_y, max_y;
23356 int from_x, from_y, to_y;
23357
23358 xassert (updated_window && updated_row);
23359 f = XFRAME (w->frame);
23360
23361 if (updated_row->full_width_p)
23362 max_x = WINDOW_TOTAL_WIDTH (w);
23363 else
23364 max_x = window_box_width (w, updated_area);
23365 max_y = window_text_bottom_y (w);
23366
23367 23368
23369 if (to_x == 0)
23370 return;
23371 else if (to_x < 0)
23372 to_x = max_x;
23373 else
23374 to_x = min (to_x, max_x);
23375
23376 to_y = min (max_y, output_cursor.y + updated_row->height);
23377
23378
23379 if (!updated_row->full_width_p)
23380 notice_overwritten_cursor (w, updated_area,
23381 output_cursor.x, -1,
23382 updated_row->y,
23383 MATRIX_ROW_BOTTOM_Y (updated_row));
23384
23385 from_x = output_cursor.x;
23386
23387
23388 if (updated_row->full_width_p)
23389 {
23390 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
23391 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
23392 }
23393 else
23394 {
23395 int area_left = window_box_left (w, updated_area);
23396 from_x += area_left;
23397 to_x += area_left;
23398 }
23399
23400 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
23401 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
23402 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
23403
23404
23405 if (to_x > from_x && to_y > from_y)
23406 {
23407 BLOCK_INPUT;
23408 FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
23409 to_x - from_x, to_y - from_y);
23410 UNBLOCK_INPUT;
23411 }
23412 }
23413
23414 #endif
23415
23416
23417
23418 23419 23420
23421
23422 23423 23424
23425
23426 static enum text_cursor_kinds
23427 get_specified_cursor_type (arg, width)
23428 Lisp_Object arg;
23429 int *width;
23430 {
23431 enum text_cursor_kinds type;
23432
23433 if (NILP (arg))
23434 return NO_CURSOR;
23435
23436 if (EQ (arg, Qbox))
23437 return FILLED_BOX_CURSOR;
23438
23439 if (EQ (arg, Qhollow))
23440 return HOLLOW_BOX_CURSOR;
23441
23442 if (EQ (arg, Qbar))
23443 {
23444 *width = 2;
23445 return BAR_CURSOR;
23446 }
23447
23448 if (CONSP (arg)
23449 && EQ (XCAR (arg), Qbar)
23450 && INTEGERP (XCDR (arg))
23451 && XINT (XCDR (arg)) >= 0)
23452 {
23453 *width = XINT (XCDR (arg));
23454 return BAR_CURSOR;
23455 }
23456
23457 if (EQ (arg, Qhbar))
23458 {
23459 *width = 2;
23460 return HBAR_CURSOR;
23461 }
23462
23463 if (CONSP (arg)
23464 && EQ (XCAR (arg), Qhbar)
23465 && INTEGERP (XCDR (arg))
23466 && XINT (XCDR (arg)) >= 0)
23467 {
23468 *width = XINT (XCDR (arg));
23469 return HBAR_CURSOR;
23470 }
23471
23472 23473 23474
23475 type = HOLLOW_BOX_CURSOR;
23476
23477 return type;
23478 }
23479
23480
23481 void
23482 set_frame_cursor_types (f, arg)
23483 struct frame *f;
23484 Lisp_Object arg;
23485 {
23486 int width;
23487 Lisp_Object tem;
23488
23489 FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
23490 FRAME_CURSOR_WIDTH (f) = width;
23491
23492
23493
23494 tem = Fassoc (arg, Vblink_cursor_alist);
23495 if (!NILP (tem))
23496 {
23497 FRAME_BLINK_OFF_CURSOR (f)
23498 = get_specified_cursor_type (XCDR (tem), &width);
23499 FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
23500 }
23501 else
23502 FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
23503 }
23504
23505
23506 23507 23508 23509 23510 23511 23512 23513 23514 23515
23516
23517 static enum text_cursor_kinds
23518 get_window_cursor_type (w, glyph, width, active_cursor)
23519 struct window *w;
23520 struct glyph *glyph;
23521 int *width;
23522 int *active_cursor;
23523 {
23524 struct frame *f = XFRAME (w->frame);
23525 struct buffer *b = XBUFFER (w->buffer);
23526 int cursor_type = DEFAULT_CURSOR;
23527 Lisp_Object alt_cursor;
23528 int non_selected = 0;
23529
23530 *active_cursor = 1;
23531
23532
23533 if (cursor_in_echo_area
23534 && FRAME_HAS_MINIBUF_P (f)
23535 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
23536 {
23537 if (w == XWINDOW (echo_area_window))
23538 {
23539 if (EQ (b->cursor_type, Qt) || NILP (b->cursor_type))
23540 {
23541 *width = FRAME_CURSOR_WIDTH (f);
23542 return FRAME_DESIRED_CURSOR (f);
23543 }
23544 else
23545 return get_specified_cursor_type (b->cursor_type, width);
23546 }
23547
23548 *active_cursor = 0;
23549 non_selected = 1;
23550 }
23551
23552
23553 else if (w != XWINDOW (f->selected_window)
23554 #ifdef HAVE_WINDOW_SYSTEM
23555 || f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
23556 #endif
23557 )
23558 {
23559 *active_cursor = 0;
23560
23561 if (MINI_WINDOW_P (w) && minibuf_level == 0)
23562 return NO_CURSOR;
23563
23564 non_selected = 1;
23565 }
23566
23567
23568 if (NILP (b->cursor_type))
23569 return NO_CURSOR;
23570
23571
23572 if (EQ (b->cursor_type, Qt))
23573 {
23574 cursor_type = FRAME_DESIRED_CURSOR (f);
23575 *width = FRAME_CURSOR_WIDTH (f);
23576 }
23577 else
23578 cursor_type = get_specified_cursor_type (b->cursor_type, width);
23579
23580 23581
23582 if (non_selected)
23583 {
23584 alt_cursor = b->cursor_in_non_selected_windows;
23585 if (!EQ (Qt, alt_cursor))
23586 return get_specified_cursor_type (alt_cursor, width);
23587
23588 if (cursor_type == FILLED_BOX_CURSOR)
23589 cursor_type = HOLLOW_BOX_CURSOR;
23590 else if (cursor_type == BAR_CURSOR && *width > 1)
23591 --*width;
23592 return cursor_type;
23593 }
23594
23595
23596 if (!w->cursor_off_p)
23597 {
23598 #ifdef HAVE_WINDOW_SYSTEM
23599 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
23600 {
23601 if (cursor_type == FILLED_BOX_CURSOR)
23602 {
23603 23604 23605
23606 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
23607 if (img != NULL && IMAGEP (img->spec))
23608 {
23609 23610 23611
23612 if (!img->mask
23613 || img->width > max (32, WINDOW_FRAME_COLUMN_WIDTH (w))
23614 || img->height > max (32, WINDOW_FRAME_LINE_HEIGHT (w)))
23615 cursor_type = HOLLOW_BOX_CURSOR;
23616 }
23617 }
23618 else if (cursor_type != NO_CURSOR)
23619 {
23620 23621 23622
23623 cursor_type = HOLLOW_BOX_CURSOR;
23624 }
23625 }
23626 #endif
23627 return cursor_type;
23628 }
23629
23630
23631
23632
23633 if ((alt_cursor = Fassoc (b->cursor_type, Vblink_cursor_alist), !NILP (alt_cursor)))
23634 return get_specified_cursor_type (XCDR (alt_cursor), width);
23635
23636
23637 if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
23638 {
23639 *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
23640 return FRAME_BLINK_OFF_CURSOR (f);
23641 }
23642
23643 #if 0
23644 23645 23646
23647
23648 23649 23650 23651 23652
23653
23654 if (cursor_type == FILLED_BOX_CURSOR)
23655 return HOLLOW_BOX_CURSOR;
23656
23657 if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
23658 {
23659 *width = 1;
23660 return cursor_type;
23661 }
23662 #endif
23663
23664 return NO_CURSOR;
23665 }
23666
23667
23668 #ifdef HAVE_WINDOW_SYSTEM
23669
23670 23671 23672 23673 23674 23675
23676
23677 static void
23678 notice_overwritten_cursor (w, area, x0, x1, y0, y1)
23679 struct window *w;
23680 enum glyph_row_area area;
23681 int x0, y0, x1, y1;
23682 {
23683 int cx0, cx1, cy0, cy1;
23684 struct glyph_row *row;
23685
23686 if (!w->phys_cursor_on_p)
23687 return;
23688 if (area != TEXT_AREA)
23689 return;
23690
23691 if (w->phys_cursor.vpos < 0
23692 || w->phys_cursor.vpos >= w->current_matrix->nrows
23693 || (row = w->current_matrix->rows + w->phys_cursor.vpos,
23694 !(row->enabled_p && row->displays_text_p)))
23695 return;
23696
23697 if (row->cursor_in_fringe_p)
23698 {
23699 row->cursor_in_fringe_p = 0;
23700 draw_fringe_bitmap (w, row, row->reversed_p);
23701 w->phys_cursor_on_p = 0;
23702 return;
23703 }
23704
23705 cx0 = w->phys_cursor.x;
23706 cx1 = cx0 + w->phys_cursor_width;
23707 if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
23708 return;
23709
23710 23711 23712 23713 23714 23715 23716 23717 23718 23719 23720 23721 23722 23723 23724
23725
23726 cy0 = w->phys_cursor.y;
23727 cy1 = cy0 + w->phys_cursor_height;
23728 if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
23729 return;
23730
23731 w->phys_cursor_on_p = 0;
23732 }
23733
23734 #endif
23735
23736
23737 23738 23739
23740
23741 #ifdef HAVE_WINDOW_SYSTEM
23742
23743 23744 23745
23746
23747 void
23748 x_fix_overlapping_area (w, row, area, overlaps)
23749 struct window *w;
23750 struct glyph_row *row;
23751 enum glyph_row_area area;
23752 int overlaps;
23753 {
23754 int i, x;
23755
23756 BLOCK_INPUT;
23757
23758 x = 0;
23759 for (i = 0; i < row->used[area];)
23760 {
23761 if (row->glyphs[area][i].overlaps_vertically_p)
23762 {
23763 int start = i, start_x = x;
23764
23765 do
23766 {
23767 x += row->glyphs[area][i].pixel_width;
23768 ++i;
23769 }
23770 while (i < row->used[area]
23771 && row->glyphs[area][i].overlaps_vertically_p);
23772
23773 draw_glyphs (w, start_x, row, area,
23774 start, i,
23775 DRAW_NORMAL_TEXT, overlaps);
23776 }
23777 else
23778 {
23779 x += row->glyphs[area][i].pixel_width;
23780 ++i;
23781 }
23782 }
23783
23784 UNBLOCK_INPUT;
23785 }
23786
23787
23788 23789 23790
23791
23792 void
23793 draw_phys_cursor_glyph (w, row, hl)
23794 struct window *w;
23795 struct glyph_row *row;
23796 enum draw_glyphs_face hl;
23797 {
23798 23799 23800
23801 if ((row->reversed_p
23802 ? (w->phys_cursor.hpos >= 0)
23803 : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
23804 {
23805 int on_p = w->phys_cursor_on_p;
23806 int x1;
23807 x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
23808 w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
23809 hl, 0);
23810 w->phys_cursor_on_p = on_p;
23811
23812 if (hl == DRAW_CURSOR)
23813 w->phys_cursor_width = x1 - w->phys_cursor.x;
23814 23815 23816
23817 else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
23818 {
23819 w->phys_cursor_width = x1 - w->phys_cursor.x;
23820
23821 if (row > w->current_matrix->rows
23822 && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
23823 x_fix_overlapping_area (w, row - 1, TEXT_AREA,
23824 OVERLAPS_ERASED_CURSOR);
23825
23826 if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
23827 && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
23828 x_fix_overlapping_area (w, row + 1, TEXT_AREA,
23829 OVERLAPS_ERASED_CURSOR);
23830 }
23831 }
23832 }
23833
23834
23835 23836
23837
23838 void
23839 erase_phys_cursor (w)
23840 struct window *w;
23841 {
23842 struct frame *f = XFRAME (w->frame);
23843 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
23844 int hpos = w->phys_cursor.hpos;
23845 int vpos = w->phys_cursor.vpos;
23846 int mouse_face_here_p = 0;
23847 struct glyph_matrix *active_glyphs = w->current_matrix;
23848 struct glyph_row *cursor_row;
23849 struct glyph *cursor_glyph;
23850 enum draw_glyphs_face hl;
23851
23852 23853
23854 if (w->phys_cursor_type == NO_CURSOR)
23855 goto mark_cursor_off;
23856
23857 23858
23859 if (vpos >= active_glyphs->nrows)
23860 goto mark_cursor_off;
23861
23862 23863
23864 cursor_row = MATRIX_ROW (active_glyphs, vpos);
23865 if (!cursor_row->enabled_p)
23866 goto mark_cursor_off;
23867
23868 23869
23870 cursor_row->visible_height = min (cursor_row->visible_height,
23871 window_text_bottom_y (w) - cursor_row->y);
23872
23873 23874 23875
23876 if (cursor_row->visible_height <= 0)
23877 goto mark_cursor_off;
23878
23879
23880 if (cursor_row->cursor_in_fringe_p)
23881 {
23882 cursor_row->cursor_in_fringe_p = 0;
23883 draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
23884 goto mark_cursor_off;
23885 }
23886
23887 23888 23889 23890 23891
23892 if ((cursor_row->reversed_p
23893 ? (w->phys_cursor.hpos < 0)
23894 : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
23895 goto mark_cursor_off;
23896
23897 23898
23899 if (! NILP (dpyinfo->mouse_face_window)
23900 && w == XWINDOW (dpyinfo->mouse_face_window)
23901 && (vpos > dpyinfo->mouse_face_beg_row
23902 || (vpos == dpyinfo->mouse_face_beg_row
23903 && hpos >= dpyinfo->mouse_face_beg_col))
23904 && (vpos < dpyinfo->mouse_face_end_row
23905 || (vpos == dpyinfo->mouse_face_end_row
23906 && hpos < dpyinfo->mouse_face_end_col))
23907 23908 23909
23910 && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
23911 mouse_face_here_p = 1;
23912
23913
23914 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
23915 {
23916 int x, y, left_x;
23917 int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
23918 int width;
23919
23920 cursor_glyph = get_phys_cursor_glyph (w);
23921 if (cursor_glyph == NULL)
23922 goto mark_cursor_off;
23923
23924 width = cursor_glyph->pixel_width;
23925 left_x = window_box_left_offset (w, TEXT_AREA);
23926 x = w->phys_cursor.x;
23927 if (x < left_x)
23928 width -= left_x - x;
23929 width = min (width, window_box_width (w, TEXT_AREA) - x);
23930 y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));
23931 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, max (x, left_x));
23932
23933 if (width > 0)
23934 FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
23935 }
23936
23937
23938 if (mouse_face_here_p)
23939 hl = DRAW_MOUSE_FACE;
23940 else
23941 hl = DRAW_NORMAL_TEXT;
23942 draw_phys_cursor_glyph (w, cursor_row, hl);
23943
23944 mark_cursor_off:
23945 w->phys_cursor_on_p = 0;
23946 w->phys_cursor_type = NO_CURSOR;
23947 }
23948
23949
23950 23951 23952 23953
23954
23955 void
23956 display_and_set_cursor (w, on, hpos, vpos, x, y)
23957 struct window *w;
23958 int on, hpos, vpos, x, y;
23959 {
23960 struct frame *f = XFRAME (w->frame);
23961 int new_cursor_type;
23962 int new_cursor_width;
23963 int active_cursor;
23964 struct glyph_row *glyph_row;
23965 struct glyph *glyph;
23966
23967 23968 23969 23970
23971 if (! FRAME_VISIBLE_P (f)
23972 || FRAME_GARBAGED_P (f)
23973 || vpos >= w->current_matrix->nrows
23974 || hpos >= w->current_matrix->matrix_w)
23975 return;
23976
23977
23978 if (!on && !w->phys_cursor_on_p)
23979 return;
23980
23981 glyph_row = MATRIX_ROW (w->current_matrix, vpos);
23982 23983
23984 if (!glyph_row->enabled_p)
23985 {
23986 w->phys_cursor_on_p = 0;
23987 return;
23988 }
23989
23990 glyph = NULL;
23991 if (!glyph_row->exact_window_width_line_p
23992 || (0 <= hpos && hpos < glyph_row->used[TEXT_AREA]))
23993 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
23994
23995 xassert (interrupt_input_blocked);
23996
23997
23998 new_cursor_type = get_window_cursor_type (w, glyph,
23999 &new_cursor_width, &active_cursor);
24000
24001 24002 24003
24004 if (w->phys_cursor_on_p
24005 && (!on
24006 || w->phys_cursor.x != x
24007 || w->phys_cursor.y != y
24008 || new_cursor_type != w->phys_cursor_type
24009 || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
24010 && new_cursor_width != w->phys_cursor_width)))
24011 erase_phys_cursor (w);
24012
24013 24014 24015 24016 24017
24018 if (on)
24019 {
24020 w->phys_cursor_ascent = glyph_row->ascent;
24021 w->phys_cursor_height = glyph_row->height;
24022
24023 24024
24025 w->phys_cursor.x = x;
24026 w->phys_cursor.y = glyph_row->y;
24027 w->phys_cursor.hpos = hpos;
24028 w->phys_cursor.vpos = vpos;
24029 }
24030
24031 FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
24032 new_cursor_type, new_cursor_width,
24033 on, active_cursor);
24034 }
24035
24036
24037 24038
24039
24040 void
24041 update_window_cursor (w, on)
24042 struct window *w;
24043 int on;
24044 {
24045 24046
24047 if (w->current_matrix)
24048 {
24049 BLOCK_INPUT;
24050 display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
24051 w->phys_cursor.x, w->phys_cursor.y);
24052 UNBLOCK_INPUT;
24053 }
24054 }
24055
24056
24057 24058
24059
24060 static void
24061 update_cursor_in_window_tree (w, on_p)
24062 struct window *w;
24063 int on_p;
24064 {
24065 while (w)
24066 {
24067 if (!NILP (w->hchild))
24068 update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
24069 else if (!NILP (w->vchild))
24070 update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
24071 else
24072 update_window_cursor (w, on_p);
24073
24074 w = NILP (w->next) ? 0 : XWINDOW (w->next);
24075 }
24076 }
24077
24078
24079 24080 24081
24082
24083 void
24084 x_update_cursor (f, on_p)
24085 struct frame *f;
24086 int on_p;
24087 {
24088 update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
24089 }
24090
24091
24092 24093 24094 24095
24096
24097 void
24098 x_clear_cursor (w)
24099 struct window *w;
24100 {
24101 if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
24102 update_window_cursor (w, 0);
24103 }
24104
24105
24106 24107
24108
24109 void
24110 show_mouse_face (dpyinfo, draw)
24111 Display_Info *dpyinfo;
24112 enum draw_glyphs_face draw;
24113 {
24114 struct window *w = XWINDOW (dpyinfo->mouse_face_window);
24115 struct frame *f = XFRAME (WINDOW_FRAME (w));
24116
24117 if (24118
24119 w->current_matrix != NULL
24120
24121 && (draw != DRAW_MOUSE_FACE || !dpyinfo->mouse_face_hidden)
24122 24123
24124 && dpyinfo->mouse_face_end_row < w->current_matrix->nrows)
24125 {
24126 int phys_cursor_on_p = w->phys_cursor_on_p;
24127 struct glyph_row *row, *first, *last;
24128
24129 first = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
24130 last = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
24131
24132 for (row = first; row <= last && row->enabled_p; ++row)
24133 {
24134 int start_hpos, end_hpos, start_x;
24135
24136
24137 if (row == first)
24138 {
24139 start_hpos = dpyinfo->mouse_face_beg_col;
24140 start_x = dpyinfo->mouse_face_beg_x;
24141 }
24142 else
24143 {
24144 start_hpos = 0;
24145 start_x = 0;
24146 }
24147
24148 if (row == last)
24149 end_hpos = dpyinfo->mouse_face_end_col;
24150 else
24151 {
24152 end_hpos = row->used[TEXT_AREA];
24153 if (draw == DRAW_NORMAL_TEXT)
24154 row->fill_line_p = 1;
24155 }
24156
24157 if (end_hpos > start_hpos)
24158 {
24159 draw_glyphs (w, start_x, row, TEXT_AREA,
24160 start_hpos, end_hpos,
24161 draw, 0);
24162
24163 row->mouse_face_p
24164 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
24165 }
24166 }
24167
24168 24169
24170 if (phys_cursor_on_p && !w->phys_cursor_on_p)
24171 {
24172 BLOCK_INPUT;
24173 display_and_set_cursor (w, 1,
24174 w->phys_cursor.hpos, w->phys_cursor.vpos,
24175 w->phys_cursor.x, w->phys_cursor.y);
24176 UNBLOCK_INPUT;
24177 }
24178 }
24179
24180
24181 if (draw == DRAW_NORMAL_TEXT && !EQ (dpyinfo->mouse_face_window, f->tool_bar_window))
24182 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
24183 else if (draw == DRAW_MOUSE_FACE)
24184 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
24185 else
24186 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
24187 }
24188
24189 24190 24191 24192
24193
24194 int
24195 clear_mouse_face (dpyinfo)
24196 Display_Info *dpyinfo;
24197 {
24198 int cleared = 0;
24199
24200 if (!dpyinfo->mouse_face_hidden && !NILP (dpyinfo->mouse_face_window))
24201 {
24202 show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
24203 cleared = 1;
24204 }
24205
24206 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
24207 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
24208 dpyinfo->mouse_face_window = Qnil;
24209 dpyinfo->mouse_face_overlay = Qnil;
24210 return cleared;
24211 }
24212
24213
24214 24215
24216
24217 int
24218 cursor_in_mouse_face_p (w)
24219 struct window *w;
24220 {
24221 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
24222 int in_mouse_face = 0;
24223
24224 if (WINDOWP (dpyinfo->mouse_face_window)
24225 && XWINDOW (dpyinfo->mouse_face_window) == w)
24226 {
24227 int hpos = w->phys_cursor.hpos;
24228 int vpos = w->phys_cursor.vpos;
24229
24230 if (vpos >= dpyinfo->mouse_face_beg_row
24231 && vpos <= dpyinfo->mouse_face_end_row
24232 && (vpos > dpyinfo->mouse_face_beg_row
24233 || hpos >= dpyinfo->mouse_face_beg_col)
24234 && (vpos < dpyinfo->mouse_face_end_row
24235 || hpos < dpyinfo->mouse_face_end_col
24236 || dpyinfo->mouse_face_past_end))
24237 in_mouse_face = 1;
24238 }
24239
24240 return in_mouse_face;
24241 }
24242
24243
24244
24245
24246 24247 24248 24249 24250 24251 24252 24253
24254
24255 static void
24256 mouse_face_from_buffer_pos (Lisp_Object window,
24257 Display_Info *dpyinfo,
24258 EMACS_INT mouse_charpos,
24259 EMACS_INT start_charpos,
24260 EMACS_INT end_charpos,
24261 Lisp_Object before_string,
24262 Lisp_Object after_string,
24263 Lisp_Object display_string)
24264 {
24265 struct window *w = XWINDOW (window);
24266 struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
24267 struct glyph_row *row;
24268 struct glyph *glyph, *end;
24269 EMACS_INT ignore;
24270 int x;
24271
24272 xassert (NILP (display_string) || STRINGP (display_string));
24273 xassert (NILP (before_string) || STRINGP (before_string));
24274 xassert (NILP (after_string) || STRINGP (after_string));
24275
24276
24277 if (start_charpos < MATRIX_ROW_START_CHARPOS (first))
24278 {
24279 dpyinfo->mouse_face_beg_col = 0;
24280 dpyinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (first, w->current_matrix);
24281 dpyinfo->mouse_face_beg_x = first->x;
24282 dpyinfo->mouse_face_beg_y = first->y;
24283 }
24284 else
24285 {
24286 row = row_containing_pos (w, start_charpos, first, NULL, 0);
24287 if (row == NULL)
24288 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24289
24290 24291
24292 if (!NILP (before_string) || !NILP (display_string))
24293 {
24294 struct glyph_row *prev;
24295 while ((prev = row - 1, prev >= first)
24296 && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
24297 && prev->used[TEXT_AREA] > 0)
24298 {
24299 struct glyph *beg = prev->glyphs[TEXT_AREA];
24300 glyph = beg + prev->used[TEXT_AREA];
24301 while (--glyph >= beg && INTEGERP (glyph->object));
24302 if (glyph < beg
24303 || !(EQ (glyph->object, before_string)
24304 || EQ (glyph->object, display_string)))
24305 break;
24306 row = prev;
24307 }
24308 }
24309
24310 glyph = row->glyphs[TEXT_AREA];
24311 end = glyph + row->used[TEXT_AREA];
24312 x = row->x;
24313 dpyinfo->mouse_face_beg_y = row->y;
24314 dpyinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (row, w->current_matrix);
24315
24316
24317 if (row->displays_text_p)
24318 for (; glyph < end
24319 && INTEGERP (glyph->object)
24320 && glyph->charpos < 0;
24321 ++glyph)
24322 x += glyph->pixel_width;
24323
24324 24325
24326 for (; glyph < end
24327 && !INTEGERP (glyph->object)
24328 && !EQ (glyph->object, before_string)
24329 && !EQ (glyph->object, display_string)
24330 && !(BUFFERP (glyph->object)
24331 && glyph->charpos >= start_charpos);
24332 ++glyph)
24333 x += glyph->pixel_width;
24334
24335 dpyinfo->mouse_face_beg_x = x;
24336 dpyinfo->mouse_face_beg_col = glyph - row->glyphs[TEXT_AREA];
24337 }
24338
24339
24340 row = row_containing_pos (w, end_charpos, first, NULL, 0);
24341 if (row == NULL)
24342 {
24343 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24344 dpyinfo->mouse_face_past_end = 1;
24345 }
24346 else if (!NILP (after_string))
24347 {
24348
24349 struct glyph_row *next;
24350 struct glyph_row *last
24351 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24352
24353 for (next = row + 1;
24354 next <= last
24355 && next->used[TEXT_AREA] > 0
24356 && EQ (next->glyphs[TEXT_AREA]->object, after_string);
24357 ++next)
24358 row = next;
24359 }
24360
24361 glyph = row->glyphs[TEXT_AREA];
24362 end = glyph + row->used[TEXT_AREA];
24363 x = row->x;
24364 dpyinfo->mouse_face_end_y = row->y;
24365 dpyinfo->mouse_face_end_row = MATRIX_ROW_VPOS (row, w->current_matrix);
24366
24367
24368 if (row->displays_text_p)
24369 for (; glyph < end
24370 && INTEGERP (glyph->object)
24371 && glyph->charpos < 0;
24372 ++glyph)
24373 x += glyph->pixel_width;
24374
24375 24376
24377 for (; glyph < end
24378 && !INTEGERP (glyph->object)
24379 && !EQ (glyph->object, after_string)
24380 && !(BUFFERP (glyph->object) && glyph->charpos >= end_charpos);
24381 ++glyph)
24382 x += glyph->pixel_width;
24383
24384
24385 if (EQ (glyph->object, after_string))
24386 {
24387 for (; EQ (glyph->object, after_string) && glyph < end; ++glyph)
24388 x += glyph->pixel_width;
24389 }
24390 else
24391 {
24392 24393 24394 24395 24396
24397 Lisp_Object prev_object;
24398 EMACS_INT pos;
24399
24400 while (glyph > row->glyphs[TEXT_AREA])
24401 {
24402 prev_object = (glyph - 1)->object;
24403 if (!STRINGP (prev_object) || EQ (prev_object, display_string))
24404 break;
24405
24406 pos = string_buffer_position (w, prev_object, end_charpos);
24407 if (pos && pos < end_charpos)
24408 break;
24409
24410 for (; glyph > row->glyphs[TEXT_AREA]
24411 && EQ ((glyph - 1)->object, prev_object);
24412 --glyph)
24413 x -= (glyph - 1)->pixel_width;
24414 }
24415 }
24416
24417 dpyinfo->mouse_face_end_x = x;
24418 dpyinfo->mouse_face_end_col = glyph - row->glyphs[TEXT_AREA];
24419 dpyinfo->mouse_face_window = window;
24420 dpyinfo->mouse_face_face_id
24421 = face_at_buffer_position (w, mouse_charpos, 0, 0, &ignore,
24422 mouse_charpos + 1,
24423 !dpyinfo->mouse_face_hidden, -1);
24424 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
24425 }
24426
24427
24428 24429 24430 24431 24432 24433 24434 24435 24436 24437 24438 24439 24440 24441
24442
24443 static int
24444 fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
24445 struct window *w;
24446 EMACS_INT pos;
24447 Lisp_Object object;
24448 int *hpos, *vpos, *x, *y;
24449 int right_p;
24450 {
24451 int yb = window_text_bottom_y (w);
24452 struct glyph_row *r;
24453 struct glyph *best_glyph = NULL;
24454 struct glyph_row *best_row = NULL;
24455 int best_x = 0;
24456
24457 for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
24458 r->enabled_p && r->y < yb;
24459 ++r)
24460 {
24461 struct glyph *g = r->glyphs[TEXT_AREA];
24462 struct glyph *e = g + r->used[TEXT_AREA];
24463 int gx;
24464
24465 for (gx = r->x; g < e; gx += g->pixel_width, ++g)
24466 if (EQ (g->object, object))
24467 {
24468 if (g->charpos == pos)
24469 {
24470 best_glyph = g;
24471 best_x = gx;
24472 best_row = r;
24473 goto found;
24474 }
24475 else if (best_glyph == NULL
24476 || ((eabs (g->charpos - pos)
24477 < eabs (best_glyph->charpos - pos))
24478 && (right_p
24479 ? g->charpos < pos
24480 : g->charpos > pos)))
24481 {
24482 best_glyph = g;
24483 best_x = gx;
24484 best_row = r;
24485 }
24486 }
24487 }
24488
24489 found:
24490
24491 if (best_glyph)
24492 {
24493 *x = best_x;
24494 *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
24495
24496 if (right_p)
24497 {
24498 *x += best_glyph->pixel_width;
24499 ++*hpos;
24500 }
24501
24502 *y = best_row->y;
24503 *vpos = best_row - w->current_matrix->rows;
24504 }
24505
24506 return best_glyph != NULL;
24507 }
24508
24509
24510
24511
24512 static int
24513 on_hot_spot_p (hot_spot, x, y)
24514 Lisp_Object hot_spot;
24515 int x, y;
24516 {
24517 if (!CONSP (hot_spot))
24518 return 0;
24519
24520 if (EQ (XCAR (hot_spot), Qrect))
24521 {
24522
24523 Lisp_Object rect = XCDR (hot_spot);
24524 Lisp_Object tem;
24525 if (!CONSP (rect))
24526 return 0;
24527 if (!CONSP (XCAR (rect)))
24528 return 0;
24529 if (!CONSP (XCDR (rect)))
24530 return 0;
24531 if (!(tem = XCAR (XCAR (rect)), INTEGERP (tem) && x >= XINT (tem)))
24532 return 0;
24533 if (!(tem = XCDR (XCAR (rect)), INTEGERP (tem) && y >= XINT (tem)))
24534 return 0;
24535 if (!(tem = XCAR (XCDR (rect)), INTEGERP (tem) && x <= XINT (tem)))
24536 return 0;
24537 if (!(tem = XCDR (XCDR (rect)), INTEGERP (tem) && y <= XINT (tem)))
24538 return 0;
24539 return 1;
24540 }
24541 else if (EQ (XCAR (hot_spot), Qcircle))
24542 {
24543
24544 Lisp_Object circ = XCDR (hot_spot);
24545 Lisp_Object lr, lx0, ly0;
24546 if (CONSP (circ)
24547 && CONSP (XCAR (circ))
24548 && (lr = XCDR (circ), INTEGERP (lr) || FLOATP (lr))
24549 && (lx0 = XCAR (XCAR (circ)), INTEGERP (lx0))
24550 && (ly0 = XCDR (XCAR (circ)), INTEGERP (ly0)))
24551 {
24552 double r = XFLOATINT (lr);
24553 double dx = XINT (lx0) - x;
24554 double dy = XINT (ly0) - y;
24555 return (dx * dx + dy * dy <= r * r);
24556 }
24557 }
24558 else if (EQ (XCAR (hot_spot), Qpoly))
24559 {
24560
24561 if (VECTORP (XCDR (hot_spot)))
24562 {
24563 struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
24564 Lisp_Object *poly = v->contents;
24565 int n = v->size;
24566 int i;
24567 int inside = 0;
24568 Lisp_Object lx, ly;
24569 int x0, y0;
24570
24571
24572 if (n < 6 || n & 1)
24573 return 0;
24574
24575 24576 24577 24578
24579 if ((lx = poly[n-2], !INTEGERP (lx))
24580 || (ly = poly[n-1], !INTEGERP (lx)))
24581 return 0;
24582 x0 = XINT (lx), y0 = XINT (ly);
24583 for (i = 0; i < n; i += 2)
24584 {
24585 int x1 = x0, y1 = y0;
24586 if ((lx = poly[i], !INTEGERP (lx))
24587 || (ly = poly[i+1], !INTEGERP (ly)))
24588 return 0;
24589 x0 = XINT (lx), y0 = XINT (ly);
24590
24591
24592 if (x0 >= x)
24593 {
24594 if (x1 >= x)
24595 continue;
24596 }
24597 else if (x1 < x)
24598 continue;
24599 if (y > y0 && y > y1)
24600 continue;
24601 if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
24602 inside = !inside;
24603 }
24604 return inside;
24605 }
24606 }
24607 return 0;
24608 }
24609
24610 Lisp_Object
24611 find_hot_spot (map, x, y)
24612 Lisp_Object map;
24613 int x, y;
24614 {
24615 while (CONSP (map))
24616 {
24617 if (CONSP (XCAR (map))
24618 && on_hot_spot_p (XCAR (XCAR (map)), x, y))
24619 return XCAR (map);
24620 map = XCDR (map);
24621 }
24622
24623 return Qnil;
24624 }
24625
24626 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
24627 3, 3, 0,
24628 doc: 24629 24630 24631 24632 24633 24634 24635 24636 24637 )
24638 (map, x, y)
24639 Lisp_Object map;
24640 Lisp_Object x, y;
24641 {
24642 if (NILP (map))
24643 return Qnil;
24644
24645 CHECK_NUMBER (x);
24646 CHECK_NUMBER (y);
24647
24648 return find_hot_spot (map, XINT (x), XINT (y));
24649 }
24650
24651
24652
24653 static void
24654 define_frame_cursor1 (f, cursor, pointer)
24655 struct frame *f;
24656 Cursor cursor;
24657 Lisp_Object pointer;
24658 {
24659
24660 if (!NILP (do_mouse_tracking))
24661 return;
24662
24663 if (!NILP (pointer))
24664 {
24665 if (EQ (pointer, Qarrow))
24666 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24667 else if (EQ (pointer, Qhand))
24668 cursor = FRAME_X_OUTPUT (f)->hand_cursor;
24669 else if (EQ (pointer, Qtext))
24670 cursor = FRAME_X_OUTPUT (f)->text_cursor;
24671 else if (EQ (pointer, intern ("hdrag")))
24672 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
24673 #ifdef HAVE_X_WINDOWS
24674 else if (EQ (pointer, intern ("vdrag")))
24675 cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
24676 #endif
24677 else if (EQ (pointer, intern ("hourglass")))
24678 cursor = FRAME_X_OUTPUT (f)->hourglass_cursor;
24679 else if (EQ (pointer, Qmodeline))
24680 cursor = FRAME_X_OUTPUT (f)->modeline_cursor;
24681 else
24682 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24683 }
24684
24685 if (cursor != No_Cursor)
24686 FRAME_RIF (f)->define_frame_cursor (f, cursor);
24687 }
24688
24689 24690 24691 24692 24693
24694
24695 static void
24696 note_mode_line_or_margin_highlight (window, x, y, area)
24697 Lisp_Object window;
24698 int x, y;
24699 enum window_part area;
24700 {
24701 struct window *w = XWINDOW (window);
24702 struct frame *f = XFRAME (w->frame);
24703 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
24704 Cursor cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24705 Lisp_Object pointer = Qnil;
24706 int charpos, dx, dy, width, height;
24707 Lisp_Object string, object = Qnil;
24708 Lisp_Object pos, help;
24709
24710 Lisp_Object mouse_face;
24711 int original_x_pixel = x;
24712 struct glyph * glyph = NULL, * row_start_glyph = NULL;
24713 struct glyph_row *row;
24714
24715 if (area == ON_MODE_LINE || area == ON_HEADER_LINE)
24716 {
24717 int x0;
24718 struct glyph *end;
24719
24720 string = mode_line_string (w, area, &x, &y, &charpos,
24721 &object, &dx, &dy, &width, &height);
24722
24723 row = (area == ON_MODE_LINE
24724 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
24725 : MATRIX_HEADER_LINE_ROW (w->current_matrix));
24726
24727
24728 if (row->mode_line_p && row->enabled_p)
24729 {
24730 glyph = row_start_glyph = row->glyphs[TEXT_AREA];
24731 end = glyph + row->used[TEXT_AREA];
24732
24733 for (x0 = original_x_pixel;
24734 glyph < end && x0 >= glyph->pixel_width;
24735 ++glyph)
24736 x0 -= glyph->pixel_width;
24737
24738 if (glyph >= end)
24739 glyph = NULL;
24740 }
24741 }
24742 else
24743 {
24744 x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
24745 string = marginal_area_string (w, area, &x, &y, &charpos,
24746 &object, &dx, &dy, &width, &height);
24747 }
24748
24749 help = Qnil;
24750
24751 if (IMAGEP (object))
24752 {
24753 Lisp_Object image_map, hotspot;
24754 if ((image_map = Fplist_get (XCDR (object), QCmap),
24755 !NILP (image_map))
24756 && (hotspot = find_hot_spot (image_map, dx, dy),
24757 CONSP (hotspot))
24758 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
24759 {
24760 Lisp_Object area_id, plist;
24761
24762 area_id = XCAR (hotspot);
24763 24764 24765
24766 hotspot = XCDR (hotspot);
24767 if (CONSP (hotspot)
24768 && (plist = XCAR (hotspot), CONSP (plist)))
24769 {
24770 pointer = Fplist_get (plist, Qpointer);
24771 if (NILP (pointer))
24772 pointer = Qhand;
24773 help = Fplist_get (plist, Qhelp_echo);
24774 if (!NILP (help))
24775 {
24776 help_echo_string = help;
24777
24778 XSETWINDOW (help_echo_window, w);
24779 help_echo_object = w->buffer;
24780 help_echo_pos = charpos;
24781 }
24782 }
24783 }
24784 if (NILP (pointer))
24785 pointer = Fplist_get (XCDR (object), QCpointer);
24786 }
24787
24788 if (STRINGP (string))
24789 {
24790 pos = make_number (charpos);
24791 24792 24793
24794 if (NILP (help))
24795 {
24796 help = Fget_text_property (pos, Qhelp_echo, string);
24797 if (!NILP (help))
24798 {
24799 help_echo_string = help;
24800 XSETWINDOW (help_echo_window, w);
24801 help_echo_object = string;
24802 help_echo_pos = charpos;
24803 }
24804 }
24805
24806 if (NILP (pointer))
24807 pointer = Fget_text_property (pos, Qpointer, string);
24808
24809
24810 if (NILP (pointer) && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
24811 {
24812 Lisp_Object map;
24813 map = Fget_text_property (pos, Qlocal_map, string);
24814 if (!KEYMAPP (map))
24815 map = Fget_text_property (pos, Qkeymap, string);
24816 if (!KEYMAPP (map))
24817 cursor = dpyinfo->vertical_scroll_bar_cursor;
24818 }
24819
24820
24821 mouse_face = Fget_text_property (pos, Qmouse_face, string);
24822 if (!NILP (mouse_face)
24823 && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
24824 && glyph)
24825 {
24826 Lisp_Object b, e;
24827
24828 struct glyph * tmp_glyph;
24829
24830 int gpos;
24831 int gseq_length;
24832 int total_pixel_width;
24833 EMACS_INT ignore;
24834
24835 int vpos, hpos;
24836
24837 b = Fprevious_single_property_change (make_number (charpos + 1),
24838 Qmouse_face, string, Qnil);
24839 if (NILP (b))
24840 b = make_number (0);
24841
24842 e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
24843 if (NILP (e))
24844 e = make_number (SCHARS (string));
24845
24846 24847 24848 24849 24850 24851 24852 24853
24854 gpos = 0;
24855 if (glyph > row_start_glyph)
24856 {
24857 tmp_glyph = glyph - 1;
24858 while (tmp_glyph >= row_start_glyph
24859 && tmp_glyph->charpos >= XINT (b)
24860 && EQ (tmp_glyph->object, glyph->object))
24861 {
24862 tmp_glyph--;
24863 gpos++;
24864 }
24865 }
24866
24867 24868 24869 24870 24871
24872 for (tmp_glyph = glyph, gseq_length = gpos;
24873 tmp_glyph->charpos < XINT (e);
24874 tmp_glyph++, gseq_length++)
24875 {
24876 if (!EQ (tmp_glyph->object, glyph->object))
24877 break;
24878 }
24879
24880 total_pixel_width = 0;
24881 for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
24882 total_pixel_width += tmp_glyph->pixel_width;
24883
24884
24885 vpos = (x - gpos);
24886 hpos = (area == ON_MODE_LINE
24887 ? (w->current_matrix)->nrows - 1
24888 : 0);
24889
24890 24891
24892 if ( EQ (window, dpyinfo->mouse_face_window)
24893 && dpyinfo->mouse_face_beg_col <= vpos
24894 && vpos < dpyinfo->mouse_face_end_col
24895 && dpyinfo->mouse_face_beg_row == hpos )
24896 return;
24897
24898 if (clear_mouse_face (dpyinfo))
24899 cursor = No_Cursor;
24900
24901 dpyinfo->mouse_face_beg_col = vpos;
24902 dpyinfo->mouse_face_beg_row = hpos;
24903
24904 dpyinfo->mouse_face_beg_x = original_x_pixel - (total_pixel_width + dx);
24905 dpyinfo->mouse_face_beg_y = 0;
24906
24907 dpyinfo->mouse_face_end_col = vpos + gseq_length;
24908 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_beg_row;
24909
24910 dpyinfo->mouse_face_end_x = 0;
24911 dpyinfo->mouse_face_end_y = 0;
24912
24913 dpyinfo->mouse_face_past_end = 0;
24914 dpyinfo->mouse_face_window = window;
24915
24916 dpyinfo->mouse_face_face_id = face_at_string_position (w, string,
24917 charpos,
24918 0, 0, 0, &ignore,
24919 glyph->face_id, 1);
24920 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
24921
24922 if (NILP (pointer))
24923 pointer = Qhand;
24924 }
24925 else if ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
24926 clear_mouse_face (dpyinfo);
24927 }
24928 define_frame_cursor1 (f, cursor, pointer);
24929 }
24930
24931
24932 24933 24934 24935 24936
24937
24938 void
24939 note_mouse_highlight (f, x, y)
24940 struct frame *f;
24941 int x, y;
24942 {
24943 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
24944 enum window_part part;
24945 Lisp_Object window;
24946 struct window *w;
24947 Cursor cursor = No_Cursor;
24948 Lisp_Object pointer = Qnil;
24949 struct buffer *b;
24950
24951
24952 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
24953 if (popup_activated ())
24954 return;
24955 #endif
24956
24957 if (NILP (Vmouse_highlight)
24958 || !f->glyphs_initialized_p
24959 || f->pointer_invisible)
24960 return;
24961
24962 dpyinfo->mouse_face_mouse_x = x;
24963 dpyinfo->mouse_face_mouse_y = y;
24964 dpyinfo->mouse_face_mouse_frame = f;
24965
24966 if (dpyinfo->mouse_face_defer)
24967 return;
24968
24969 if (gc_in_progress)
24970 {
24971 dpyinfo->mouse_face_deferred_gc = 1;
24972 return;
24973 }
24974
24975
24976 window = window_from_coordinates (f, x, y, &part, 0, 0, 1);
24977
24978 24979
24980 if (! EQ (window, dpyinfo->mouse_face_window)
24981 || (part != ON_TEXT && part != ON_MODE_LINE && part != ON_HEADER_LINE
24982 && !NILP (dpyinfo->mouse_face_window)))
24983 clear_mouse_face (dpyinfo);
24984
24985
24986 if (!WINDOWP (window))
24987 return;
24988
24989
24990 help_echo_string = Qnil;
24991
24992
24993 w = XWINDOW (window);
24994 frame_to_window_pixel_xy (w, &x, &y);
24995
24996 24997
24998 if (EQ (window, f->tool_bar_window))
24999 {
25000 note_tool_bar_highlight (f, x, y);
25001 return;
25002 }
25003
25004
25005 if (part == ON_MODE_LINE || part == ON_HEADER_LINE
25006 || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
25007 {
25008 note_mode_line_or_margin_highlight (window, x, y, part);
25009 return;
25010 }
25011
25012 if (part == ON_VERTICAL_BORDER)
25013 {
25014 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
25015 help_echo_string = build_string ("drag-mouse-1: resize");
25016 }
25017 else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
25018 || part == ON_SCROLL_BAR)
25019 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
25020 else
25021 cursor = FRAME_X_OUTPUT (f)->text_cursor;
25022
25023 25024
25025 b = XBUFFER (w->buffer);
25026 if (part == ON_TEXT
25027 && EQ (w->window_end_valid, w->buffer)
25028 && XFASTINT (w->last_modified) == BUF_MODIFF (b)
25029 && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
25030 {
25031 int hpos, vpos, i, dx, dy, area;
25032 EMACS_INT pos;
25033 struct glyph *glyph;
25034 Lisp_Object object;
25035 Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
25036 Lisp_Object *overlay_vec = NULL;
25037 int noverlays;
25038 struct buffer *obuf;
25039 int obegv, ozv, same_region;
25040
25041
25042 glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
25043
25044
25045 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
25046 {
25047 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
25048 if (img != NULL && IMAGEP (img->spec))
25049 {
25050 Lisp_Object image_map, hotspot;
25051 if ((image_map = Fplist_get (XCDR (img->spec), QCmap),
25052 !NILP (image_map))
25053 && (hotspot = find_hot_spot (image_map,
25054 glyph->slice.x + dx,
25055 glyph->slice.y + dy),
25056 CONSP (hotspot))
25057 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
25058 {
25059 Lisp_Object area_id, plist;
25060
25061 area_id = XCAR (hotspot);
25062 25063 25064
25065 hotspot = XCDR (hotspot);
25066 if (CONSP (hotspot)
25067 && (plist = XCAR (hotspot), CONSP (plist)))
25068 {
25069 pointer = Fplist_get (plist, Qpointer);
25070 if (NILP (pointer))
25071 pointer = Qhand;
25072 help_echo_string = Fplist_get (plist, Qhelp_echo);
25073 if (!NILP (help_echo_string))
25074 {
25075 help_echo_window = window;
25076 help_echo_object = glyph->object;
25077 help_echo_pos = glyph->charpos;
25078 }
25079 }
25080 }
25081 if (NILP (pointer))
25082 pointer = Fplist_get (XCDR (img->spec), QCpointer);
25083 }
25084 }
25085
25086
25087 if (glyph == NULL
25088 || area != TEXT_AREA
25089 || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
25090 {
25091 if (clear_mouse_face (dpyinfo))
25092 cursor = No_Cursor;
25093 if (NILP (pointer))
25094 {
25095 if (area != TEXT_AREA)
25096 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
25097 else
25098 pointer = Vvoid_text_area_pointer;
25099 }
25100 goto set_cursor;
25101 }
25102
25103 pos = glyph->charpos;
25104 object = glyph->object;
25105 if (!STRINGP (object) && !BUFFERP (object))
25106 goto set_cursor;
25107
25108
25109 if (BUFFERP (object) && pos > BUF_Z (b))
25110 goto set_cursor;
25111
25112 25113
25114 obuf = current_buffer;
25115 current_buffer = b;
25116 obegv = BEGV;
25117 ozv = ZV;
25118 BEGV = BEG;
25119 ZV = Z;
25120
25121
25122 position = make_number (pos);
25123
25124 if (BUFFERP (object))
25125 {
25126
25127 GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
25128
25129 noverlays = sort_overlays (overlay_vec, noverlays, w);
25130 }
25131 else
25132 noverlays = 0;
25133
25134 same_region = (EQ (window, dpyinfo->mouse_face_window)
25135 && vpos >= dpyinfo->mouse_face_beg_row
25136 && vpos <= dpyinfo->mouse_face_end_row
25137 && (vpos > dpyinfo->mouse_face_beg_row
25138 || hpos >= dpyinfo->mouse_face_beg_col)
25139 && (vpos < dpyinfo->mouse_face_end_row
25140 || hpos < dpyinfo->mouse_face_end_col
25141 || dpyinfo->mouse_face_past_end));
25142
25143 if (same_region)
25144 cursor = No_Cursor;
25145
25146
25147 if (! same_region
25148 25149 25150 25151
25152 || (OVERLAYP (dpyinfo->mouse_face_overlay)
25153 && mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
25154 {
25155
25156 overlay = Qnil;
25157 for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
25158 {
25159 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
25160 if (!NILP (mouse_face))
25161 overlay = overlay_vec[i];
25162 }
25163
25164 25165
25166 if (!NILP (overlay) && EQ (overlay, dpyinfo->mouse_face_overlay))
25167 goto check_help_echo;
25168 dpyinfo->mouse_face_overlay = overlay;
25169
25170
25171 if (clear_mouse_face (dpyinfo))
25172 cursor = No_Cursor;
25173
25174
25175 if (NILP (overlay))
25176 mouse_face = Fget_text_property (position, Qmouse_face, object);
25177
25178 25179
25180 if (!NILP (mouse_face) && STRINGP (object))
25181 {
25182 25183
25184 Lisp_Object b, e;
25185 EMACS_INT ignore;
25186
25187 b = Fprevious_single_property_change
25188 (make_number (pos + 1), Qmouse_face, object, Qnil);
25189 e = Fnext_single_property_change
25190 (position, Qmouse_face, object, Qnil);
25191 if (NILP (b))
25192 b = make_number (0);
25193 if (NILP (e))
25194 e = make_number (SCHARS (object) - 1);
25195
25196 fast_find_string_pos (w, XINT (b), object,
25197 &dpyinfo->mouse_face_beg_col,
25198 &dpyinfo->mouse_face_beg_row,
25199 &dpyinfo->mouse_face_beg_x,
25200 &dpyinfo->mouse_face_beg_y, 0);
25201 fast_find_string_pos (w, XINT (e), object,
25202 &dpyinfo->mouse_face_end_col,
25203 &dpyinfo->mouse_face_end_row,
25204 &dpyinfo->mouse_face_end_x,
25205 &dpyinfo->mouse_face_end_y, 1);
25206 dpyinfo->mouse_face_past_end = 0;
25207 dpyinfo->mouse_face_window = window;
25208 dpyinfo->mouse_face_face_id
25209 = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
25210 glyph->face_id, 1);
25211 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
25212 cursor = No_Cursor;
25213 }
25214 else
25215 {
25216 25217
25218 Lisp_Object buffer, display_string;
25219
25220 if (STRINGP (object))
25221 {
25222 25223
25224 struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
25225 int start = MATRIX_ROW_START_CHARPOS (r);
25226 pos = string_buffer_position (w, object, start);
25227 if (pos > 0)
25228 {
25229 mouse_face = get_char_property_and_overlay
25230 (make_number (pos), Qmouse_face, w->buffer, &overlay);
25231 buffer = w->buffer;
25232 display_string = object;
25233 }
25234 }
25235 else
25236 {
25237 buffer = object;
25238 display_string = Qnil;
25239 }
25240
25241 if (!NILP (mouse_face))
25242 {
25243 Lisp_Object before, after;
25244 Lisp_Object before_string, after_string;
25245
25246 if (NILP (overlay))
25247 {
25248
25249 before = Fprevious_single_property_change
25250 (make_number (pos + 1), Qmouse_face, buffer,
25251 Fmarker_position (w->start));
25252 after = Fnext_single_property_change
25253 (make_number (pos), Qmouse_face, buffer,
25254 make_number (BUF_Z (XBUFFER (buffer))
25255 - XFASTINT (w->window_end_pos)));
25256 before_string = after_string = Qnil;
25257 }
25258 else
25259 {
25260
25261 before = Foverlay_start (overlay);
25262 after = Foverlay_end (overlay);
25263 before_string = Foverlay_get (overlay, Qbefore_string);
25264 after_string = Foverlay_get (overlay, Qafter_string);
25265
25266 if (!STRINGP (before_string)) before_string = Qnil;
25267 if (!STRINGP (after_string)) after_string = Qnil;
25268 }
25269
25270 mouse_face_from_buffer_pos (window, dpyinfo, pos,
25271 XFASTINT (before),
25272 XFASTINT (after),
25273 before_string, after_string,
25274 display_string);
25275 cursor = No_Cursor;
25276 }
25277 }
25278 }
25279
25280 check_help_echo:
25281
25282
25283 if (NILP (help_echo_string)) {
25284 Lisp_Object help, overlay;
25285
25286
25287 help = overlay = Qnil;
25288 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
25289 {
25290 overlay = overlay_vec[i];
25291 help = Foverlay_get (overlay, Qhelp_echo);
25292 }
25293
25294 if (!NILP (help))
25295 {
25296 help_echo_string = help;
25297 help_echo_window = window;
25298 help_echo_object = overlay;
25299 help_echo_pos = pos;
25300 }
25301 else
25302 {
25303 Lisp_Object object = glyph->object;
25304 int charpos = glyph->charpos;
25305
25306
25307 if (STRINGP (object)
25308 && charpos >= 0
25309 && charpos < SCHARS (object))
25310 {
25311 help = Fget_text_property (make_number (charpos),
25312 Qhelp_echo, object);
25313 if (NILP (help))
25314 {
25315 25316
25317 struct glyph_row *r
25318 = MATRIX_ROW (w->current_matrix, vpos);
25319 int start = MATRIX_ROW_START_CHARPOS (r);
25320 EMACS_INT pos = string_buffer_position (w, object, start);
25321 if (pos > 0)
25322 {
25323 help = Fget_char_property (make_number (pos),
25324 Qhelp_echo, w->buffer);
25325 if (!NILP (help))
25326 {
25327 charpos = pos;
25328 object = w->buffer;
25329 }
25330 }
25331 }
25332 }
25333 else if (BUFFERP (object)
25334 && charpos >= BEGV
25335 && charpos < ZV)
25336 help = Fget_text_property (make_number (charpos), Qhelp_echo,
25337 object);
25338
25339 if (!NILP (help))
25340 {
25341 help_echo_string = help;
25342 help_echo_window = window;
25343 help_echo_object = object;
25344 help_echo_pos = charpos;
25345 }
25346 }
25347 }
25348
25349
25350 if (NILP (pointer))
25351 {
25352
25353 for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
25354 pointer = Foverlay_get (overlay_vec[i], Qpointer);
25355
25356 if (NILP (pointer))
25357 {
25358 Lisp_Object object = glyph->object;
25359 int charpos = glyph->charpos;
25360
25361
25362 if (STRINGP (object)
25363 && charpos >= 0
25364 && charpos < SCHARS (object))
25365 {
25366 pointer = Fget_text_property (make_number (charpos),
25367 Qpointer, object);
25368 if (NILP (pointer))
25369 {
25370 25371
25372 struct glyph_row *r
25373 = MATRIX_ROW (w->current_matrix, vpos);
25374 int start = MATRIX_ROW_START_CHARPOS (r);
25375 EMACS_INT pos = string_buffer_position (w, object,
25376 start);
25377 if (pos > 0)
25378 pointer = Fget_char_property (make_number (pos),
25379 Qpointer, w->buffer);
25380 }
25381 }
25382 else if (BUFFERP (object)
25383 && charpos >= BEGV
25384 && charpos < ZV)
25385 pointer = Fget_text_property (make_number (charpos),
25386 Qpointer, object);
25387 }
25388 }
25389
25390 BEGV = obegv;
25391 ZV = ozv;
25392 current_buffer = obuf;
25393 }
25394
25395 set_cursor:
25396
25397 define_frame_cursor1 (f, cursor, pointer);
25398 }
25399
25400
25401 25402 25403 25404
25405
25406 void
25407 x_clear_window_mouse_face (w)
25408 struct window *w;
25409 {
25410 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
25411 Lisp_Object window;
25412
25413 BLOCK_INPUT;
25414 XSETWINDOW (window, w);
25415 if (EQ (window, dpyinfo->mouse_face_window))
25416 clear_mouse_face (dpyinfo);
25417 UNBLOCK_INPUT;
25418 }
25419
25420
25421 25422 25423
25424
25425 void
25426 cancel_mouse_face (f)
25427 struct frame *f;
25428 {
25429 Lisp_Object window;
25430 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
25431
25432 window = dpyinfo->mouse_face_window;
25433 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
25434 {
25435 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
25436 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
25437 dpyinfo->mouse_face_window = Qnil;
25438 }
25439 }
25440
25441
25442 #endif
25443
25444
25445 25446 25447
25448
25449 #ifdef HAVE_WINDOW_SYSTEM
25450
25451 25452
25453
25454 static void
25455 expose_area (w, row, r, area)
25456 struct window *w;
25457 struct glyph_row *row;
25458 XRectangle *r;
25459 enum glyph_row_area area;
25460 {
25461 struct glyph *first = row->glyphs[area];
25462 struct glyph *end = row->glyphs[area] + row->used[area];
25463 struct glyph *last;
25464 int first_x, start_x, x;
25465
25466 if (area == TEXT_AREA && row->fill_line_p)
25467
25468 draw_glyphs (w, 0, row, area,
25469 0, row->used[area],
25470 DRAW_NORMAL_TEXT, 0);
25471 else
25472 {
25473 25474 25475
25476 start_x = window_box_left_offset (w, area);
25477 x = start_x;
25478 if (area == TEXT_AREA)
25479 x += row->x;
25480
25481
25482 while (first < end
25483 && x + first->pixel_width < r->x)
25484 {
25485 x += first->pixel_width;
25486 ++first;
25487 }
25488
25489
25490 last = first;
25491 first_x = x;
25492 while (last < end
25493 && x < r->x + r->width)
25494 {
25495 x += last->pixel_width;
25496 ++last;
25497 }
25498
25499
25500 if (last > first)
25501 draw_glyphs (w, first_x - start_x, row, area,
25502 first - row->glyphs[area], last - row->glyphs[area],
25503 DRAW_NORMAL_TEXT, 0);
25504 }
25505 }
25506
25507
25508 25509 25510
25511
25512 static int
25513 expose_line (w, row, r)
25514 struct window *w;
25515 struct glyph_row *row;
25516 XRectangle *r;
25517 {
25518 xassert (row->enabled_p);
25519
25520 if (row->mode_line_p || w->pseudo_window_p)
25521 draw_glyphs (w, 0, row, TEXT_AREA,
25522 0, row->used[TEXT_AREA],
25523 DRAW_NORMAL_TEXT, 0);
25524 else
25525 {
25526 if (row->used[LEFT_MARGIN_AREA])
25527 expose_area (w, row, r, LEFT_MARGIN_AREA);
25528 if (row->used[TEXT_AREA])
25529 expose_area (w, row, r, TEXT_AREA);
25530 if (row->used[RIGHT_MARGIN_AREA])
25531 expose_area (w, row, r, RIGHT_MARGIN_AREA);
25532 draw_row_fringe_bitmaps (w, row);
25533 }
25534
25535 return row->mouse_face_p;
25536 }
25537
25538
25539 25540 25541 25542 25543 25544 25545
25546
25547 static void
25548 expose_overlaps (w, first_overlapping_row, last_overlapping_row, r)
25549 struct window *w;
25550 struct glyph_row *first_overlapping_row;
25551 struct glyph_row *last_overlapping_row;
25552 XRectangle *r;
25553 {
25554 struct glyph_row *row;
25555
25556 for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
25557 if (row->overlapping_p)
25558 {
25559 xassert (row->enabled_p && !row->mode_line_p);
25560
25561 row->clip = r;
25562 if (row->used[LEFT_MARGIN_AREA])
25563 x_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
25564
25565 if (row->used[TEXT_AREA])
25566 x_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
25567
25568 if (row->used[RIGHT_MARGIN_AREA])
25569 x_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
25570 row->clip = NULL;
25571 }
25572 }
25573
25574
25575
25576
25577 static int
25578 phys_cursor_in_rect_p (w, r)
25579 struct window *w;
25580 XRectangle *r;
25581 {
25582 XRectangle cr, result;
25583 struct glyph *cursor_glyph;
25584 struct glyph_row *row;
25585
25586 if (w->phys_cursor.vpos >= 0
25587 && w->phys_cursor.vpos < w->current_matrix->nrows
25588 && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
25589 row->enabled_p)
25590 && row->cursor_in_fringe_p)
25591 {
25592
25593 cr.x = window_box_right_offset (w,
25594 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
25595 ? RIGHT_MARGIN_AREA
25596 : TEXT_AREA));
25597 cr.y = row->y;
25598 cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
25599 cr.height = row->height;
25600 return x_intersect_rectangles (&cr, r, &result);
25601 }
25602
25603 cursor_glyph = get_phys_cursor_glyph (w);
25604 if (cursor_glyph)
25605 {
25606 25607
25608 cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
25609 cr.y = w->phys_cursor.y;
25610 cr.width = cursor_glyph->pixel_width;
25611 cr.height = w->phys_cursor_height;
25612 25613
25614 return x_intersect_rectangles (&cr, r, &result);
25615 }
25616
25617 return 0;
25618 }
25619
25620
25621 25622 25623
25624
25625 void
25626 x_draw_vertical_border (w)
25627 struct window *w;
25628 {
25629 struct frame *f = XFRAME (WINDOW_FRAME (w));
25630
25631 25632 25633
25634
25635 25636 25637 25638
25639 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
25640 return;
25641
25642 if (!WINDOW_RIGHTMOST_P (w)
25643 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
25644 {
25645 int x0, x1, y0, y1;
25646
25647 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
25648 y1 -= 1;
25649
25650 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
25651 x1 -= 1;
25652
25653 FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
25654 }
25655 else if (!WINDOW_LEFTMOST_P (w)
25656 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
25657 {
25658 int x0, x1, y0, y1;
25659
25660 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
25661 y1 -= 1;
25662
25663 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
25664 x0 -= 1;
25665
25666 FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
25667 }
25668 }
25669
25670
25671 25672 25673 25674
25675
25676 static int
25677 expose_window (w, fr)
25678 struct window *w;
25679 XRectangle *fr;
25680 {
25681 struct frame *f = XFRAME (w->frame);
25682 XRectangle wr, r;
25683 int mouse_face_overwritten_p = 0;
25684
25685 25686 25687 25688
25689 if (w->current_matrix == NULL)
25690 return 0;
25691
25692 25693 25694
25695 if (w == updated_window)
25696 {
25697 SET_FRAME_GARBAGED (f);
25698 return 0;
25699 }
25700
25701
25702 wr.x = WINDOW_LEFT_EDGE_X (w);
25703 wr.y = WINDOW_TOP_EDGE_Y (w);
25704 wr.width = WINDOW_TOTAL_WIDTH (w);
25705 wr.height = WINDOW_TOTAL_HEIGHT (w);
25706
25707 if (x_intersect_rectangles (fr, &wr, &r))
25708 {
25709 int yb = window_text_bottom_y (w);
25710 struct glyph_row *row;
25711 int cursor_cleared_p;
25712 struct glyph_row *first_overlapping_row, *last_overlapping_row;
25713
25714 TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
25715 r.x, r.y, r.width, r.height));
25716
25717
25718 r.x -= WINDOW_LEFT_EDGE_X (w);
25719 r.y -= WINDOW_TOP_EDGE_Y (w);
25720
25721
25722 if (!w->pseudo_window_p
25723 && phys_cursor_in_rect_p (w, &r))
25724 {
25725 x_clear_cursor (w);
25726 cursor_cleared_p = 1;
25727 }
25728 else
25729 cursor_cleared_p = 0;
25730
25731
25732 first_overlapping_row = last_overlapping_row = NULL;
25733 for (row = w->current_matrix->rows;
25734 row->enabled_p;
25735 ++row)
25736 {
25737 int y0 = row->y;
25738 int y1 = MATRIX_ROW_BOTTOM_Y (row);
25739
25740 if ((y0 >= r.y && y0 < r.y + r.height)
25741 || (y1 > r.y && y1 < r.y + r.height)
25742 || (r.y >= y0 && r.y < y1)
25743 || (r.y + r.height > y0 && r.y + r.height < y1))
25744 {
25745 25746
25747 if (row->overlapping_p && !row->mode_line_p)
25748 {
25749 if (first_overlapping_row == NULL)
25750 first_overlapping_row = row;
25751 last_overlapping_row = row;
25752 }
25753
25754 row->clip = fr;
25755 if (expose_line (w, row, &r))
25756 mouse_face_overwritten_p = 1;
25757 row->clip = NULL;
25758 }
25759 else if (row->overlapping_p)
25760 {
25761
25762 if (y0 < r.y
25763 ? y0 + row->phys_height > r.y
25764 : y0 + row->ascent - row->phys_ascent < r.y +r.height)
25765 {
25766 if (first_overlapping_row == NULL)
25767 first_overlapping_row = row;
25768 last_overlapping_row = row;
25769 }
25770 }
25771
25772 if (y1 >= yb)
25773 break;
25774 }
25775
25776
25777 if (WINDOW_WANTS_MODELINE_P (w)
25778 && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
25779 row->enabled_p)
25780 && row->y < r.y + r.height)
25781 {
25782 if (expose_line (w, row, &r))
25783 mouse_face_overwritten_p = 1;
25784 }
25785
25786 if (!w->pseudo_window_p)
25787 {
25788
25789 if (first_overlapping_row)
25790 expose_overlaps (w, first_overlapping_row, last_overlapping_row,
25791 fr);
25792
25793
25794 x_draw_vertical_border (w);
25795
25796
25797 if (cursor_cleared_p)
25798 update_window_cursor (w, 1);
25799 }
25800 }
25801
25802 return mouse_face_overwritten_p;
25803 }
25804
25805
25806
25807 25808 25809
25810
25811 static int
25812 expose_window_tree (w, r)
25813 struct window *w;
25814 XRectangle *r;
25815 {
25816 struct frame *f = XFRAME (w->frame);
25817 int mouse_face_overwritten_p = 0;
25818
25819 while (w && !FRAME_GARBAGED_P (f))
25820 {
25821 if (!NILP (w->hchild))
25822 mouse_face_overwritten_p
25823 |= expose_window_tree (XWINDOW (w->hchild), r);
25824 else if (!NILP (w->vchild))
25825 mouse_face_overwritten_p
25826 |= expose_window_tree (XWINDOW (w->vchild), r);
25827 else
25828 mouse_face_overwritten_p |= expose_window (w, r);
25829
25830 w = NILP (w->next) ? NULL : XWINDOW (w->next);
25831 }
25832
25833 return mouse_face_overwritten_p;
25834 }
25835
25836
25837 25838 25839 25840 25841
25842
25843 void
25844 expose_frame (f, x, y, w, h)
25845 struct frame *f;
25846 int x, y, w, h;
25847 {
25848 XRectangle r;
25849 int mouse_face_overwritten_p = 0;
25850
25851 TRACE ((stderr, "expose_frame "));
25852
25853
25854 if (FRAME_GARBAGED_P (f))
25855 {
25856 TRACE ((stderr, " garbaged\n"));
25857 return;
25858 }
25859
25860 25861 25862
25863 if (FRAME_FACE_CACHE (f) == NULL
25864 || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
25865 {
25866 TRACE ((stderr, " no faces\n"));
25867 return;
25868 }
25869
25870 if (w == 0 || h == 0)
25871 {
25872 r.x = r.y = 0;
25873 r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
25874 r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
25875 }
25876 else
25877 {
25878 r.x = x;
25879 r.y = y;
25880 r.width = w;
25881 r.height = h;
25882 }
25883
25884 TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
25885 mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
25886
25887 if (WINDOWP (f->tool_bar_window))
25888 mouse_face_overwritten_p
25889 |= expose_window (XWINDOW (f->tool_bar_window), &r);
25890
25891 #ifdef HAVE_X_WINDOWS
25892 #ifndef MSDOS
25893 #ifndef USE_X_TOOLKIT
25894 if (WINDOWP (f->menu_bar_window))
25895 mouse_face_overwritten_p
25896 |= expose_window (XWINDOW (f->menu_bar_window), &r);
25897 #endif
25898 #endif
25899 #endif
25900
25901 25902 25903 25904 25905 25906 25907 25908 25909 25910
25911 25912 25913
25914 if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
25915 {
25916 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
25917 if (f == dpyinfo->mouse_face_mouse_frame)
25918 {
25919 int x = dpyinfo->mouse_face_mouse_x;
25920 int y = dpyinfo->mouse_face_mouse_y;
25921 clear_mouse_face (dpyinfo);
25922 note_mouse_highlight (f, x, y);
25923 }
25924 }
25925 }
25926
25927
25928 25929 25930 25931
25932
25933 int
25934 x_intersect_rectangles (r1, r2, result)
25935 XRectangle *r1, *r2, *result;
25936 {
25937 XRectangle *left, *right;
25938 XRectangle *upper, *lower;
25939 int intersection_p = 0;
25940
25941
25942 if (r1->x < r2->x)
25943 left = r1, right = r2;
25944 else
25945 left = r2, right = r1;
25946
25947 25948
25949 if (right->x <= left->x + left->width)
25950 {
25951 result->x = right->x;
25952
25953 25954
25955 result->width = (min (left->x + left->width, right->x + right->width)
25956 - result->x);
25957
25958
25959 if (r1->y < r2->y)
25960 upper = r1, lower = r2;
25961 else
25962 upper = r2, lower = r1;
25963
25964 25965
25966 if (lower->y <= upper->y + upper->height)
25967 {
25968 result->y = lower->y;
25969
25970 25971
25972 result->height = (min (lower->y + lower->height,
25973 upper->y + upper->height)
25974 - result->y);
25975 intersection_p = 1;
25976 }
25977 }
25978
25979 return intersection_p;
25980 }
25981
25982 #endif
25983
25984
25985 25986 25987
25988
25989 void
25990 syms_of_xdisp ()
25991 {
25992 Vwith_echo_area_save_vector = Qnil;
25993 staticpro (&Vwith_echo_area_save_vector);
25994
25995 Vmessage_stack = Qnil;
25996 staticpro (&Vmessage_stack);
25997
25998 Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
25999 staticpro (&Qinhibit_redisplay);
26000
26001 message_dolog_marker1 = Fmake_marker ();
26002 staticpro (&message_dolog_marker1);
26003 message_dolog_marker2 = Fmake_marker ();
26004 staticpro (&message_dolog_marker2);
26005 message_dolog_marker3 = Fmake_marker ();
26006 staticpro (&message_dolog_marker3);
26007
26008 #if GLYPH_DEBUG
26009 defsubr (&Sdump_frame_glyph_matrix);
26010 defsubr (&Sdump_glyph_matrix);
26011 defsubr (&Sdump_glyph_row);
26012 defsubr (&Sdump_tool_bar_row);
26013 defsubr (&Strace_redisplay);
26014 defsubr (&Strace_to_stderr);
26015 #endif
26016 #ifdef HAVE_WINDOW_SYSTEM
26017 defsubr (&Stool_bar_lines_needed);
26018 defsubr (&Slookup_image_map);
26019 #endif
26020 defsubr (&Sformat_mode_line);
26021 defsubr (&Sinvisible_p);
26022 defsubr (&Scurrent_bidi_paragraph_direction);
26023
26024 staticpro (&Qmenu_bar_update_hook);
26025 Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
26026
26027 staticpro (&Qoverriding_terminal_local_map);
26028 Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
26029
26030 staticpro (&Qoverriding_local_map);
26031 Qoverriding_local_map = intern_c_string ("overriding-local-map");
26032
26033 staticpro (&Qwindow_scroll_functions);
26034 Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
26035
26036 staticpro (&Qwindow_text_change_functions);
26037 Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
26038
26039 staticpro (&Qredisplay_end_trigger_functions);
26040 Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
26041
26042 staticpro (&Qinhibit_point_motion_hooks);
26043 Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
26044
26045 Qeval = intern_c_string ("eval");
26046 staticpro (&Qeval);
26047
26048 QCdata = intern_c_string (":data");
26049 staticpro (&QCdata);
26050 Qdisplay = intern_c_string ("display");
26051 staticpro (&Qdisplay);
26052 Qspace_width = intern_c_string ("space-width");
26053 staticpro (&Qspace_width);
26054 Qraise = intern_c_string ("raise");
26055 staticpro (&Qraise);
26056 Qslice = intern_c_string ("slice");
26057 staticpro (&Qslice);
26058 Qspace = intern_c_string ("space");
26059 staticpro (&Qspace);
26060 Qmargin = intern_c_string ("margin");
26061 staticpro (&Qmargin);
26062 Qpointer = intern_c_string ("pointer");
26063 staticpro (&Qpointer);
26064 Qleft_margin = intern_c_string ("left-margin");
26065 staticpro (&Qleft_margin);
26066 Qright_margin = intern_c_string ("right-margin");
26067 staticpro (&Qright_margin);
26068 Qcenter = intern_c_string ("center");
26069 staticpro (&Qcenter);
26070 Qline_height = intern_c_string ("line-height");
26071 staticpro (&Qline_height);
26072 QCalign_to = intern_c_string (":align-to");
26073 staticpro (&QCalign_to);
26074 QCrelative_width = intern_c_string (":relative-width");
26075 staticpro (&QCrelative_width);
26076 QCrelative_height = intern_c_string (":relative-height");
26077 staticpro (&QCrelative_height);
26078 QCeval = intern_c_string (":eval");
26079 staticpro (&QCeval);
26080 QCpropertize = intern_c_string (":propertize");
26081 staticpro (&QCpropertize);
26082 QCfile = intern_c_string (":file");
26083 staticpro (&QCfile);
26084 Qfontified = intern_c_string ("fontified");
26085 staticpro (&Qfontified);
26086 Qfontification_functions = intern_c_string ("fontification-functions");
26087 staticpro (&Qfontification_functions);
26088 Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
26089 staticpro (&Qtrailing_whitespace);
26090 Qescape_glyph = intern_c_string ("escape-glyph");
26091 staticpro (&Qescape_glyph);
26092 Qnobreak_space = intern_c_string ("nobreak-space");
26093 staticpro (&Qnobreak_space);
26094 Qimage = intern_c_string ("image");
26095 staticpro (&Qimage);
26096 Qtext = intern_c_string ("text");
26097 staticpro (&Qtext);
26098 Qboth = intern_c_string ("both");
26099 staticpro (&Qboth);
26100 Qboth_horiz = intern_c_string ("both-horiz");
26101 staticpro (&Qboth_horiz);
26102 QCmap = intern_c_string (":map");
26103 staticpro (&QCmap);
26104 QCpointer = intern_c_string (":pointer");
26105 staticpro (&QCpointer);
26106 Qrect = intern_c_string ("rect");
26107 staticpro (&Qrect);
26108 Qcircle = intern_c_string ("circle");
26109 staticpro (&Qcircle);
26110 Qpoly = intern_c_string ("poly");
26111 staticpro (&Qpoly);
26112 Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
26113 staticpro (&Qmessage_truncate_lines);
26114 Qgrow_only = intern_c_string ("grow-only");
26115 staticpro (&Qgrow_only);
26116 Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
26117 staticpro (&Qinhibit_menubar_update);
26118 Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
26119 staticpro (&Qinhibit_eval_during_redisplay);
26120 Qposition = intern_c_string ("position");
26121 staticpro (&Qposition);
26122 Qbuffer_position = intern_c_string ("buffer-position");
26123 staticpro (&Qbuffer_position);
26124 Qobject = intern_c_string ("object");
26125 staticpro (&Qobject);
26126 Qbar = intern_c_string ("bar");
26127 staticpro (&Qbar);
26128 Qhbar = intern_c_string ("hbar");
26129 staticpro (&Qhbar);
26130 Qbox = intern_c_string ("box");
26131 staticpro (&Qbox);
26132 Qhollow = intern_c_string ("hollow");
26133 staticpro (&Qhollow);
26134 Qhand = intern_c_string ("hand");
26135 staticpro (&Qhand);
26136 Qarrow = intern_c_string ("arrow");
26137 staticpro (&Qarrow);
26138 Qtext = intern_c_string ("text");
26139 staticpro (&Qtext);
26140 Qrisky_local_variable = intern_c_string ("risky-local-variable");
26141 staticpro (&Qrisky_local_variable);
26142 Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
26143 staticpro (&Qinhibit_free_realized_faces);
26144
26145 list_of_error = Fcons (Fcons (intern_c_string ("error"),
26146 Fcons (intern_c_string ("void-variable"), Qnil)),
26147 Qnil);
26148 staticpro (&list_of_error);
26149
26150 Qlast_arrow_position = intern_c_string ("last-arrow-position");
26151 staticpro (&Qlast_arrow_position);
26152 Qlast_arrow_string = intern_c_string ("last-arrow-string");
26153 staticpro (&Qlast_arrow_string);
26154
26155 Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
26156 staticpro (&Qoverlay_arrow_string);
26157 Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
26158 staticpro (&Qoverlay_arrow_bitmap);
26159
26160 echo_buffer[0] = echo_buffer[1] = Qnil;
26161 staticpro (&echo_buffer[0]);
26162 staticpro (&echo_buffer[1]);
26163
26164 echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
26165 staticpro (&echo_area_buffer[0]);
26166 staticpro (&echo_area_buffer[1]);
26167
26168 Vmessages_buffer_name = make_pure_c_string ("*Messages*");
26169 staticpro (&Vmessages_buffer_name);
26170
26171 mode_line_proptrans_alist = Qnil;
26172 staticpro (&mode_line_proptrans_alist);
26173 mode_line_string_list = Qnil;
26174 staticpro (&mode_line_string_list);
26175 mode_line_string_face = Qnil;
26176 staticpro (&mode_line_string_face);
26177 mode_line_string_face_prop = Qnil;
26178 staticpro (&mode_line_string_face_prop);
26179 Vmode_line_unwind_vector = Qnil;
26180 staticpro (&Vmode_line_unwind_vector);
26181
26182 help_echo_string = Qnil;
26183 staticpro (&help_echo_string);
26184 help_echo_object = Qnil;
26185 staticpro (&help_echo_object);
26186 help_echo_window = Qnil;
26187 staticpro (&help_echo_window);
26188 previous_help_echo_string = Qnil;
26189 staticpro (&previous_help_echo_string);
26190 help_echo_pos = -1;
26191
26192 Qright_to_left = intern_c_string ("right-to-left");
26193 staticpro (&Qright_to_left);
26194 Qleft_to_right = intern_c_string ("left-to-right");
26195 staticpro (&Qleft_to_right);
26196
26197 #ifdef HAVE_WINDOW_SYSTEM
26198 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
26199 doc: 26200 26201 );
26202 x_stretch_cursor_p = 0;
26203 #endif
26204
26205 DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace,
26206 doc: 26207 );
26208 Vshow_trailing_whitespace = Qnil;
26209
26210 DEFVAR_LISP ("nobreak-char-display", &Vnobreak_char_display,
26211 doc: 26212 26213 26214 26215 26216 );
26217 Vnobreak_char_display = Qt;
26218
26219 DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer,
26220 doc: 26221 26222 );
26223 Vvoid_text_area_pointer = Qarrow;
26224
26225 DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay,
26226 doc: 26227 );
26228 Vinhibit_redisplay = Qnil;
26229
26230 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string,
26231 doc: );
26232 Vglobal_mode_string = Qnil;
26233
26234 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position,
26235 doc: 26236 26237 );
26238 Voverlay_arrow_position = Qnil;
26239
26240 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string,
26241 doc: 26242 );
26243 Voverlay_arrow_string = make_pure_c_string ("=>");
26244
26245 DEFVAR_LISP ("overlay-arrow-variable-list", &Voverlay_arrow_variable_list,
26246 doc: 26247 26248 );
26249 Voverlay_arrow_variable_list
26250 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
26251
26252 DEFVAR_INT ("scroll-step", &scroll_step,
26253 doc: 26254 26255 26256 26257 );
26258
26259 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively,
26260 doc: 26261 26262 26263 26264 26265 26266 );
26267 scroll_conservatively = 0;
26268
26269 DEFVAR_INT ("scroll-margin", &scroll_margin,
26270 doc: 26271 26272 );
26273 scroll_margin = 0;
26274
26275 DEFVAR_LISP ("display-pixels-per-inch", &Vdisplay_pixels_per_inch,
26276 doc: 26277 );
26278 Vdisplay_pixels_per_inch = make_float (72.0);
26279
26280 #if GLYPH_DEBUG
26281 DEFVAR_INT ("debug-end-pos", &debug_end_pos, doc: );
26282 #endif
26283
26284 DEFVAR_LISP ("truncate-partial-width-windows",
26285 &Vtruncate_partial_width_windows,
26286 doc: 26287 26288 26289 26290 26291 26292 26293 26294 26295 26296 );
26297 Vtruncate_partial_width_windows = make_number (50);
26298
26299 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video,
26300 doc: 26301 26302 );
26303 mode_line_inverse_video = 1;
26304
26305 DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit,
26306 doc: 26307 26308 );
26309 Vline_number_display_limit = Qnil;
26310
26311 DEFVAR_INT ("line-number-display-limit-width",
26312 &line_number_display_limit_width,
26313 doc: 26314 26315 );
26316 line_number_display_limit_width = 200;
26317
26318 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows,
26319 doc: );
26320 highlight_nonselected_windows = 0;
26321
26322 DEFVAR_BOOL ("multiple-frames", &multiple_frames,
26323 doc: 26324 26325 26326 );
26327
26328 DEFVAR_LISP ("frame-title-format", &Vframe_title_format,
26329 doc: 26330 26331 26332 26333 26334 );
26335
26336 DEFVAR_LISP ("icon-title-format", &Vicon_title_format,
26337 doc: 26338 26339 26340 26341 );
26342 Vicon_title_format
26343 = Vframe_title_format
26344 = pure_cons (intern_c_string ("multiple-frames"),
26345 pure_cons (make_pure_c_string ("%b"),
26346 pure_cons (pure_cons (empty_unibyte_string,
26347 pure_cons (intern_c_string ("invocation-name"),
26348 pure_cons (make_pure_c_string ("@"),
26349 pure_cons (intern_c_string ("system-name"),
26350 Qnil)))),
26351 Qnil)));
26352
26353 DEFVAR_LISP ("message-log-max", &Vmessage_log_max,
26354 doc: 26355 26356 );
26357 Vmessage_log_max = make_number (100);
26358
26359 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions,
26360 doc: 26361 26362 26363 26364 );
26365 Vwindow_size_change_functions = Qnil;
26366
26367 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions,
26368 doc: 26369 26370 26371 26372 );
26373 Vwindow_scroll_functions = Qnil;
26374
26375 DEFVAR_LISP ("window-text-change-functions",
26376 &Vwindow_text_change_functions,
26377 doc: );
26378 Vwindow_text_change_functions = Qnil;
26379
26380 DEFVAR_LISP ("redisplay-end-trigger-functions", &Vredisplay_end_trigger_functions,
26381 doc: 26382 26383 );
26384 Vredisplay_end_trigger_functions = Qnil;
26385
26386 DEFVAR_LISP ("mouse-autoselect-window", &Vmouse_autoselect_window,
26387 doc: 26388 26389 26390 26391 26392 26393 26394 26395 26396 26397 26398 26399 26400 26401 26402 26403 );
26404 Vmouse_autoselect_window = Qnil;
26405
26406 DEFVAR_LISP ("auto-resize-tool-bars", &Vauto_resize_tool_bars,
26407 doc: 26408 26409 26410 26411 );
26412 Vauto_resize_tool_bars = Qt;
26413
26414 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p,
26415 doc: );
26416 auto_raise_tool_bar_buttons_p = 1;
26417
26418 DEFVAR_BOOL ("make-cursor-line-fully-visible", &make_cursor_line_fully_visible_p,
26419 doc: );
26420 make_cursor_line_fully_visible_p = 1;
26421
26422 DEFVAR_LISP ("tool-bar-border", &Vtool_bar_border,
26423 doc: 26424 26425 26426 26427 );
26428 Vtool_bar_border = Qinternal_border_width;
26429
26430 DEFVAR_LISP ("tool-bar-button-margin", &Vtool_bar_button_margin,
26431 doc: 26432 26433 26434 26435 );
26436 Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
26437
26438 DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief,
26439 doc: );
26440 tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
26441
26442 DEFVAR_LISP ("tool-bar-style", &Vtool_bar_style,
26443 doc: 26444 26445 26446 26447 26448 26449 );
26450 Vtool_bar_style = Qnil;
26451
26452 DEFVAR_INT ("tool-bar-max-label-size", &tool_bar_max_label_size,
26453 doc: 26454 26455 );
26456 tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
26457
26458 DEFVAR_LISP ("fontification-functions", &Vfontification_functions,
26459 doc: 26460 26461 26462 );
26463 Vfontification_functions = Qnil;
26464 Fmake_variable_buffer_local (Qfontification_functions);
26465
26466 DEFVAR_BOOL ("unibyte-display-via-language-environment",
26467 &unibyte_display_via_language_environment,
26468 doc: 26469 26470 26471 26472 26473 26474 26475 );
26476 unibyte_display_via_language_environment = 0;
26477
26478 DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height,
26479 doc: 26480 26481 );
26482 Vmax_mini_window_height = make_float (0.25);
26483
26484 DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows,
26485 doc: 26486 26487 26488 26489 26490 );
26491 Vresize_mini_windows = Qgrow_only;
26492
26493 DEFVAR_LISP ("blink-cursor-alist", &Vblink_cursor_alist,
26494 doc: 26495 26496 26497 26498 26499 26500 26501 26502 );
26503 Vblink_cursor_alist = Qnil;
26504
26505 DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p,
26506 doc: );
26507 automatic_hscrolling_p = 1;
26508 Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
26509 staticpro (&Qauto_hscroll_mode);
26510
26511 DEFVAR_INT ("hscroll-margin", &hscroll_margin,
26512 doc: 26513 );
26514 hscroll_margin = 5;
26515
26516 DEFVAR_LISP ("hscroll-step", &Vhscroll_step,
26517 doc: 26518 26519 26520 26521 26522 26523 26524 26525 26526 26527 26528 26529 26530 26531 );
26532 Vhscroll_step = make_number (0);
26533
26534 DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines,
26535 doc: 26536 );
26537 message_truncate_lines = 0;
26538
26539 DEFVAR_LISP ("menu-bar-update-hook", &Vmenu_bar_update_hook,
26540 doc: 26541 26542 26543 );
26544 Vmenu_bar_update_hook = Qnil;
26545
26546 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame,
26547 doc: 26548 );
26549 Vmenu_updating_frame = Qnil;
26550
26551 DEFVAR_BOOL ("inhibit-menubar-update", &inhibit_menubar_update,
26552 doc: );
26553 inhibit_menubar_update = 0;
26554
26555 DEFVAR_LISP ("wrap-prefix", &Vwrap_prefix,
26556 doc: 26557 26558 26559 26560 26561 26562 26563 );
26564 Vwrap_prefix = Qnil;
26565 staticpro (&Qwrap_prefix);
26566 Qwrap_prefix = intern_c_string ("wrap-prefix");
26567 Fmake_variable_buffer_local (Qwrap_prefix);
26568
26569 DEFVAR_LISP ("line-prefix", &Vline_prefix,
26570 doc: 26571 26572 26573 26574 26575 26576 26577 );
26578 Vline_prefix = Qnil;
26579 staticpro (&Qline_prefix);
26580 Qline_prefix = intern_c_string ("line-prefix");
26581 Fmake_variable_buffer_local (Qline_prefix);
26582
26583 DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay,
26584 doc: );
26585 inhibit_eval_during_redisplay = 0;
26586
26587 DEFVAR_BOOL ("inhibit-free-realized-faces", &inhibit_free_realized_faces,
26588 doc: );
26589 inhibit_free_realized_faces = 0;
26590
26591 #if GLYPH_DEBUG
26592 DEFVAR_BOOL ("inhibit-try-window-id", &inhibit_try_window_id,
26593 doc: );
26594 inhibit_try_window_id = 0;
26595
26596 DEFVAR_BOOL ("inhibit-try-window-reusing", &inhibit_try_window_reusing,
26597 doc: );
26598 inhibit_try_window_reusing = 0;
26599
26600 DEFVAR_BOOL ("inhibit-try-cursor-movement", &inhibit_try_cursor_movement,
26601 doc: );
26602 inhibit_try_cursor_movement = 0;
26603 #endif
26604
26605 DEFVAR_INT ("overline-margin", &overline_margin,
26606 doc: 26607 26608 );
26609 overline_margin = 2;
26610
26611 DEFVAR_INT ("underline-minimum-offset",
26612 &underline_minimum_offset,
26613 doc: 26614 26615 26616 26617 );
26618 underline_minimum_offset = 1;
26619
26620 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
26621 doc: );
26622 display_hourglass_p = 1;
26623
26624 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
26625 doc: 26626 );
26627 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
26628
26629 hourglass_atimer = NULL;
26630 hourglass_shown_p = 0;
26631 }
26632
26633
26634
26635
26636 void
26637 init_xdisp ()
26638 {
26639 Lisp_Object root_window;
26640 struct window *mini_w;
26641
26642 current_header_line_height = current_mode_line_height = -1;
26643
26644 CHARPOS (this_line_start_pos) = 0;
26645
26646 mini_w = XWINDOW (minibuf_window);
26647 root_window = FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w)));
26648
26649 if (!noninteractive)
26650 {
26651 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
26652 int i;
26653
26654 XWINDOW (root_window)->top_line = make_number (FRAME_TOP_MARGIN (f));
26655 set_window_height (root_window,
26656 FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f),
26657 0);
26658 mini_w->top_line = make_number (FRAME_LINES (f) - 1);
26659 set_window_height (minibuf_window, 1, 0);
26660
26661 XWINDOW (root_window)->total_cols = make_number (FRAME_COLS (f));
26662 mini_w->total_cols = make_number (FRAME_COLS (f));
26663
26664 scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
26665 scratch_glyph_row.glyphs[TEXT_AREA + 1]
26666 = scratch_glyphs + MAX_SCRATCH_GLYPHS;
26667
26668
26669 for (i = 0; i < 3; ++i)
26670 default_invis_vector[i] = make_number ('.');
26671 }
26672
26673 {
26674 26675
26676 int size = 100;
26677 mode_line_noprop_buf = (char *) xmalloc (size);
26678 mode_line_noprop_buf_end = mode_line_noprop_buf + size;
26679 mode_line_noprop_ptr = mode_line_noprop_buf;
26680 mode_line_target = MODE_LINE_DISPLAY;
26681 }
26682
26683 help_echo_showing_p = 0;
26684 }
26685
26686 26687
26688 #ifndef WINDOWSNT
26689
26690
26691
26692
26693 int
26694 hourglass_started ()
26695 {
26696 return hourglass_shown_p || hourglass_atimer != NULL;
26697 }
26698
26699
26700 void
26701 start_hourglass ()
26702 {
26703 #if defined (HAVE_WINDOW_SYSTEM)
26704 EMACS_TIME delay;
26705 int secs, usecs = 0;
26706
26707 cancel_hourglass ();
26708
26709 if (INTEGERP (Vhourglass_delay)
26710 && XINT (Vhourglass_delay) > 0)
26711 secs = XFASTINT (Vhourglass_delay);
26712 else if (FLOATP (Vhourglass_delay)
26713 && XFLOAT_DATA (Vhourglass_delay) > 0)
26714 {
26715 Lisp_Object tem;
26716 tem = Ftruncate (Vhourglass_delay, Qnil);
26717 secs = XFASTINT (tem);
26718 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
26719 }
26720 else
26721 secs = DEFAULT_HOURGLASS_DELAY;
26722
26723 EMACS_SET_SECS_USECS (delay, secs, usecs);
26724 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
26725 show_hourglass, NULL);
26726 #endif
26727 }
26728
26729
26730 26731
26732 void
26733 cancel_hourglass ()
26734 {
26735 #if defined (HAVE_WINDOW_SYSTEM)
26736 if (hourglass_atimer)
26737 {
26738 cancel_atimer (hourglass_atimer);
26739 hourglass_atimer = NULL;
26740 }
26741
26742 if (hourglass_shown_p)
26743 hide_hourglass ();
26744 #endif
26745 }
26746 #endif
26747
26748 26749