Merge from trunk.

74 files changed, 4497 insertions, 2073 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 1bfc293c466..275a1d8db88 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -67,7 +67,7 @@ define xgettype
   else
     set $bugfix = $arg0
   end
-  set $type = (enum Lisp_Type) (USE_LSB_TAG ? $bugfix & (1 << GCTYPEBITS) - 1 : $bugfix >> VALBITS)
+  set $type = (enum Lisp_Type) (USE_LSB_TAG ? $bugfix & (1 << GCTYPEBITS) - 1 : (EMACS_UINT) $bugfix >> VALBITS)
 end
 
 # Set up something to print out s-expressions.
diff --git a/src/ChangeLog b/src/ChangeLog
index a2dfa5bf613..e67fdada36f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,10 +1,766 @@
+2013-12-07  Jan Djärv  <jan.h.d@swipnet.se>
+
+        Pixel resize changes for NS (Bug#16049).
+        * nsterm.m (x_set_window_size): Change parameters rows/cols to
+        height/width.  row/cols are locals.
+        Pass pixelwise to check_frame_size.  Don't set FRAME_PIXEL_WIDTH/HEIGHT.
+        (updateFrameSize:): Remove gsextra.  Adjust for pixelwise resize.
+        (windowWillResize): Remove gsextra.  Calculate extra as in
+        updateFrameSize.
+        (x_new_font): Don't change frame size if fullscreen.  Change
+        size pixelwise.
+
+        * nsfns.m (Fx_create_frame): Call change_frame_size twice as per
+        comment in xfns.c.  Change to pixelwise call.
+
+2013-12-06  Eli Zaretskii  <eliz@gnu.org>
+
+        * buffer.c (Fset_buffer_multibyte): Invalidate buffer caches.
+        (Bug#16070)
+
+2013-12-06  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xterm.c (input_signal_count): Remove.
+        (x_dispatch_event): Define unconditionally.
+        (x_make_frame_visible): Process X events until the frame
+        is really visible (Bug#16027).
+        * xterm.h (x_dispatch_event): Declare unconditionally.
+
+2013-12-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfns.m (ns_frame_parm_handlers): Add right/bottom_divider_width.
+
+        * nsterm.m (x_set_window_size): Handle pixelwise.
+
+2013-12-05  Martin Rudalics  <rudalics@gmx.at>
+
+        * w32term.c (x_new_font):
+        * xterm.c (x_new_font): Calculate new frame size from new font
+        size (Bug#16028).
+
+2013-12-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h (FOR_EACH_TAIL): New macro.
+        * fns.c (Fdelq): Use it to avoid inf-loops; remove QUIT.
+
+        * window.c (select_window): Call second wset_redisplay before we change
+        selected_window (bug#16034).
+
+2013-12-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * bidi.c (LRM_CHAR, RLM_CHAR): Remove; no longer used.
+
+2013-12-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32xfns.c: Include window.h, to avoid a compiler warning.
+
+2013-12-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * window.c (window_scroll): Mark window for redisplay (bug#16034).
+        (scroll_command, Fscroll_other_window): Don't cause redisplay now that
+        window_scroll takes care of it.
+        (Fset_window_point, Fdelete_other_windows_internal)
+        (set_window_buffer, Fwindow_resize_apply, resize_frame_windows)
+        (Fsplit_window_internal, Fdelete_window_internal)
+        (Fresize_mini_window_internal, Fset_window_configuration)
+        (apply_window_adjustment): Use fset_redisplay and wset_redisplay to
+        cause redisplay instead of forcing a complete redisplay.
+        * xdisp.c (wset_redisplay): Don't set windows_or_buffers_changed if
+        we're only affecting the selected_window.
+
+2013-12-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_get_type, bidi_get_category): Handle the isolate
+        directional control characters.  Update type and category
+        determination according to the UBA from Unicode v6.3.
+        (bidi_category_t): New category EXPLICIT_FORMATTING.
+
+        * dispextern.h (bidi_type_t): Update to include new bidirectional
+        properties introduced with Unicode v6.3.  (Bug#16043)
+
+2013-12-04  Martin Rudalics  <rudalics@gmx.at>
+
+        * xterm.c (XTflash): Fix coordinate of bottom area to flash
+        (Bug#16044).
+
+2013-12-04  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.c (font_list_entities): Remove dummy assignment.
+        * font.h (struct font) [HAVE_WINDOW_SYSTEM]: Group members which are
+        used on graphic displays only.  Remove unused 'font_encoder' member.
+        (struct font_bitmap): Remove unused 'extra' member.
+        * nsfont.m (nsfont_open):
+        * w32font.c (w32font_open_internal):
+        * ftfont.c (ftfont_get_bitmap): Adjust users.
+
+2013-12-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use bool for boolean.
+        * tparam.c (tparam1):
+        * undo.c (record_point, record_property_change):
+        Use bool for boolean, for local vars that are always true or false.
+
+        Minor integer overflow fixes (Bug#16033).
+        * window.c (Fset_window_new_pixel): Don't let new_pixel go negative.
+        This improves on the previous fix to this function.
+        (window_resize_check): When summing up pixel counts, don't rely on
+        undefined behavior if the sum overflows.
+
+2013-12-03  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fset_window_new_pixel): Don't choke at negative
+        argument value (Bug#16033).
+
+        * xfns.c (Fx_create_frame): Add another call to change_frame_size
+        to avoid crash in window_box_height.
+
+        * gtkutil.h: Fix external declaration of xg_frame_set_char_size.
+        * gtkutil.c (xg_frame_set_char_size, style_changed_cb): Fix size
+        calculation.
+        * xterm.c (x_set_window_size): Fix size calculation (Bug#16013).
+
+2013-12-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor integer overflow fixes.
+        * window.c (Fset_window_new_pixel, grow_mini_window):
+        * xdisp.c (Fwindow_text_pixel_size):
+        Avoid undefined behavior on signed integer overflow.
+        * xfns.c (x_set_mouse_color):
+        Check that drag shape fits in 'unsigned', since that's what X wants.
+
+2013-12-02  Eli Zaretskii  <eliz@gnu.org>
+
+        Improve reporting of fatal exception on MS-Windows.
+        * w32fns.c (my_exception_handler): New function.
+        (globals_of_w32fns): Set it up as the unhandled exception
+        handler.  Initialize exception code and address to zeros.
+        (emacs_abort): If the exception code and address are available,
+        print them at the beginning of the backtrace.  Fix the format of
+        printing addresses (was producing 0x0x12345678 on XP).
+        (Bug#15994)
+
+2013-12-02  Helmut Eller  <eller.helmut@gmail.com>
+
+        * eval.c (Fbacktrace__locals): New function.
+        (syms_of_eval): Defsubr it.
+
+2013-12-02  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.h (FONT_WIDTH, FONT_HEIGHT, FONT_BASE, FONT_DESCENT):
+        Define here to unify between...
+        * nsterm.h, w32term.h, xterm.h: ...port-specific headers.
+        * w32term.h (CHECK_W32_FRAME): Remove unused macro.
+
+2013-12-02  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * xterm.h (struct scroll_bar): Remove member `fringe_extended_p'.
+
+        * xterm.c (x_draw_fringe_bitmap, x_scroll_run): Remove code for
+        fringe background extension.
+        (x_scroll_bar_create): Remove variables `sb_left' and `sb_width',
+        because they are now always the same as `left' and `width',
+        respectively.  Remove code for the case that `width' and
+        `sb_width' are different.
+
+2013-12-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * dispextern.h, xdisp.c (x_draw_bottom_divider): Now static.
+        * frame.c (set_frame_param) [!HAVE_NTGUI]: Remove.
+        * xdisp.c (Ftool_bar_height) [USE_GTK || HAVE_NS]: Now const function.
+
+2013-12-01  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * image.c (imagemagick_compute_animated_image): Don't crash if we
+        have an animation with different-sized images (bug#15313).
+
+2013-11-30  Martin Rudalics  <rudalics@gmx.at>
+
+        Remove some unused items introduced during pixelwise change.
+        * window.c (window_resize_total_check): Remove unused function.
+        * xdisp.c (remember_mouse_glyph): Remove unused label.
+        (Ftool_bar_height): Move declaration inside #if.
+        * xterm.c (x_set_window_size): Don't use r and c.
+
+2013-11-30  Juanma Barranquero  <lekktu@gmail.com>
+
+        * xdisp.c (Fwindow_text_pixel_size): Remove unused variables
+        `value' and `endp'.
+
+        * window.c (Fset_window_configuration): Comment out unused variables.
+
+        * w32term.c (w32_read_socket): Remove unused variable `buf'.
+
+2013-11-30  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xdisp.c (redisplay_internal): unrequest_sigio => request_sigio.
+
+        * xfaces.c (NEAR_SAME_COLOR_THRESHOLD): Move inside HAVE_WINDOW_SYSTEM.
+
+        * gnutls.c (gnutls_audit_log_function): Only declare and define if
+        HAVE_GNUTLS3 (Bug#16001).
+
+        * xdisp.c (redisplay_internal): Call request_sigio at end_of_redisplay
+        if interrupts are deferred (Bug#15801).
+
+2013-11-30  Martin Rudalics  <rudalics@gmx.at>
+
+        Support resizing frames and windows pixelwise.
+        * dispextern.h (enum window_part): Add ON_SCROLL_BAR,
+        ON_RIGHT_DIVIDER and ON_BOTTOM_DIVIDER.
+        (struct glyph_matrix): Replace window_left_col and
+        window_top_line by window_pixel_left and window_pixel_top.
+        (WINDOW_WANTS_MODELINE_P, WINDOW_WANTS_HEADER_LINE_P): Minor
+        rewrite.
+        (enum face_id): Add WINDOW_DIVIDER_FACE_ID.
+        (draw_window_divider, move_it_to, x_draw_right_divider)
+        (x_draw_bottom_divider, change_frame_size): Add or fix
+        declarations.
+        * dispnew.c (change_frame_size_1): Change prototype.
+        (adjust_glyph_matrix, required_matrix_width)
+        (adjust_frame_glyphs_for_window_redisplay): Use pixel
+        values instead of lines and columns.
+        (marginal_area_string): Use WINDOW_FRINGES_WIDTH instead of
+        WINDOW_TOTAL_FRINGE_WIDTH.
+        (handle_window_change_signal, do_pending_window_change)
+        (init_display): Adjusts calls of change_frame_size.
+        (change_frame_size, change_frame_size_1): Handle pixelwise
+        changes.
+        * frame.c (Qright_divider_width, Qbottom_divider_width): New
+        Lisp objects.
+        (set_menu_bar_lines_1, set_menu_bar_lines, make_frame)
+        (make_terminal_frame, Fmake_terminal_frame, Fframe_parameters)
+        (x_set_internal_border_width, x_set_vertical_scroll_bars)
+        (x_set_scroll_bar_width, x_figure_window_size): Handle pixel
+        values.
+        (set_frame_param): New function.
+        (Fframe_text_cols, Fframe_text_lines, Fframe_total_cols)
+        (Fframe_text_width, Fframe_text_height, Fscroll_bar_width)
+        (Ffringe_width, Fborder_width, Fright_divider_width)
+        (Fbottom_divider_width): New functions, defsubr them.
+        (Fset_frame_height, Fset_frame_width, Fset_frame_size): New
+        argument pixelwise.
+        (struct frame_parm_table): New members Qright_divider_width and
+        Qbottom_divider_width.
+        (x_set_frame_parameters): Handle parameters for pixelwise sizes.
+        (x_report_frame_params): Handle Qright_divider_width and
+        Qbottom_divider_width.
+        (x_set_right_divider_width, x_set_bottom_divider_width): New
+        functions.
+        (frame_resize_pixelwise): New option.
+        * frame.h (struct frame): Add tool_bar_height, menu_bar_height,
+        new_pixelwise, right_divider_width and bottom_divider_width;
+        remove total_lines; rename text_lines, text_cols, new_text_lines
+        and new_text_cols to text_height, text_width, new_height and
+        new_width respectively.
+        (FRAME_LINES, FRAME_COLS): Rename to FRAME_TEXT_HEIGHT and
+        FRAME_TEXT_WIDTH respectively.
+        (FRAME_MENU_BAR_HEIGHT, FRAME_TOOL_BAR_HEIGHT)
+        (FRAME_RIGHT_DIVIDER_WIDTH, FRAME_BOTTOM_DIVIDER_WIDTH)
+        (FRAME_TEXT_TO_PIXEL_WIDTH, FRAME_PIXEL_TO_TEXT_WIDTH): New
+        macros.
+        (FRAME_TOP_MARGIN_HEIGHT, FRAME_LEFT_SCROLL_BAR_AREA_WIDTH)
+        (FRAME_RIGHT_SCROLL_BAR_AREA_WIDTH, FRAME_SCROLL_BAR_AREA_WIDTH)
+        (SET_FRAME_COLS, SET_FRAME_WIDTH, SET_FRAME_HEIGHT)
+        (FRAME_TEXT_COLS_TO_PIXEL_WIDTH, FRAME_PIXEL_WIDTH_TO_TEXT_COLS)
+        (FRAME_TEXT_COLS_TO_PIXEL_WIDTH): Rewrite macros.
+        (FRAME_TOTAL_COLS_ARG): Remove macro.
+        * fringe.c (draw_fringe_bitmap_1): Handle right divder.
+        * gtkutil.c (xg_frame_resized, xg_frame_set_char_size)
+        (x_wm_set_size_hint): Handle frame pixel sizes.
+        * indent.c (compute_motion, Fcompute_motion): Call
+        window_body_width instead of window_body_cols.
+        * keyboard.c (Qright_divider, Qbottom_divider): New symbols.
+        (make_lispy_position): Handle right and bottom dividers.
+        (Fsuspend_emacs): Pixelize call of change_frame_size.
+        * keyboard.h: Extern Qright_divider, Qbottom_divider.
+        * lisp.h: Extern set_frame_param.
+        * nsfns.m (x_set_tool_bar_lines): Pixelize call of
+        x_set_window_size.
+        (Fx_create_frame): Add entry for vertical_drag_cursor.  Pixelize
+        call of change_frame_size.
+        * nsterm.h (struct ns_output): Add vertical_drag_cursor.
+        * nsterm.m (ns_update_window_end): Optionally draw right
+        divider.
+        (x_set_window_size): Add argument pixelwise.  Call
+        check_frame_size and change_frame_size with pixelwise zero.
+        (ns_draw_window_divider): New function.
+        (ns_redisplay_interface): Add ns_draw_window_divider.
+        (updateFrameSize:): Call change_frame_size with pixelwise zero.
+        (x_new_font): Call x_set_window_size with pixelwise zero.
+        * print.c (print_object): For a window print its sequence
+        number again.
+        * term.c (Fresume_tty): Pixelize call of change_frame_size.
+        * w32fns.c (x_set_mouse_color): Handle vertical drag cursor.
+        (x_set_menu_bar_lines, x_set_tool_bar_lines): Calculate pixelwise.
+        (w32_createwindow): Use scroll bar area width.
+        (w32_wnd_proc): Handle bottom divider width.  For
+        WM_WINDOWPOSCHANGING return zero if we resize pixelwise.
+        (Fx_create_frame): Default divider width parameters.  Caclulate
+        sizes pixelwise.  Add vertical drag cursor support.
+        (x_create_tip_frame): Default divider widths to zero.  Pixelize
+        call to change_frame_size.
+        (Fx_show_tip): Add handling of divider widths.  Pixelize window
+        position and sizes.
+        (Fw32_frame_rect): New function.
+        (frame_parm_handler w32_frame_parm_handlers): Add divider
+        widths.
+        (Vx_window_vertical_drag_shape): Add variable.
+        * w32inevt.c (resize_event, maybe_generate_resize_event):
+        Pixelize change_frame_size calls.
+        * w32menu.c (set_frame_menubar): Pixelize x_set_window_size
+        call.
+        * w32term.c (w32_draw_window_divider): New function.
+        (x_update_window_end): Handle right divider.
+        (w32_draw_fringe_bitmap, x_scroll_run)
+        (w32_set_vertical_scroll_bar): Pixelize scrollbar widths.
+        (w32_read_socket): Handle SIZE_MAXIMIZED separately.  Calculate
+        new frame sizes pixelwise.
+        (x_new_font): Pixelize call to x_set_window_size.
+        (x_check_fullscreen): Pixelize call to change_frame_size.
+        (x_set_window_size_1, x_set_window_size): New argument
+        pixelwise.  Calculate pixelwise.
+        (x_wm_set_size_hint): Use scroll bar area width.
+        (w32_redisplay_interface): Add w32_draw_window_divider.
+        * w32term.h (struct w32_output): Add vertical drag cursor.
+        * widget.c (set_frame_size, update_wm_hints)
+        (EmacsFrameResize, EmacsFrameSetValues): Pixelize calls of
+        change_frame_size.
+        (EmacsFrameSetCharSize): Pixelize call of x_set_window_size.
+        * window.c (sequence_number): Restore.
+        (Fwindow_pixel_width, Fwindow_pixel_height)
+        (Fwindow_mode_line_height, Fwindow_header_line_height)
+        (window_pixel_to_total, Frun_window_scroll_functions)
+        (Fset_window_new_pixel, window_resize_apply_total)
+        (Fwindow_resize_apply_total): New functions.
+        (window_body_height, window_body_width): Rename from
+        window_body_lines.  New argument PIXELWISE.  Calculate
+        pixelwise.
+        (Fwindow_body_height, Fwindow_body_width): New argument
+        PIXELWISE.
+        (coordinates_in_window, window_relative_x_coord): Use window's
+        pixel width instead of total width.
+        (replace_window, recombine_windows): Initialize pixel values.
+        (resize_root_window, resize_frame_windows, grow_mini_window)
+        (shrink_mini_window): New argument PIXELWISE.  Calculate
+        pixelwise.
+        (Fdelete_other_windows_internal, adjust_window_margins)
+        (window_resize_check, window_resize_apply)
+        (Fdelete_window_internal, Fresize_mini_window_internal)
+        (Fwindow_text_width, Fwindow_text_height): Calculate pixelwise.
+        (check_frame_size): Rename arguments.  New argument PIXELWISE.
+        Calculate pixelwise.
+        (set_window_buffer): Make samebuf bool.  Run configuration change
+        hook only if buffer changed.
+        (Fset_window_buffer): Rewrite doc-string.
+        (make_window): Initialize new_pixel slot.
+        (Fwindow_resize_apply): Check pixel size of root window.
+        (Fsplit_window_internal): Call 2nd argument pixel_size.
+        Calculate pixelwise.
+        (Fscroll_left, Fscroll_right): Call window_body_width instead of
+        window_body_cols.
+        (save_window_data): New slots frame_text_width,
+        frame_text_height, frame_menu_bar_height, frame_tool_bar_height.
+        (saved_window): New slots pixel_left, pixel_top, pixel_height,
+        pixel_width.
+        (Fcurrent_window_configuration, Fset_window_configuration)
+        (save_window_save, compare_window_configurations): Handle new
+        slots in save_window_data and saved_window.
+        (Fset_window_scroll_bars): Fix doc-string.
+        (window_resize_pixelwise): New variable.
+        (coordinates_in_window, Fcoordinates_in_window_p): Handle
+        dividers.
+        (make_parent_window): Adjust sequence_number.
+        (Fwindow_right_divider_width, Fwindow_bottom_divider_width): New
+        functions.
+        * window.h (struct window): New members new_pixel, pixel_left,
+        pixel_top, pixel_width, pixel_height.  Restore sequence_number.
+        (wset_new_pixel): New function.
+        (WINDOW_PIXEL_WIDTH, WINDOW_PIXEL_HEIGHT)
+        (MIN_SAFE_WINDOW_PIXEL_WIDTH, MIN_SAFE_WINDOW_PIXEL_HEIGHT)
+        (WINDOW_LEFT_PIXEL_EDGE, WINDOW_RIGHT_PIXEL_EDGE)
+        (WINDOW_TOP_PIXEL_EDGE, WINDOW_BOTTOM_PIXEL_EDGE)
+        (WINDOW_BOTTOMMOST_P, WINDOW_BOX_LEFT_PIXEL_EDGE)
+        (WINDOW_BOX_RIGHT_PIXEL_EDGE, WINDOW_MARGINS_COLS)
+        (WINDOW_MARGINS_WIDTH, WINDOW_RIGHT_DIVIDER_WIDTH)
+        (WINDOW_BOTTOM_DIVIDER_WIDTH): New macros.
+        (WINDOW_TOTAL_FRINGE_WIDTH): Rename to WINDOW_FRINGES_WIDTH.
+        (WINDOW_TOTAL_WIDTH, WINDOW_TOTAL_HEIGHT): Remove macros.
+        (WINDOW_RIGHT_EDGE_X, WINDOW_LEFT_EDGE_X, WINDOW_TOP_EDGE_Y)
+        (WINDOW_BOTTOM_EDGE_Y, WINDOW_FULL_WIDTH_P, WINDOW_LEFTMOST_P)
+        (WINDOW_RIGHTMOST_P, WINDOW_BOX_LEFT_EDGE_X)
+        (WINDOW_BOX_RIGHT_EDGE_X, WINDOW_FRINGE_COLS)
+        (WINDOW_BOX_HEIGHT_NO_MODE_LINE, WINDOW_BOX_TEXT_HEIGHT):
+        Rewrite.
+        (resize_frame_windows, grow_mini_window, shrink_mini_window)
+        (window_body_width, check_frame_size): Adapt external declarations.
+        * xdisp.c (last_max_ascent): New integer.
+        (window_text_bottom_y): Handle bottom divider.
+        (window_box_width, window_box_height): Calculate pixelwise.
+        (get_glyph_string_clip_rects): Handle right divider.
+        (remember_mouse_glyph): When windows are resized pixelwise
+        proceed with width and height set to 1.
+        (init_iterator): Use WINDOW_PIXEL_WIDTH instead of
+        WINDOW_TOTAL_WIDTH.
+        (move_it_to): Calculate and return maximum x position
+        encountered.
+        (Fwindow_text_pixel_size): New function.
+        (resize_mini_window, update_tool_bar): Calculate pixelwise.
+        (tool_bar_lines_needed): Rename to tool_bar_height.  Calculate
+        pixelwise.
+        (Ftool_bar_lines_needed): Rename to Ftool_bar_height.  Calculate
+        pixelwise.
+        (redisplay_tool_bar): Calculate pixelwise.
+        (redisplay_window): Calculate pixelwise.  Handle dividers.
+        (draw_glyphs, x_clear_end_of_line, note_mouse_highlight)
+        (x_draw_vertical_border): Handle dividers.
+        (define_frame_cursor1): Handle vertical drag cursor.
+        (x_draw_right_divider, x_draw_bottom_divider): New functions.
+        (expose_window): Calculate pixelwise.  Handle dividers.
+        (init_xdisp): Initialize pixel values.
+        * xfaces.c (Qwindow_divider): New face.
+        (realize_basic_faces): Realize it.
+        * xfns.c (x_set_mouse_color): Handle vertical_drag_cursor.
+        (x_set_menu_bar_lines, x_set_tool_bar_lines): Calculate pixelwise.
+        (x_set_scroll_bar_default_width): Default actual width to 16.
+        (Fx_create_frame): Set sizes pixelwise.
+        (x_create_tip_frame): Default divider widths to zero.  Pixelize
+        call of change_frame_size.
+        (Fx_show_tip): Handle divider widths.  Initial pixel position
+        and sizes.
+        (frame_parm_handler x_frame_parm_handlers): Add divider widths.
+        (Vx_window_vertical_drag_shape): New option.
+        * xmenu.c (free_frame_menubar): Pixelize call of
+        x_set_window_size.
+        * xterm.c (x_draw_window_divider): New function.
+        (x_update_window_end): Optionally draw right divider.
+        (x_draw_fringe_bitmap, x_scroll_run, x_scroll_bar_create)
+        (XTset_vertical_scroll_bar): Use scroll bar pixel width.
+        (handle_one_xevent, x_new_font): Calculate pixelwise.
+        (x_set_window_size_1, x_set_window_size): New argument
+        pixelwise.  Calculate pixelwise.
+        (x_wm_set_size_hint): Pixelize call of check_frame_size.
+        (struct x_redisplay_interface): Add x_draw_window_divider.
+        * xterm.h (struct x_output): Add vertical_drag_cursor.
+
+2013-11-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (redisplay_internal): Don't call set_window_update_flags.
+        Set invisible frames's `redisplay' when a full redisplay is requested.
+        (redisplay_window): Set must_be_updated_p instead (bug#15999).
+        (redisplay_mode_lines): Don't set must_be_updated_p any more.
+        (display_mode_lines): Set it here instead.
+
+        * dispnew.c (set_window_update_flags): Remove `b' argument; make static.
+
+        * dispextern.h (set_window_update_flags): Remove.
+
+2013-11-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * fns.c (internal_equal): Add a hash_table argument to handle cycles.
+
+        * xdisp.c (REDISPLAY_SOME_P): New macro.
+        (redisplay_internal): Use it (bug#15999).
+        (prepare_menu_bars, redisplay_window): Use it as well.
+
+        * lisp.mk (lisp): Add electric.elc and uniquify.elc.
+
+2013-11-29  Tom Seddon  <emacs@tomseddon.plus.com>  (tiny change)
+
+        * w32font.c (g_b_init_get_char_width_32_w): New static var.
+        (globals_of_w32font): Zero it out.
+        (GetCharWidth32W_Proc): New function pointer.
+        (get_char_width_32_w): New function.
+        (compute_metrics): If get_glyph_outline_w returns an error, try
+        get_char_width_32_w before declaring a failure.  This avoids
+        punishing raster (a.k.a. "bitmap") fonts by slowing down
+        redisplay.  (Bug#6364).
+
+2013-11-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (clear_mouse_face): Don't invalidate the entire
+        mouse-highlight info, just signal frame_up_to_date_hook that mouse
+        highlight needs to be redisplayed.  (Bug#15913)
+
+2013-11-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * buffer.h (struct buffer_text, struct buffer):
+        * frame.h (struct frame):
+        * window.h (struct window):
+        Avoid 'bool foo : 1;', as it's not portable to pre-C99 compilers,
+        as described in ../lib/stdbool.in.h.  Use 'unsigned foo : 1;' instead.
+        * menu.c (syms_of_menu): Define x-popup-dialog, removing a
+        no-longer-valid use of HAVE_MENUS.
+        * xdisp.c (propagate_buffer_redisplay): Now static.
+
+2013-11-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xmenu.c (Fmenu_or_popup_active_p):
+        * window.c (Fset_window_configuration):
+        * menu.c (Fx_popup_menu, Fx_popup_dialog):
+        * keyboard.c (record_menu_key, read_char_x_menu_prompt):
+        * fns.c (Fyes_or_no_p):
+        * editfns.c (Fmessage_box, Fmessage_or_box):
+        * alloc.c (make_save_ptr_ptr):
+        * xdisp.c, w32menu.c, term.c, xterm.h, xterm.c: Remove HAVE_MENUS.
+
+        * window.c (Fset_window_configuration): Move select_window later.
+
+2013-11-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Refine redisplay optimizations to only redisplay *some* frames/windows
+        rather than all of them.
+        * xdisp.c (REDISPLAY_SOME): New constant.
+        (redisplay_other_windows, wset_redisplay, fset_redisplay)
+        (bset_redisplay, bset_update_mode_line): New functions.
+        (message_dolog): Use bset_redisplay.
+        (clear_garbaged_frames): Use fset_redisplay.
+        (echo_area_display): Use wset_redisplay.
+        (buffer_shared_and_changed): Remove.
+        (prepare_menu_bars): Call Vpre_redisplay_function before updating
+        frame titles.  Compute the actual set of windows redisplayed.
+        Don't update frame titles and menu bars for frames that don't need to
+        be redisplayed.
+        (propagate_buffer_redisplay): New function.
+        (AINC): New macro.
+        (redisplay_internal): Use it.  Be more selective in the set of windows
+        we redisplay.  Propagate windows_or_buffers_changed to
+        update_mode_lines a bit later to simplify the code.
+        (mark_window_display_accurate_1): Reset window and buffer's
+        `redisplay' flag.
+        (redisplay_window): Do nothing if neither the window nor the buffer nor
+        the frame needs redisplay.
+        * window.h (struct window): Add `redisplay' field.
+        (wset_redisplay, fset_redisplay, bset_redisplay, bset_update_mode_line)
+        (redisplay_other_windows, window_list): New declarations.
+        * window.c (select_window, Fset_window_start): Use wset_redisplay.
+        (window_list): Not static any more.
+        (grow_mini_window, shrink_mini_window): Use fset_redisplay.
+        * minibuf.c (read_minibuf_unwind): Don't redisplay everything.
+        * insdel.c (prepare_to_modify_buffer_1): Use bset_redisplay.
+        * frame.c (Fmake_frame_visible): Don't redisplay everything.
+        * frame.h (struct frame): Add `redisplay' field.
+        Move `external_menu_bar' bitfield next to other bit-fields.
+        (SET_FRAME_GARBAGED): Use fset_redisplay.
+        (SET_FRAME_VISIBLE): Don't garbage the frame;
+        Use redisplay_other_windows.
+        * buffer.h (struct buffer): Add `redisplay' field.
+        * buffer.c (Fforce_mode_line_update): Pay attention to the `all' flag.
+        (modify_overlay): Use bset_redisplay.
+        * alloc.c (gc_sweep): Don't unmark strings while sweeping symbols.
+
+2013-11-28  Eli Zaretskii  <eliz@gnu.org>
+
+        Support w32 file notifications in batch mode.
+        * w32proc.c (sys_select): Don't wait on interrupt_handle if it is
+        invalid (which happens in batch mode).  If non-interactive, call
+        handle_file_notifications to store file notification events in the
+        input queue.  (Bug#15933)
+
+        * w32notify.c (send_notifications): Handle FRAME_INITIAL frames as well.
+
+        * w32inevt.c (handle_file_notifications): Now external, not static.
+
+        * w32term.h (handle_file_notifications): Provide prototype.
+
+        * emacs.c (main) [HAVE_W32NOTIFY]: When non-interactive, call
+        init_crit, since init_display, which does that otherwise, is not
+        called.
+
+2013-11-27  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in ($(lispsource)/international/charprop.el): New.
+        (emacs$(EXEEXT)): Depend on charprop.el.
+
+2013-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (Finsert_file_contents): Invalidate buffer caches when
+        deleting portions of the buffer under non-nil REPLACE argument.
+        (Bug#15973)
+
+        * w32notify.c (Fw32notify_add_watch): If the argument FILE is a
+        directory, watch it and not its parent.
+        (add_watch): Allow empty string in FILE.
+
+2013-11-27  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fset_window_start, window_resize_apply)
+        (window_scroll): Reset window_end_valid (Bug#15957).
+
+2013-11-27  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (leimdir): Now in lisp source directory.
+        ($(leimdir)/leim-list.el): Just use ../leim .
+        * epaths.in (PATH_DUMPLOADSEARCH):
+        * lread.c (load_path_default):
+        * nsterm.m (ns_load_path): No more leim directory.
+
+2013-11-26  Andreas Schwab  <schwab@suse.de>
+
+        * .gdbinit (xgettype): Add cast.
+
+2013-11-26  Glenn Morris  <rgm@gnu.org>
+
+        Preload leim-list.el.
+        * epaths.in (PATH_DUMPLOADSEARCH): Add leim/.
+        * callproc.c (init_callproc): Don't assume PATH_DUMPLOADSEARCH
+        is a single directory.
+
+2013-11-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        bool-vector-subsetp is now the normal direction (Bug#15912).
+        * data.c (Fbool_vector_subsetp): Test whether the first argument
+        is a subset of the second one, not the reverse.  Add doc string.
+
+        Fix minor problems found by static checking.
+        * lread.c (load_path_default): Now static.
+        * textprop.c (text_property_stickiness): Be consistent about the
+        test used when deciding whether to consider the previous character.
+        This simplifies the code a bit.
+
+2013-11-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * textprop.c (text_property_stickiness): Fix front-stickiness at BOB.
+
+        * frame.c (Fhandle_focus_in, Fhandle_focus_out): Move to frame.el.
+        (syms_of_frame): Don't defsubr them.
+
+2013-11-25  Glenn Morris  <rgm@gnu.org>
+
+        * lread.c (load_path_default): Change the sense of the argument.
+        (init_lread): When EMACSLOADPATH is set, do not ignore changes
+        from dump_path.  When it is not, avoid checking dump_path twice.
+
+        * lread.c (init_lread): Fix 2013-11-23 goof that was checking
+        uninstalled dump_path against installed Vload_path.  (Bug#15964)
+
+2013-11-24  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Export get_pos_property to Elisp.
+        * editfns.c (Fget_pos_property): Rename from get_pos_property.
+        (syms_of_editfns): Export it to Elisp.
+
+        * data.c (Fmake_variable_buffer_local): Mention `permanent-local'.
+
+2013-11-23  Romain Francoise  <romain@orebokech.com>
+
+        * fileio.c (init_fileio): Move `write_region_inhibit_fsync'
+        initialization here ...
+        (syms_of_fileio): ... from here.
+
+2013-11-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lread.c (init_lread): Fix int/Lisp_Object mixup.
+        Please use --enable-check-lisp-object-type.
+
+2013-11-23  Glenn Morris  <rgm@gnu.org>
+
+        * process.c (get_process): Explicit error for dead buffers.
+
+2013-11-23  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * process.c (get_process): Check that OBJ is a live buffer.  (Bug#15923)
+
+2013-11-23  Glenn Morris  <rgm@gnu.org>
+
+        Empty elements in EMACSLOADPATH stand for the default.  (Bug#12100)
+        * lread.c (load_path_check): Take path to check as argument.
+        (load_path_default): New, split from init_lread.
+        (init_lread): Move calc of default load-path to load_path_default.
+        Empty elements in EMACSLOADPATH now stand for the default.
+        (load-path): Doc fix.
+        * emacs.c (decode_env_path): Add option to treat empty elements
+        as nil rather than ".".
+        * callproc.c (init_callproc_1, init_callproc):
+        * image.c (Vx_bitmap_file_path):
+        * lisp.h (decode_env_path):
+        * lread.c (Vsource_directory):
+        Update for new argument spec of decode_env_path.
+
+2013-11-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_find_paragraph_start): Limit the returned positions
+        to BEGV_BYTE..ZV_BYTE range.  (Bug#15951)
+
+2013-11-21  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix some dependency problems that cause unnecessary recompiles.
+        Problem reported by RMS in
+        <http://lists.gnu.org/archive/html/emacs-devel/2013-11/msg00421.html>.
+        * Makefile.in (OLDXMENU_TARGET, OLDXMENU, OLDXMENU_DEPS)
+        (really-lwlib, really-oldXMenu, stamp-oldxmenu)
+        (../src/$(OLDXMENU), $(OLDXMENU)): Remove.
+        (temacs$(EXEEXT)): Depend on $(LIBXMENU), not stamp-oldxmenu.
+        ($(lwlibdir)/liblw.a, $(oldXMenudir)/libXMenu11.a, FORCE): New targets.
+        (boostrap-clean): No need to remove stamp-oldxmenu.
+
+        Fix recently introduced bool vector overrun.
+        This was due to an optimization that went awry.
+        Reported by Glenn Morris in
+        <http://lists.gnu.org/archive/html/emacs-devel/2013-11/msg00622.html>.
+        * alloc.c (make_uninit_bool_vector): Don't allocate a dummy word
+        for empty vectors, undoing the 2013-11-18 change.
+        * data.c (bool_vector_binop_driver): Rely on this.
+        Fix bug that occasionally overran the destination.
+        * lisp.h (struct Lisp_Bool_vector): Document this.
+
+2013-11-20  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (init, run, stop:): Enable again. stop calls super stop
+        to handle dialogs.
+
+        * nsterm.m (init, run, stop:): Comment out for now, does not work
+        with dialogs.
+
+2013-11-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * charset.c (syms_of_charset): Don't read past end of string.
+
+2013-11-19  Glenn Morris  <rgm@gnu.org>
+
+        * frame.c (Fhandle_focus_in, Fhandle_focus_out): Doc fixes.
+
+2013-11-19  Brian Jenkins  <brian@brianjenkins.org>  (tiny change)
+
+        Add hooks to run on gaining/losing focus.  (Bug#15029)
+        * frame.c (Qfocus_in_hook, Qfocus_out_hook): New static lisp objects.
+        (Fhandle_focus_in, Fhandle_focus_out): Run focus hooks.
+        (syms_of_frame): Add focus-in-hook, focus-out-hook.
+
+2013-11-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * data.c (bool_vector_binop_driver): Rename locals for sanity's sake.
+        The old names predated the API change that put destination at end.
+
+        Improve API of recently-added bool vector functions (Bug#15912).
+        The old API had (bool-vector-count-matches A B)
+        and (bool-vector-count-matches-at A B I), which gave the
+        misleading impression that the two functions were variants, one
+        with a location I.  The new API has (bool-vector-count-population A)
+        and (bool-vector-count-consecutive A B I) to make the distinction
+        clearer.  The first function no longer has a B argument, since the
+        caller can easily determine the number of nils if the length and
+        number of ts is known.
+        * data.c (Fbool_vector_count_population): Rename from
+        bool_vector_count_matches, and accept just 1 argument.
+        (Fbool_vector_count_consecutive): Rename from
+        Fbool_vector_count_matches_at.
+
+        Always allocate at least one bits_word per bool vector.
+        See Daniel Colascione in:
+        http://lists.gnu.org/archive/html/emacs-devel/2013-11/msg00518.html
+        * alloc.c (make_uninit_bool_vector): Always allocate at least one word.
+        * data.c (bool_vector_binop_driver): Rely on this.  Tune.
+        * lisp.h (struct Lisp_Bool_vector): Document this.
+
 2013-11-18  Eli Zaretskii  <eliz@gnu.org>
 
         * insdel.c (invalidate_buffer_caches): New function, consolidated
         from part of prepare_to_modify_buffer.
         (insert_from_gap, prepare_to_modify_buffer):
-        * coding.c (code_convert_region, code_convert_string): Call
-        invalidate_buffer_caches.  (Bug#15841)
+        * coding.c (code_convert_region, code_convert_string):
+        Call invalidate_buffer_caches.  (Bug#15841)
 
         * lisp.h (invalidate_buffer_caches): Add prototype.
 
@@ -141,7 +897,7 @@
         "dumb loop", adjust C pointers into buffer text to follow suit.
         (Bug#15841)
 
-2013-11-09  Łukasz Stelmach <stlman@poczta.fm> (tiny change)
+2013-11-09  Łukasz Stelmach  <stlman@poczta.fm>  (tiny change)
 
         * gtkutil.c (xg_check_special_colors): Use rgb: instead of rgbi:
         for conversion (Bug#15837).
diff --git a/src/ChangeLog.12 b/src/ChangeLog.12
index b14ce20ede3..02940840eaa 100644
--- a/src/ChangeLog.12
+++ b/src/ChangeLog.12
@@ -2840,7 +2840,7 @@
 2012-11-19  Daniel Colascione  <dancol@dancol.org>
 
         * w32fns.c (Fx_file_dialog):
-        (Fx_file_dialog): Accomodate rename of cygwin_convert_path* to
+        (Fx_file_dialog): Accommodate rename of cygwin_convert_path* to
         cygwin_convert_file_name*.
 
         * cygw32.c (Fcygwin_convert_path_to_windows, syms_of_cygw32):
diff --git a/src/Makefile.in b/src/Makefile.in
index ca0b25a2f69..7d91928acfe 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -52,7 +52,7 @@ lispsource = $(srcdir)/../lisp
 lib = ../lib
 libsrc = ../lib-src
 etc = ../etc
-leimdir = ../leim
+leimdir = ${lispsource}/leim
 oldXMenudir = ../oldXMenu
 lwlibdir = ../lwlib
 
@@ -179,30 +179,8 @@ LIBXTR6=@LIBXTR6@
 LIBXT_OTHER=@LIBXT_OTHER@
 
 ## If !HAVE_X11 || USE_GTK, empty.
-## Else if USE_X_TOOLKIT really-lwlib, else really-oldxmenu.
-OLDXMENU_TARGET=@OLDXMENU_TARGET@
-
-## If !HAVE_X11 || USE_GTK, empty.
 ## Else if USE_X_TOOLKIT, $(lwlibdir)/liblw.a.
 ## Else $(oldXMenudir)/libXMenu11.a.
-## (Actually, rather than being empty, it is set to "nothing".
-## It is never actually used for anything in this case.
-## This is done because there is a rule with target $(OLDXMENU) below,
-## and I think it might be a syntax error with some makes to have
-## an empty target, even if the associated rule is never run.
-## http://lists.gnu.org/archive/html/help-make/2010-05/msg00058.html
-## The alternative would be to put that rule in a makefile fragment.)
-OLDXMENU=@OLDXMENU@
-
-## If HAVE_X11 && !USE_GTK, $(OLDXMENU) ../src/$(OLDXMENU); else empty.
-## We use stamp-xmenu with these two deps to both ensure that lwlib
-## gets remade based on its dependencies in its own makefile,
-## and remake temacs if lwlib gets changed by this.
-OLDXMENU_DEPS=@OLDXMENU_DEPS@
-
-## If !HAVE_X11 && HAVE_X_WINDOWS, -lXMenu (this case no longer possible).
-## Else if !HAVE_X11 || USE_GTK, empty.
-## Else $(OLDXMENU).
 LIBXMENU=@LIBXMENU@
 
 ## xmenu.o if HAVE_X_WINDOWS, else empty.
@@ -222,7 +200,7 @@ LIBXT=$(TOOLKIT_LIBW) $(LIBXT_OTHER)
 ## If HAVE_X11, $(LIBXT) $(LIBX_EXTRA), else empty.
 LIBX_OTHER=@LIBX_OTHER@
 
-## LIBXMENU is nil if !HAVE_X_WINDOWS.
+## LIBXMENU is empty if !HAVE_X_WINDOWS.
 ## LD_SWITCH_X_SITE should not be used if not using X, but nothing
 ## sets it at present, and if something ever does, it should be
 ## configure, which should set it to nil in non-X builds.
@@ -437,7 +415,10 @@ all: emacs$(EXEEXT) $(OTHER_FILES)
 .PHONY: all
 
 $(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
-        cd $(leimdir) && $(MAKE) $(MFLAGS) leim-list.el EMACS="$(bootstrap_exe)"
+        cd ../leim && $(MAKE) $(MFLAGS) leim-list.el EMACS="$(bootstrap_exe)"
+
+$(lispsource)/international/charprop.el: bootstrap-emacs$(EXEEXT)
+        cd ../admin/unidata && $(MAKE) $(MFLAGS) all EMACS="../$(bootstrap_exe)"
 
 ## The dumped Emacs is as functional and more efficient than
 ## bootstrap-emacs, so we replace the latter with the former.
@@ -445,7 +426,8 @@ $(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
 ## since not all pieces are used on all platforms.  But DOC depends
 ## on all of $lisp, and emacs depends on DOC, so it is ok to use $lisp here.
 emacs$(EXEEXT): temacs$(EXEEXT) $(ADDSECTION) \
-                $(etc)/DOC $(lisp) $(leimdir)/leim-list.el
+                $(etc)/DOC $(lisp) $(leimdir)/leim-list.el \
+                $(lispsource)/international/charprop.el
         if test "$(CANNOT_DUMP)" = "yes"; then \
           rm -f emacs$(EXEEXT); \
           ln temacs$(EXEEXT) emacs$(EXEEXT); \
@@ -504,7 +486,7 @@ $(lib)/libgnu.a: $(config_h)
 ## existence when setting Vinstallation_directory (FIXME?).
 ## This goes on to affect various things, and the emacs binary fails
 ## to start if Vinstallation_directory has the wrong value.
-temacs$(EXEEXT): stamp-oldxmenu $(ALLOBJS) \
+temacs$(EXEEXT): $(LIBXMENU) $(ALLOBJS) \
                  $(lib)/libgnu.a $(EMACSRES)
         $(CC) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(LDFLAGS) \
           -o temacs $(ALLOBJS) $(lib)/libgnu.a $(W32_RES_LINK) $(LIBES)
@@ -514,29 +496,17 @@ temacs$(EXEEXT): stamp-oldxmenu $(ALLOBJS) \
           test "X$(PAXCTL)" = X || $(PAXCTL) -r temacs$(EXEEXT)
 
 ## The following oldxmenu-related rules are only (possibly) used if
-## HAVE_X11 && !USE_GTK, but there is no harm in always defining them
-## (provided we take a little care that OLDXMENU is never empty).
-really-lwlib: globals.h
-        cd $(lwlibdir); $(MAKE) $(MFLAGS) \
-    CC='$(CC)' CFLAGS='$(CFLAGS)' MAKE='$(MAKE)'
-        @true  # make -t should not create really-lwlib.
-.PHONY: really-lwlib
-
-really-oldXMenu:
-        cd $(oldXMenudir); $(MAKE) $(MFLAGS) \
-    CC='$(CC)' CFLAGS='$(CFLAGS)' MAKE='$(MAKE)'
-        @true  # make -t should not create really-oldXMenu.
-.PHONY: really-oldXMenu
-
-## We do not really need this when OLDXMENU_DEPS is empty, but as
-## things stand we need something to satisfy the temacs dependency.
-stamp-oldxmenu: $(OLDXMENU_DEPS)
-        touch stamp-oldxmenu
-
-## Supply an ordering for parallel make.
-../src/$(OLDXMENU): $(OLDXMENU)
-
-$(OLDXMENU): $(OLDXMENU_TARGET)
+## HAVE_X11 && !USE_GTK, but there is no harm in always defining them.
+$(lwlibdir)/liblw.a: $(config_h) globals.h lisp.h FORCE
+        cd $(lwlibdir) && \
+          $(MAKE) $(MFLAGS) CC='$(CC)' CFLAGS='$(CFLAGS)' MAKE='$(MAKE)' \
+            liblw.a
+$(oldXMenudir)/libXMenu11.a: FORCE
+        cd $(oldXMenudir) && \
+          $(MAKE) $(MFLAGS) CC='$(CC)' CFLAGS='$(CFLAGS)' MAKE='$(MAKE)' \
+            libXMenu11.a
+FORCE:
+.PHONY: FORCE
 
 ../config.status: config.in epaths.in
         @echo "The file ${?:.in=.h} needs to be set up from $?."
@@ -572,7 +542,7 @@ clean: mostlyclean
 ## It should remove all files generated during a compilation/bootstrap,
 ## but not things like config.status or TAGS.
 bootstrap-clean: clean
-        rm -f epaths.h config.h config.stamp stamp-h1 stamp-oldxmenu
+        rm -f epaths.h config.h config.stamp stamp-h1
         if test -f ./.gdbinit; then \
           mv ./.gdbinit ./.gdbinit.save; \
           if test -f "$(srcdir)/.gdbinit"; then rm -f ./.gdbinit.save; \
diff --git a/src/alloc.c b/src/alloc.c
index f12fdc5c861..f076075a94f 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2066,20 +2066,20 @@ Lisp_Object
 make_uninit_bool_vector (EMACS_INT nbits)
 {
   Lisp_Object val;
-  struct Lisp_Bool_Vector *p;
-  EMACS_INT word_bytes, needed_elements;
-  word_bytes = bool_vector_words (nbits) * sizeof (bits_word);
-  needed_elements = ((bool_header_size - header_size + word_bytes
-                      + word_size - 1)
-                     / word_size);
-  p = (struct Lisp_Bool_Vector *) allocate_vector (needed_elements);
+  EMACS_INT words = bool_vector_words (nbits);
+  EMACS_INT word_bytes = words * sizeof (bits_word);
+  EMACS_INT needed_elements = ((bool_header_size - header_size + word_bytes
+                                + word_size - 1)
+                               / word_size);
+  struct Lisp_Bool_Vector *p
+    = (struct Lisp_Bool_Vector *) allocate_vector (needed_elements);
   XSETVECTOR (val, p);
   XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0, 0);
   p->size = nbits;
 
   /* Clear padding at the end.  */
-  if (nbits)
-    p->data[bool_vector_words (nbits) - 1] = 0;
+  if (words)
+    p->data[words - 1] = 0;
 
   return val;
 }
@@ -3477,7 +3477,7 @@ make_save_ptr_int (void *a, ptrdiff_t b)
   return val;
 }
 
-#if defined HAVE_MENUS && ! (defined USE_X_TOOLKIT || defined USE_GTK)
+#if ! (defined USE_X_TOOLKIT || defined USE_GTK)
 Lisp_Object
 make_save_ptr_ptr (void *a, void *b)
 {
@@ -4317,7 +4317,7 @@ live_buffer_p (struct mem_node *m, void *p)
 void dump_zombies (void) EXTERNALLY_VISIBLE;
 
 /* Array of objects that are kept alive because the C stack contains
-   a pattern that looks like a reference to them .  */
+   a pattern that looks like a reference to them.  */
 
 #define MAX_ZOMBIES 10
 static Lisp_Object zombies[MAX_ZOMBIES];
@@ -6291,7 +6291,7 @@ survives_gc_p (Lisp_Object obj)
 
 
 
-/* Sweep: find all structures not marked, and free them. */
+/* Sweep: find all structures not marked, and free them.  */
 
 static void
 gc_sweep (void)
@@ -6303,7 +6303,7 @@ gc_sweep (void)
   sweep_strings ();
   check_string_bytes (!noninteractive);
 
-  /* Put all unmarked conses on free list */
+  /* Put all unmarked conses on free list.  */
   {
     register struct cons_block *cblk;
     struct cons_block **cprev = &cons_block;
@@ -6380,7 +6380,7 @@ gc_sweep (void)
     total_free_conses = num_free;
   }
 
-  /* Put all unmarked floats on free list */
+  /* Put all unmarked floats on free list.  */
   {
     register struct float_block *fblk;
     struct float_block **fprev = &float_block;
@@ -6426,7 +6426,7 @@ gc_sweep (void)
     total_free_floats = num_free;
   }
 
-  /* Put all unmarked intervals on free list */
+  /* Put all unmarked intervals on free list.  */
   {
     register struct interval_block *iblk;
     struct interval_block **iprev = &interval_block;
@@ -6475,7 +6475,7 @@ gc_sweep (void)
     total_free_intervals = num_free;
   }
 
-  /* Put all unmarked symbols on free list */
+  /* Put all unmarked symbols on free list.  */
   {
     register struct symbol_block *sblk;
     struct symbol_block **sprev = &symbol_block;
@@ -6512,7 +6512,7 @@ gc_sweep (void)
               {
                 ++num_used;
                 if (!pure_p)
-                  UNMARK_STRING (XSTRING (sym->s.name));
+                  eassert (!STRING_MARKED_P (XSTRING (sym->s.name)));
                 sym->s.gcmarkbit = 0;
               }
           }
diff --git a/src/bidi.c b/src/bidi.c
index dc905cd9e5f..18dce1931db 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -67,16 +67,15 @@ static bool bidi_initialized = 0;
 
 static Lisp_Object bidi_type_table, bidi_mirror_table;
 
-#define LRM_CHAR   0x200E
-#define RLM_CHAR   0x200F
-#define BIDI_EOB   -1
+#define BIDI_EOB   (-1)
 
 /* Data type for describing the bidirectional character categories.  */
 typedef enum {
   UNKNOWN_BC,
   NEUTRAL,
   WEAK,
-  STRONG
+  STRONG,
+  EXPLICIT_FORMATTING
 } bidi_category_t;
 
 /* UAX#9 says to search only for L, AL, or R types of characters, and
@@ -115,13 +114,9 @@ bidi_get_type (int ch, bidi_dir_t override)
   if (default_type == UNKNOWN_BT)
     emacs_abort ();
 
-  if (override == NEUTRAL_DIR)
-    return default_type;
-
   switch (default_type)
     {
-      /* Although UAX#9 does not tell, it doesn't make sense to
-         override NEUTRAL_B and LRM/RLM characters.  */
+      case WEAK_BN:
       case NEUTRAL_B:
       case LRE:
       case LRO:
@@ -129,20 +124,20 @@ bidi_get_type (int ch, bidi_dir_t override)
       case RLO:
       case PDF:
         return default_type;
+        /* FIXME: The isolate controls are treated as BN until we add
+           support for UBA v6.3.  */
+      case LRI:
+      case RLI:
+      case FSI:
+      case PDI:
+        return WEAK_BN;
       default:
-        switch (ch)
-          {
-            case LRM_CHAR:
-            case RLM_CHAR:
-              return default_type;
-            default:
-              if (override == L2R) /* X6 */
-                return STRONG_L;
-              else if (override == R2L)
-                return STRONG_R;
-              else
-                emacs_abort (); /* can't happen: handled above */
-          }
+        if (override == L2R)
+          return STRONG_L;
+        else if (override == R2L)
+          return STRONG_R;
+        else
+          return default_type;
     }
 }
 
@@ -163,12 +158,7 @@ bidi_get_category (bidi_type_t type)
       case STRONG_L:
       case STRONG_R:
       case STRONG_AL:
-      case LRE:
-      case LRO:
-      case RLE:
-      case RLO:
         return STRONG;
-      case PDF:         /* ??? really?? */
       case WEAK_EN:
       case WEAK_ES:
       case WEAK_ET:
@@ -176,12 +166,30 @@ bidi_get_category (bidi_type_t type)
       case WEAK_CS:
       case WEAK_NSM:
       case WEAK_BN:
+        /* FIXME */
+      case LRI:
+      case RLI:
+      case FSI:
+      case PDI:
         return WEAK;
       case NEUTRAL_B:
       case NEUTRAL_S:
       case NEUTRAL_WS:
       case NEUTRAL_ON:
         return NEUTRAL;
+      case LRE:
+      case LRO:
+      case RLE:
+      case RLO:
+      case PDF:
+#if 0
+        /* FIXME: This awaits implementation of isolate support.  */
+      case LRI:
+      case RLI:
+      case FSI:
+      case PDI:
+#endif
+        return EXPLICIT_FORMATTING;
       default:
         emacs_abort ();
     }
@@ -1148,6 +1156,9 @@ bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
     pos = BEGV, pos_byte = BEGV_BYTE;
   if (bpc)
     know_region_cache (current_buffer, bpc, pos, oldpos);
+  /* Positions returned by the region cache are not limited to
+     BEGV..ZV range, so we limit them here.  */
+  pos_byte = clip_to_bounds (BEGV_BYTE, pos_byte, ZV_BYTE);
   return pos_byte;
 }
 
diff --git a/src/blockinput.h b/src/blockinput.h
index 8f1b1e18985..6c69b01d3dd 100644
--- a/src/blockinput.h
+++ b/src/blockinput.h
@@ -59,7 +59,7 @@ extern void unblock_input (void);
 extern void totally_unblock_input (void);
 extern void unblock_input_to (int);
 
-/* In critical section ? */
+/* In critical section?  */
 
 INLINE bool
 input_blocked_p (void)
diff --git a/src/buffer.c b/src/buffer.c
index 61b685ea5c5..e4a550fed95 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1336,10 +1336,16 @@ header lines.  This function also forces recomputation of the
 menu bar menus and the frame title.  */)
      (Lisp_Object all)
 {
-  if (!NILP (all) || buffer_window_count (current_buffer))
+  if (!NILP (all))
     {
       update_mode_lines = 10;
-      current_buffer->prevent_redisplay_optimizations_p = 1;
+      /* FIXME: This can't be right.  */
+      current_buffer->prevent_redisplay_optimizations_p = true;
+    }
+  else if (buffer_window_count (current_buffer))
+    {
+      bset_update_mode_line (current_buffer);
+      current_buffer->prevent_redisplay_optimizations_p = true;
     }
   return all;
 }
@@ -2476,6 +2482,8 @@ current buffer is cleared.  */)
   if (narrowed)
     error ("Changing multibyteness in a narrowed buffer");
 
+  invalidate_buffer_caches (current_buffer, BEGV, ZV);
+
   if (NILP (flag))
     {
       ptrdiff_t pos, stop;
@@ -3895,17 +3903,7 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
 
   BUF_COMPUTE_UNCHANGED (buf, start, end);
 
-  /* If BUF is visible, consider updating the display if ...  */
-  if (buffer_window_count (buf) > 0)
-    {
-      /* ... it's visible in other window than selected,  */
-      if (buf != XBUFFER (XWINDOW (selected_window)->contents))
-        windows_or_buffers_changed = 11;
-      /* ... or if we modify an overlay at the end of the buffer
-         and so we cannot be sure that window end is still valid.  */
-      else if (end >= ZV && start <= ZV)
-        windows_or_buffers_changed = 12;
-    }
+  bset_redisplay (buf);
 
   ++BUF_OVERLAY_MODIFF (buf);
 }
diff --git a/src/buffer.h b/src/buffer.h
index d1a3e50d7cf..10d5fdc23e0 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -475,7 +475,10 @@ struct buffer_text
     /* Usually 0.  Temporarily set to 1 in decode_coding_gap to
        prevent Fgarbage_collect from shrinking the gap and losing
        not-yet-decoded bytes.  */
-    bool inhibit_shrinking;
+    unsigned inhibit_shrinking : 1;
+
+    /* True if it needs to be redisplayed.  */
+    unsigned redisplay : 1;
   };
 
 /* Most code should use this macro to access Lisp fields in struct buffer.  */
@@ -738,7 +741,7 @@ struct buffer
   Lisp_Object INTERNAL_FIELD (cursor_in_non_selected_windows);
 
   /* No more Lisp_Object beyond this point.  Except undo_list,
-     which is handled specially in Fgarbage_collect .  */
+     which is handled specially in Fgarbage_collect.  */
 
   /* This structure holds the coordinates of the buffer contents
      in ordinary buffers.  In indirect buffers, this is not used.  */
diff --git a/src/callproc.c b/src/callproc.c
index 2966711978b..b44f680b352 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1,6 +1,6 @@
 /* Synchronous subprocess invocation for GNU Emacs.
-   Copyright (C) 1985-1988, 1993-1995, 1999-2013
-                 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1988, 1993-1995, 1999-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1520,14 +1520,14 @@ init_callproc_1 (void)
 #ifdef HAVE_NS
                                              etc_dir ? etc_dir :
 #endif
-                                             PATH_DATA);
+                                             PATH_DATA, 0);
   Vdata_directory = Ffile_name_as_directory (Fcar (Vdata_directory));
 
   Vdoc_directory = decode_env_path ("EMACSDOC",
 #ifdef HAVE_NS
                                              etc_dir ? etc_dir :
 #endif
-                                             PATH_DOC);
+                                             PATH_DOC, 0);
   Vdoc_directory = Ffile_name_as_directory (Fcar (Vdoc_directory));
 
   /* Check the EMACSPATH environment variable, defaulting to the
@@ -1536,10 +1536,10 @@ init_callproc_1 (void)
 #ifdef HAVE_NS
                                 path_exec ? path_exec :
 #endif
-                                PATH_EXEC);
+                                PATH_EXEC, 0);
   Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path));
   /* FIXME?  For ns, path_exec should go at the front?  */
-  Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
+  Vexec_path = nconc2 (decode_env_path ("PATH", "", 0), Vexec_path);
 }
 
 /* This is run after init_cmdargs, when Vinstallation_directory is valid.  */
@@ -1580,9 +1580,9 @@ init_callproc (void)
 #ifdef HAVE_NS
                                         path_exec ? path_exec :
 #endif
-                                        PATH_EXEC);
+                                        PATH_EXEC, 0);
           Vexec_path = Fcons (tem, Vexec_path);
-          Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path);
+          Vexec_path = nconc2 (decode_env_path ("PATH", "", 0), Vexec_path);
         }
 
       Vexec_directory = Ffile_name_as_directory (tem);
@@ -1606,24 +1606,17 @@ init_callproc (void)
      source directory.  */
   if (data_dir == 0)
     {
-      Lisp_Object tem, tem1, tem2, srcdir;
-#ifdef WINDOWSNT
-      /* PATH_DUMPLOADSEARCH is in ANSI codepage; convert to UTF-8.  */
-      char dumpload_dir[MAX_UTF8_PATH];
+      Lisp_Object tem, tem1, srcdir;
+      Lisp_Object lispdir = Fcar (decode_env_path (0, PATH_DUMPLOADSEARCH, 0));
 
-      filename_from_ansi (PATH_DUMPLOADSEARCH, dumpload_dir);
-      tem2 = build_unibyte_string (dumpload_dir);
-#else
-      tem2 = build_unibyte_string (PATH_DUMPLOADSEARCH);
-#endif
+      srcdir = Fexpand_file_name (build_string ("../src/"), lispdir);
 
-      srcdir = Fexpand_file_name (build_string ("../src/"), tem2);
       tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory);
       tem1 = Ffile_exists_p (tem);
       if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1))
         {
           Lisp_Object newdir;
-          newdir = Fexpand_file_name (build_string ("../etc/"), tem2);
+          newdir = Fexpand_file_name (build_string ("../etc/"), lispdir);
           tem = Fexpand_file_name (build_string ("GNU"), newdir);
           tem1 = Ffile_exists_p (tem);
           if (!NILP (tem1))
diff --git a/src/charset.c b/src/charset.c
index 4a36f8059ae..2ef060228ee 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -2428,19 +2428,19 @@ the value may be a list of mnemonics.  */);
   Vcurrent_iso639_language = Qnil;
 
   charset_ascii
-    = define_charset_internal (Qascii, 1, "\x00\x7F\x00\x00\x00\x00",
+    = define_charset_internal (Qascii, 1, "\x00\x7F\0\0\0\0\0",
                                0, 127, 'B', -1, 0, 1, 0, 0);
   charset_iso_8859_1
-    = define_charset_internal (Qiso_8859_1, 1, "\x00\xFF\x00\x00\x00\x00",
+    = define_charset_internal (Qiso_8859_1, 1, "\x00\xFF\0\0\0\0\0",
                                0, 255, -1, -1, -1, 1, 0, 0);
   charset_unicode
-    = define_charset_internal (Qunicode, 3, "\x00\xFF\x00\xFF\x00\x10",
+    = define_charset_internal (Qunicode, 3, "\x00\xFF\x00\xFF\x00\x10\0",
                                0, MAX_UNICODE_CHAR, -1, 0, -1, 1, 0, 0);
   charset_emacs
-    = define_charset_internal (Qemacs, 3, "\x00\xFF\x00\xFF\x00\x3F",
+    = define_charset_internal (Qemacs, 3, "\x00\xFF\x00\xFF\x00\x3F\0",
                                0, MAX_5_BYTE_CHAR, -1, 0, -1, 1, 1, 0);
   charset_eight_bit
-    = define_charset_internal (Qeight_bit, 1, "\x80\xFF\x00\x00\x00\x00",
+    = define_charset_internal (Qeight_bit, 1, "\x80\xFF\0\0\0\0\0",
                                128, 255, -1, 0, -1, 0, 1,
                                MAX_5_BYTE_CHAR + 1);
   charset_unibyte = charset_iso_8859_1;
diff --git a/src/charset.h b/src/charset.h
index 6e6a8891b4a..d5c41ec6f49 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -208,7 +208,7 @@ struct charset
   unsigned min_code, max_code;
 
   /* Offset value used by macros CODE_POINT_TO_INDEX and
-      INDEX_TO_CODE_POINT. .  */
+      INDEX_TO_CODE_POINT.  */
   unsigned char_index_offset;
 
   /* Minimum and Maximum character codes of the charset.  If the
diff --git a/src/chartab.c b/src/chartab.c
index 16dd85c12c0..2a8bbc6983a 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -1272,7 +1272,7 @@ uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
 
 
 /* Encode VALUE as an element of char-table TABLE which adopts RUN-LENGTH
-   compression and contains numbers as elements .  */
+   compression and contains numbers as elements.  */
 
 static Lisp_Object
 uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
diff --git a/src/composite.c b/src/composite.c
index 2ab5dbc9133..cef2ed86e57 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1191,7 +1191,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
 
 /* Check if the character at CHARPOS (and BYTEPOS) is composed
    (possibly with the following characters) on window W.  ENDPOS limits
-   characters to be composed.  FACE, in non-NULL, is a base face of
+   characters to be composed.  FACE, if non-NULL, is a base face of
    the character.  If STRING is not nil, it is a string containing the
    character to check, and CHARPOS and BYTEPOS are indices in the
    string.  In that case, FACE must not be NULL.
diff --git a/src/data.c b/src/data.c
index d0171b5d758..1fe7a1c9b65 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1551,8 +1551,12 @@ Note that binding the variable with `let', or setting it while
 a `let'-style binding made in this buffer is in effect,
 does not make the variable buffer-local.  Return VARIABLE.
 
-In most cases it is better to use `make-local-variable',
-which makes a variable local in just one buffer.
+This globally affects all uses of this variable, so it belongs together with
+the variable declaration, rather than with its uses (if you just want to make
+a variable local to the current buffer for one particular use, use
+`make-local-variable').  Buffer-local bindings are normally cleared
+while setting up a new major mode, unless they have a `permanent-local'
+property.
 
 The function `default-value' gets the default value and `set-default' sets it.  */)
   (register Lisp_Object variable)
@@ -3018,64 +3022,103 @@ enum bool_vector_op { bool_vector_exclusive_or,
                       bool_vector_subsetp };
 
 static Lisp_Object
-bool_vector_binop_driver (Lisp_Object op1,
-                          Lisp_Object op2,
+bool_vector_binop_driver (Lisp_Object a,
+                          Lisp_Object b,
                           Lisp_Object dest,
                           enum bool_vector_op op)
 {
   EMACS_INT nr_bits;
-  bits_word *adata, *bdata, *cdata;
-  ptrdiff_t i;
-  bool changed = 0;
-  bits_word mword;
+  bits_word *adata, *bdata, *destdata;
+  ptrdiff_t i = 0;
   ptrdiff_t nr_words;
 
-  CHECK_BOOL_VECTOR (op1);
-  CHECK_BOOL_VECTOR (op2);
+  CHECK_BOOL_VECTOR (a);
+  CHECK_BOOL_VECTOR (b);
 
-  nr_bits = bool_vector_size (op1);
-  if (bool_vector_size (op2) != nr_bits)
-    wrong_length_argument (op1, op2, dest);
+  nr_bits = bool_vector_size (a);
+  if (bool_vector_size (b) != nr_bits)
+    wrong_length_argument (a, b, dest);
+
+  nr_words = bool_vector_words (nr_bits);
+  adata = bool_vector_data (a);
+  bdata = bool_vector_data (b);
 
   if (NILP (dest))
     {
       dest = make_uninit_bool_vector (nr_bits);
-      changed = 1;
+      destdata = bool_vector_data (dest);
     }
   else
     {
       CHECK_BOOL_VECTOR (dest);
+      destdata = bool_vector_data (dest);
       if (bool_vector_size (dest) != nr_bits)
-        wrong_length_argument (op1, op2, dest);
-    }
+        wrong_length_argument (a, b, dest);
 
-  nr_words = bool_vector_words (nr_bits);
+      switch (op)
+        {
+        case bool_vector_exclusive_or:
+          for (; i < nr_words; i++)
+            if (destdata[i] != (adata[i] ^ bdata[i]))
+              goto set_dest;
+          break;
+
+        case bool_vector_subsetp:
+          for (; i < nr_words; i++)
+            if (adata[i] &~ bdata[i])
+              return Qnil;
+          return Qt;
+
+        case bool_vector_union:
+          for (; i < nr_words; i++)
+            if (destdata[i] != (adata[i] | bdata[i]))
+              goto set_dest;
+          break;
+
+        case bool_vector_intersection:
+          for (; i < nr_words; i++)
+            if (destdata[i] != (adata[i] & bdata[i]))
+              goto set_dest;
+          break;
 
-  adata = bool_vector_data (dest);
-  bdata = bool_vector_data (op1);
-  cdata = bool_vector_data (op2);
+        case bool_vector_set_difference:
+          for (; i < nr_words; i++)
+            if (destdata[i] != (adata[i] &~ bdata[i]))
+              goto set_dest;
+          break;
+        }
+
+      return Qnil;
+    }
 
-  for (i = 0; i < nr_words; i++)
+ set_dest:
+  switch (op)
     {
-      if (op == bool_vector_exclusive_or)
-        mword = bdata[i] ^ cdata[i];
-      else if (op == bool_vector_union || op == bool_vector_subsetp)
-        mword = bdata[i] | cdata[i];
-      else if (op == bool_vector_intersection)
-        mword = bdata[i] & cdata[i];
-      else if (op == bool_vector_set_difference)
-        mword = bdata[i] &~ cdata[i];
-      else
-        abort ();
+    case bool_vector_exclusive_or:
+      for (; i < nr_words; i++)
+        destdata[i] = adata[i] ^ bdata[i];
+      break;
 
-      if (! changed)
-        changed = adata[i] != mword;
+    case bool_vector_union:
+      for (; i < nr_words; i++)
+        destdata[i] = adata[i] | bdata[i];
+      break;
 
-      if (op != bool_vector_subsetp)
-        adata[i] = mword;
+    case bool_vector_intersection:
+      for (; i < nr_words; i++)
+        destdata[i] = adata[i] & bdata[i];
+      break;
+
+    case bool_vector_set_difference:
+      for (; i < nr_words; i++)
+        destdata[i] = adata[i] &~ bdata[i];
+      break;
+
+    default:
+      eassume (0);
     }
 
-  return changed ? dest : Qnil;
+  return dest;
 }
 
 /* PRECONDITION must be true.  Return VALUE.  This odd construction
@@ -3199,11 +3242,11 @@ Return the destination vector if it changed or nil otherwise.  */)
 
 DEFUN ("bool-vector-subsetp", Fbool_vector_subsetp,
        Sbool_vector_subsetp, 2, 2, 0,
-       doc: )
+       doc: /* Return t if every t value in A is also t in B, nil otherwise.
+A and B must be bool vectors of the same length.  */)
   (Lisp_Object a, Lisp_Object b)
 {
-  /* Like bool_vector_union, but doesn't modify b.  */
-  return bool_vector_binop_driver (b, a, b, bool_vector_subsetp);
+  return bool_vector_binop_driver (a, b, b, bool_vector_subsetp);
 }
 
 DEFUN ("bool-vector-not", Fbool_vector_not,
@@ -3247,11 +3290,12 @@ Return the destination vector.  */)
   return b;
 }
 
-DEFUN ("bool-vector-count-matches", Fbool_vector_count_matches,
-       Sbool_vector_count_matches, 2, 2, 0,
-       doc: /* Count how many elements in A equal B.
-A must be a bool vector.  B is a generalized bool.  */)
-  (Lisp_Object a, Lisp_Object b)
+DEFUN ("bool-vector-count-population", Fbool_vector_count_population,
+       Sbool_vector_count_population, 1, 1, 0,
+       doc: /* Count how many elements in A are t.
+A is a bool vector.  To count A's nil elements, subtract the return
+value from A's length.  */)
+  (Lisp_Object a)
 {
   EMACS_INT count;
   EMACS_INT nr_bits;
@@ -3268,17 +3312,13 @@ A must be a bool vector.  B is a generalized bool.  */)
   for (i = 0; i < nwords; i++)
     count += count_one_bits_word (adata[i]);
 
-  if (NILP (b))
-    count = nr_bits - count;
   return make_number (count);
 }
 
-DEFUN ("bool-vector-count-matches-at",
-       Fbool_vector_count_matches_at,
-       Sbool_vector_count_matches_at, 3, 3, 0,
-       doc: /* Count how many consecutive elements in A equal B at i.
-A must be a bool vector.  B is a generalized boolean.  i is an
-index into the vector.  */)
+DEFUN ("bool-vector-count-consecutive", Fbool_vector_count_consecutive,
+       Sbool_vector_count_consecutive, 3, 3, 0,
+       doc: /* Count how many consecutive elements in A equal B starting at I.
+A is a bool vector, B is t or nil, and I is an index into A.  */)
   (Lisp_Object a, Lisp_Object b, Lisp_Object i)
 {
   EMACS_INT count;
@@ -3314,7 +3354,10 @@ index into the vector.  */)
       mword = bits_word_to_host_endian (adata[pos]);
       mword ^= twiddle;
       mword >>= offset;
+
+      /* Do not count the pad bits.  */
       mword |= (bits_word) 1 << (BITS_PER_BITS_WORD - offset);
+
       count = count_trailing_zero_bits (mword);
       pos++;
       if (count + offset < BITS_PER_BITS_WORD)
@@ -3622,8 +3665,8 @@ syms_of_data (void)
   defsubr (&Sbool_vector_set_difference);
   defsubr (&Sbool_vector_not);
   defsubr (&Sbool_vector_subsetp);
-  defsubr (&Sbool_vector_count_matches);
-  defsubr (&Sbool_vector_count_matches_at);
+  defsubr (&Sbool_vector_count_consecutive);
+  defsubr (&Sbool_vector_count_population);
 
   set_symbol_function (Qwholenump, XSYMBOL (Qnatnump)->function);
 
diff --git a/src/dispextern.h b/src/dispextern.h
index d40febd207a..7de4edf2196 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -118,7 +118,9 @@ enum window_part
   ON_RIGHT_FRINGE,
   ON_LEFT_MARGIN,
   ON_RIGHT_MARGIN,
-  ON_SCROLL_BAR
+  ON_SCROLL_BAR,
+  ON_RIGHT_DIVIDER,
+  ON_BOTTOM_DIVIDER
 };
 
 /* Number of bits allocated to store fringe bitmap numbers.  */
@@ -667,7 +669,7 @@ struct glyph_pool
    glyph memory, which is allocated in the form of a glyph_pool structure.
    Glyph rows in such a window matrix are slices of frame matrix rows.
 
-   2. Free-standing window glyph matrices managing their own glyph
+   3. Free-standing window glyph matrices managing their own glyph
    storage.  This form is used in window-based redisplay which
    includes variable width and height fonts etc.
 
@@ -704,12 +706,12 @@ struct glyph_matrix
   int matrix_w, matrix_h;
 
   /* If this structure describes a window matrix of window W,
-     window_left_col is the value of W->left_col, window_top_line the
-     value of W->top_line, window_height and window_width are width and
-     height of W, as returned by window_box, and window_vscroll is the
-     value of W->vscroll at the time the matrix was last adjusted.
+     window_pixel_left is the value of W->pixel_left, window_pixel_top
+     the value of W->pixel_top, window_height and window_width are width
+     and height of W, as returned by window_box, and window_vscroll is
+     the value of W->vscroll at the time the matrix was last adjusted.
      Only set for window-based redisplay.  */
-  int window_left_col, window_top_line;
+  int window_pixel_left, window_pixel_top;
   int window_height, window_width;
   int window_vscroll;
 
@@ -722,7 +724,7 @@ struct glyph_matrix
      which do their own scrolling.  */
   unsigned no_scrolling_p : 1;
 
-  /* Non-zero means window displayed in this matrix has a top mode
+  /* Non-zero means window displayed in this matrix has a header
      line.  */
   unsigned header_line_p : 1;
 
@@ -1460,28 +1462,40 @@ struct glyph_string
 #define DESIRED_HEADER_LINE_HEIGHT(W) \
      MATRIX_HEADER_LINE_HEIGHT ((W)->desired_matrix)
 
-/* Value is non-zero if window W wants a mode line.  */
+/* PXW: The height checks below serve to show at least one text line
+   instead of a mode- and/or header line when a window gets very small.
+   But (1) the check fails when the mode- or header-line is taller than
+   the associated frame's line height and (2) we don't care much about
+   text visibility anyway when shrinking a frame containing a toolbar.
 
-#define WINDOW_WANTS_MODELINE_P(W)                              \
-  (!MINI_WINDOW_P ((W))                                         \
-   && !(W)->pseudo_window_p                                     \
-   && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))      \
-   && BUFFERP ((W)->contents)                                   \
-   && !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format))  \
-   && WINDOW_TOTAL_LINES (W) > 1)
+   So maybe these checks should be removed and any clipping left to the
+   window manager.  */
 
-/* Value is true if window W wants a header line.  */
-
-#define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
+/* Value is true if window W wants a mode line and is large enough
+   to accommodate it.  */
+#define WINDOW_WANTS_MODELINE_P(W)                                      \
   (BUFFERP ((W)->contents)                                              \
-   ? (!MINI_WINDOW_P ((W))                                              \
+   ? (!MINI_WINDOW_P (W)                                                \
       && !(W)->pseudo_window_p                                          \
-      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))           \
-      && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))     \
-      && WINDOW_TOTAL_LINES (W) >                                       \
-          (1 + !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format)))) \
+      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))             \
+      && !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format))       \
+      && WINDOW_PIXEL_HEIGHT (W) > WINDOW_FRAME_LINE_HEIGHT (W))        \
    : 0)
 
+/* Value is true if window W wants a header line and is large enough
+   to accommodate it.  */
+#define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
+     (BUFFERP ((W)->contents)                                           \
+      ? (!MINI_WINDOW_P (W)                                             \
+         && !(W)->pseudo_window_p                                       \
+         && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))          \
+         && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))  \
+         && (WINDOW_PIXEL_HEIGHT (W)                                    \
+             > (WINDOW_WANTS_MODELINE_P (W)                             \
+                ? (2 * WINDOW_FRAME_LINE_HEIGHT (W))                    \
+                : WINDOW_FRAME_LINE_HEIGHT (W))))                       \
+      : 0)
+
 /* Return proper value to be used as baseline offset of font that has
    ASCENT and DESCENT to draw characters by the font at the vertical
    center of the line of frame F.
@@ -1751,6 +1765,7 @@ enum face_id
   MOUSE_FACE_ID,
   MENU_FACE_ID,
   VERTICAL_BORDER_FACE_ID,
+  WINDOW_DIVIDER_FACE_ID,
   BASIC_FACE_ID_SENTINEL
 };
 
@@ -1880,6 +1895,10 @@ typedef enum {
   RLE,          /* right-to-left embedding */
   RLO,          /* right-to-left override */
   PDF,          /* pop directional format */
+  LRI,          /* left-to-right isolate */
+  RLI,          /* right-to-left isolate */
+  FSI,          /* first strong isolate */
+  PDI,          /* pop directional isolate */
   WEAK_ES,      /* european number separator */
   WEAK_ET,      /* european number terminator */
   WEAK_CS,      /* common separator */
@@ -2850,6 +2869,10 @@ struct redisplay_interface
   void (*draw_vertical_window_border) (struct window *w,
                                        int x, int y_0, int y_1);
 
+/* Draw window divider for window W from (X_0, Y_0) to (X_1, ,Y_1).  */
+  void (*draw_window_divider) (struct window *w,
+                               int x_0, int x_1, int y_0, int y_1);
+
 /* Shift display of frame F to make room for inserted glyphs.
    The area at pixel (X,Y) of width WIDTH and height HEIGHT is
    shifted right by SHIFT_BY pixels.  */
@@ -3167,6 +3190,7 @@ int window_box_left_offset (struct window *, enum glyph_row_area);
 int window_box_right (struct window *, enum glyph_row_area);
 int window_box_right_offset (struct window *, enum glyph_row_area);
 int estimate_mode_line_height (struct frame *, enum face_id);
+int move_it_to (struct it *, ptrdiff_t, int, int, int, int);
 void pixel_to_glyph_coords (struct frame *, int, int, int *, int *,
                             NativeRectangle *, int);
 void remember_mouse_glyph (struct frame *, int, int, NativeRectangle *);
@@ -3178,7 +3202,6 @@ void init_iterator (struct it *, struct window *, ptrdiff_t,
 void init_iterator_to_row_start (struct it *, struct window *,
                                  struct glyph_row *);
 void start_display (struct it *, struct window *, struct text_pos);
-void move_it_to (struct it *, ptrdiff_t, int, int, int, int);
 void move_it_vertically (struct it *, int);
 void move_it_vertically_backward (struct it *, int);
 void move_it_by_lines (struct it *, ptrdiff_t);
@@ -3235,6 +3258,7 @@ extern void display_and_set_cursor (struct window *, bool, int, int, int, int);
 extern void x_update_cursor (struct frame *, bool);
 extern void x_clear_cursor (struct window *);
 extern void x_draw_vertical_border (struct window *w);
+extern void x_draw_right_divider (struct window *w);
 
 extern int get_glyph_string_clip_rects (struct glyph_string *,
                                         NativeRectangle *, int);
@@ -3462,10 +3486,9 @@ void blank_row (struct window *, struct glyph_row *, int);
 void clear_glyph_matrix_rows (struct glyph_matrix *, int, int);
 void clear_glyph_row (struct glyph_row *);
 void prepare_desired_row (struct glyph_row *);
-void set_window_update_flags (struct window *, struct buffer *, bool);
 void update_single_window (struct window *, bool);
 void do_pending_window_change (bool);
-void change_frame_size (struct frame *, int, int, bool, bool, bool);
+void change_frame_size (struct frame *, int, int, bool, bool, bool, bool);
 void init_display (void);
 void syms_of_display (void);
 extern Lisp_Object Qredisplay_dont_pause;
diff --git a/src/dispnew.c b/src/dispnew.c
index 3207f4a0018..94929600286 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -72,7 +72,7 @@ struct dim
 static void update_frame_line (struct frame *, int);
 static int required_matrix_height (struct window *);
 static int required_matrix_width (struct window *);
-static void change_frame_size_1 (struct frame *, int, int, bool, bool, bool);
+static void change_frame_size_1 (struct frame *, int, int, bool, bool, bool, bool);
 static void increment_row_positions (struct glyph_row *, ptrdiff_t, ptrdiff_t);
 static void build_frame_matrix_from_window_tree (struct glyph_matrix *,
                                                  struct window *);
@@ -97,6 +97,7 @@ static bool scrolling (struct frame *);
 static void set_window_cursor_after_update (struct window *);
 static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
 static void adjust_frame_glyphs_for_frame_redisplay (struct frame *);
+static void set_window_update_flags (struct window *w, bool on_p);
 
 /* True means last display completed.  False means it was preempted.  */
 
@@ -400,8 +401,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
       if (!marginal_areas_changed_p
           && !XFRAME (w->frame)->fonts_changed
           && !header_line_changed_p
-          && matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
-          && matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
+          && matrix->window_pixel_left == WINDOW_LEFT_PIXEL_EDGE (w)
+          && matrix->window_pixel_top == WINDOW_TOP_PIXEL_EDGE (w)
           && matrix->window_height == window_height
           && matrix->window_vscroll == w->vscroll
           && matrix->window_width == window_width)
@@ -542,8 +543,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
               && !header_line_changed_p
               && new_rows == 0
               && dim.width == matrix->matrix_w
-              && matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
-              && matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
+              && matrix->window_pixel_left == WINDOW_LEFT_PIXEL_EDGE (w)
+              && matrix->window_pixel_top == WINDOW_TOP_PIXEL_EDGE (w)
               && matrix->window_width == window_width)
             {
               /* Find the last row in the window.  */
@@ -590,8 +591,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
      was last adjusted.  This is used to optimize redisplay above.  */
   if (w)
     {
-      matrix->window_left_col = WINDOW_LEFT_EDGE_COL (w);
-      matrix->window_top_line = WINDOW_TOP_EDGE_LINE (w);
+      matrix->window_pixel_left = WINDOW_LEFT_PIXEL_EDGE (w);
+      matrix->window_pixel_top = WINDOW_TOP_PIXEL_EDGE (w);
       matrix->window_height = window_height;
       matrix->window_width = window_width;
       matrix->window_vscroll = w->vscroll;
@@ -1660,6 +1661,7 @@ required_matrix_height (struct window *w)
     {
       int ch_height = FRAME_SMALLEST_FONT_HEIGHT (f);
       int window_pixel_height = window_box_height (w) + eabs (w->vscroll);
+
       return (((window_pixel_height + ch_height - 1)
                / ch_height) * w->nrows_scale_factor
               /* One partially visible line at the top and
@@ -1684,10 +1686,9 @@ required_matrix_width (struct window *w)
   if (FRAME_WINDOW_P (f))
     {
       int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
-      int window_pixel_width = WINDOW_TOTAL_WIDTH (w);
 
       /* Compute number of glyphs needed in a glyph row.  */
-      return (((window_pixel_width + ch_width - 1)
+      return (((WINDOW_PIXEL_WIDTH (w) + ch_width - 1)
                / ch_width) * w->ncols_scale_factor
               /* 2 partially visible columns in the text area.  */
               + 2
@@ -1977,6 +1978,10 @@ adjust_frame_glyphs_for_frame_redisplay (struct frame *f)
       /* Size of frame matrices must equal size of frame.  Note
          that we are called for X frames with window widths NOT equal
          to the frame width (from CHANGE_FRAME_SIZE_1).  */
+      if (matrix_dim.width != FRAME_COLS (f)
+          || matrix_dim.height != FRAME_LINES (f))
+        return;
+
       eassert (matrix_dim.width == FRAME_COLS (f)
                && matrix_dim.height == FRAME_LINES (f));
 
@@ -2046,10 +2051,14 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
 
     /* Set window dimensions to frame dimensions and allocate or
        adjust glyph matrices of W.  */
-    w->top_line = 0;
+    w->pixel_left = 0;
     w->left_col = 0;
-    w->total_lines = FRAME_MENU_BAR_LINES (f);
+    w->pixel_top = 0;
+    w->top_line = 0;
+    w->pixel_width = FRAME_PIXEL_WIDTH (f);
     w->total_cols = FRAME_TOTAL_COLS (f);
+    w->pixel_height = FRAME_MENU_BAR_HEIGHT (f);
+    w->total_lines = FRAME_MENU_BAR_LINES (f);
     allocate_matrices_for_window_redisplay (w);
   }
 #endif
@@ -2071,10 +2080,15 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
     else
       w = XWINDOW (f->tool_bar_window);
 
-    w->top_line = FRAME_MENU_BAR_LINES (f);
+    w->pixel_left = 0;
     w->left_col = 0;
-    w->total_lines = FRAME_TOOL_BAR_LINES (f);
+    w->pixel_top = FRAME_MENU_BAR_HEIGHT (f);
+    w->top_line = FRAME_MENU_BAR_LINES (f);
+    w->pixel_width = (FRAME_PIXEL_WIDTH (f)
+                       - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
     w->total_cols = FRAME_TOTAL_COLS (f);
+    w->pixel_height = FRAME_TOOL_BAR_HEIGHT (f);
+    w->total_lines = FRAME_TOOL_BAR_LINES (f);
     allocate_matrices_for_window_redisplay (w);
   }
 #endif
@@ -2944,8 +2958,8 @@ redraw_frame (struct frame *f)
   /* Mark all windows as inaccurate, so that every window will have
      its redisplay done.  */
   mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
-  set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), NULL, 1);
-  f->garbaged = 0;
+  set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), true);
+  f->garbaged = false;
 }
 
 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 0, 1, 0,
@@ -3029,7 +3043,7 @@ update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
               Lisp_Object tem;
 
               update_window (w, 1);
-              w->must_be_updated_p = 0;
+              w->must_be_updated_p = false;
 
               /* Swap tool-bar strings.  We swap because we want to
                  reuse strings.  */
@@ -3075,7 +3089,7 @@ update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
 
  do_pause:
   /* Reset flags indicating that a window should be updated.  */
-  set_window_update_flags (root_window, NULL, 0);
+  set_window_update_flags (root_window, false);
 
   display_completed = !paused_p;
   return paused_p;
@@ -3098,7 +3112,7 @@ update_frame_with_menu (struct frame *f)
      frame matrix we operate.  */
   set_frame_matrix_frame (f);
 
-  /* Update the display  */
+  /* Update the display.  */
   update_begin (f);
   /* Force update_frame_1 not to stop due to pending input, and not
      try scrolling.  */
@@ -3122,7 +3136,7 @@ update_frame_with_menu (struct frame *f)
 #endif
 
   /* Reset flags indicating that a window should be updated.  */
-  set_window_update_flags (root_window, NULL, 0);
+  set_window_update_flags (root_window, false);
 }
 
 
@@ -3174,7 +3188,7 @@ update_single_window (struct window *w, bool force_p)
       update_end (f);
 
       /* Reset flag in W.  */
-      w->must_be_updated_p = 0;
+      w->must_be_updated_p = false;
     }
 }
 
@@ -3897,18 +3911,17 @@ set_window_cursor_after_update (struct window *w)
 }
 
 
-/* If B is NULL, set WINDOW->must_be_updated_p to ON_P for all windows in
-   the window tree rooted at W.  Otherwise set WINDOW->must_be_updated_p
-   to ON_P only for windows that displays B.  */
+/* Set WINDOW->must_be_updated_p to ON_P for all windows in
+   the window tree rooted at W.  */
 
-void
-set_window_update_flags (struct window *w, struct buffer *b, bool on_p)
+static void
+set_window_update_flags (struct window *w, bool on_p)
 {
   while (w)
     {
       if (WINDOWP (w->contents))
-        set_window_update_flags (XWINDOW (w->contents), b, on_p);
-      else if (!(b && b != XBUFFER (w->contents)))
+        set_window_update_flags (XWINDOW (w->contents), on_p);
+      else
         w->must_be_updated_p = on_p;
 
       w = NILP (w->next) ? 0 : XWINDOW (w->next);
@@ -5275,7 +5288,7 @@ marginal_area_string (struct window *w, enum window_part part,
       if (area == RIGHT_MARGIN_AREA)
         x0 = ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
                ? WINDOW_LEFT_FRINGE_WIDTH (w)
-               : WINDOW_TOTAL_FRINGE_WIDTH (w))
+               : WINDOW_FRINGES_WIDTH (w))
               + window_box_width (w, LEFT_MARGIN_AREA)
               + window_box_width (w, TEXT_AREA));
       else
@@ -5367,7 +5380,7 @@ handle_window_change_signal (int sig)
           /* Record the new sizes, but don't reallocate the data
              structures now.  Let that be done later outside of the
              signal handler.  */
-          change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
+          change_frame_size (XFRAME (frame), width, height, 0, 1, 0, 0);
     }
   }
 }
@@ -5401,17 +5414,21 @@ do_pending_window_change (bool safe)
         {
           struct frame *f = XFRAME (frame);
 
-          if (f->new_text_lines != 0 || f->new_text_cols != 0)
-            change_frame_size (f, f->new_text_lines, f->new_text_cols,
-                               0, 0, safe);
+          if (f->new_height != 0 || f->new_width != 0)
+            change_frame_size (f, f->new_width, f->new_height,
+                               0, 0, safe, f->new_pixelwise);
         }
     }
 }
 
-
 /* Change the frame height and/or width.  Values may be given as zero to
    indicate no change is to take place.
 
+   new_height and new_width refer to the text portion of the frame.  It
+   doesn't matter for new_height, since text and total portion are the
+   same in that case.  But new_width must be enlarged to get the total
+   width of the frame.
+
    If DELAY, assume we're being called from a signal handler, and
    queue the change for later - perhaps the next redisplay.
    Since this tries to resize windows, we can't call it
@@ -5421,8 +5438,8 @@ do_pending_window_change (bool safe)
    safe to change frame sizes while a redisplay is in progress.  */
 
 void
-change_frame_size (struct frame *f, int newheight, int newwidth,
-                   bool pretend, bool delay, bool safe)
+change_frame_size (struct frame *f, int new_width, int new_height,
+                   bool pretend, bool delay, bool safe, bool pixelwise)
 {
   Lisp_Object tail, frame;
 
@@ -5433,55 +5450,72 @@ change_frame_size (struct frame *f, int newheight, int newwidth,
          ttys. */
       FOR_EACH_FRAME (tail, frame)
         if (! FRAME_WINDOW_P (XFRAME (frame)))
-          change_frame_size_1 (XFRAME (frame), newheight, newwidth,
-                               pretend, delay, safe);
+          change_frame_size_1 (XFRAME (frame), new_width, new_height,
+                               pretend, delay, safe, pixelwise);
     }
   else
-    change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe);
+    change_frame_size_1 (f, new_width, new_height, pretend, delay, safe,
+                         pixelwise);
 }
 
 static void
-change_frame_size_1 (struct frame *f, int newheight, int newwidth,
-                     bool pretend, bool delay, bool safe)
+change_frame_size_1 (struct frame *f, int new_width, int new_height,
+                     bool pretend, bool delay, bool safe, bool pixelwise)
 {
-  int new_frame_total_cols;
+  int new_text_width, new_text_height, new_root_width;
+  int old_root_width = (FRAME_PIXEL_WIDTH (f)
+                        - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
+  int new_cols, new_lines;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   /* If we can't deal with the change now, queue it for later.  */
   if (delay || (redisplaying_p && !safe))
     {
-      f->new_text_lines = newheight;
-      f->new_text_cols = newwidth;
+      f->new_width = new_width;
+      f->new_height = new_height;
+      f->new_pixelwise = pixelwise;
       delayed_size_change = 1;
       return;
     }
 
   /* This size-change overrides any pending one for this frame.  */
-  f->new_text_lines = 0;
-  f->new_text_cols = 0;
+  f->new_height = 0;
+  f->new_width = 0;
+  f->new_pixelwise = 0;
 
   /* If an argument is zero, set it to the current value.  */
-  if (newheight == 0)
-    newheight = FRAME_LINES (f);
-  if (newwidth == 0)
-    newwidth  = FRAME_COLS  (f);
+  if (pixelwise)
+    {
+      new_text_width = (new_width == 0) ? FRAME_TEXT_WIDTH (f) : new_width;
+      new_text_height = (new_height == 0) ? FRAME_TEXT_HEIGHT (f) : new_height;
+      new_cols = new_text_width / FRAME_COLUMN_WIDTH (f);
+      new_lines = new_text_height / FRAME_LINE_HEIGHT (f);
+    }
+  else
+    {
+      new_cols = (new_width == 0) ? FRAME_COLS (f) : new_width;
+      new_lines = (new_height == 0) ? FRAME_LINES (f) : new_height;
+      new_text_width = new_cols * FRAME_COLUMN_WIDTH (f);
+      new_text_height = new_lines * FRAME_LINE_HEIGHT (f);
+    }
 
   /* Compute width of windows in F.  */
   /* Round up to the smallest acceptable size.  */
-  check_frame_size (f, &newheight, &newwidth);
-
-  /* This is the width of the frame with vertical scroll bars and fringe
-     columns.  Do this after rounding - see discussion of bug#9723.  */
-  new_frame_total_cols = FRAME_TOTAL_COLS_ARG (f, newwidth);
-
+  check_frame_size (f, &new_text_width, &new_text_height, 1);
+
+  /* This is the width of the frame without vertical scroll bars and
+     fringe columns.  Do this after rounding - see discussion of
+     bug#9723.  */
+  new_root_width = (new_text_width
+                    /* PXM: Use the configured scrollbar width !??  */
+                    + FRAME_SCROLL_BAR_AREA_WIDTH (f)
+                    + FRAME_TOTAL_FRINGE_WIDTH (f));
   /* If we're not changing the frame size, quit now.  */
   /* Frame width may be unchanged but the text portion may change, for
      example, fullscreen and remove/add scroll bar.  */
-  if (newheight == FRAME_LINES (f)
-      /* Text portion unchanged?  */
-      && newwidth == FRAME_COLS  (f)
-      /* Frame width unchanged?  */
-      && new_frame_total_cols == FRAME_TOTAL_COLS (f))
+  if (new_text_height == FRAME_TEXT_HEIGHT (f)
+      && new_text_width == FRAME_TEXT_WIDTH (f)
+      && new_root_width == old_root_width)
     return;
 
   block_input ();
@@ -5490,36 +5524,44 @@ change_frame_size_1 (struct frame *f, int newheight, int newwidth,
   /* We only can set screen dimensions to certain values supported
      by our video hardware.  Try to find the smallest size greater
      or equal to the requested dimensions.  */
-  dos_set_window_size (&newheight, &newwidth);
+  dos_set_window_size (&new_lines, &new_cols);
 #endif
 
-  if (newheight != FRAME_LINES (f))
+  if (new_text_height != FRAME_TEXT_HEIGHT (f))
     {
-      resize_frame_windows (f, newheight, 0);
+      resize_frame_windows (f, new_text_height, 0, 1);
 
       /* MSDOS frames cannot PRETEND, as they change frame size by
          manipulating video hardware.  */
       if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
-        FrameRows (FRAME_TTY (f)) = newheight;
+        FrameRows (FRAME_TTY (f)) = new_height;
     }
 
-  if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
+  if (new_text_width != FRAME_TEXT_WIDTH (f)
+      || new_root_width != old_root_width)
     {
-      resize_frame_windows (f, new_frame_total_cols, 1);
+      resize_frame_windows (f, new_root_width, 1, 1);
 
       /* MSDOS frames cannot PRETEND, as they change frame size by
          manipulating video hardware.  */
       if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
-        FrameCols (FRAME_TTY (f)) = newwidth;
+        FrameCols (FRAME_TTY (f)) = new_cols;
 
 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
       if (WINDOWP (f->tool_bar_window))
-        XWINDOW (f->tool_bar_window)->total_cols = newwidth;
+        {
+          XWINDOW (f->tool_bar_window)->total_cols = new_cols;
+          XWINDOW (f->tool_bar_window)->pixel_width = new_root_width;
+        }
 #endif
     }
 
-  FRAME_LINES (f) = newheight;
-  SET_FRAME_COLS (f, newwidth);
+  SET_FRAME_COLS (f, new_cols);
+  FRAME_LINES (f) = new_lines;
+  FRAME_TEXT_WIDTH (f) = new_text_width;
+  FRAME_TEXT_HEIGHT (f) = new_text_height;
+  FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_TO_PIXEL_WIDTH (f, new_text_width);
+  FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_TO_PIXEL_HEIGHT (f, new_text_height);
 
   {
     struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
@@ -5546,8 +5588,6 @@ change_frame_size_1 (struct frame *f, int newheight, int newwidth,
 
   unbind_to (count, Qnil);
 }
-
-
 
 /***********************************************************************
                    Terminal Related Lisp Functions
@@ -6076,8 +6116,8 @@ init_display (void)
 #endif
     t->display_info.tty->top_frame = selected_frame;
     change_frame_size (XFRAME (selected_frame),
-                       FrameRows (t->display_info.tty),
-                       FrameCols (t->display_info.tty), 0, 0, 1);
+                       FrameCols (t->display_info.tty),
+                       FrameRows (t->display_info.tty), 0, 0, 1, 0);
 
     /* Delete the initial terminal. */
     if (--initial_terminal->reference_count == 0
diff --git a/src/editfns.c b/src/editfns.c
index 277e5b60704..8e47d1f82e4 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -343,16 +343,15 @@ overlays_around (EMACS_INT pos, Lisp_Object *vec, ptrdiff_t len)
   return idx;
 }
 
-/* Return the value of property PROP, in OBJECT at POSITION.
-   It's the value of PROP that a char inserted at POSITION would get.
-   OBJECT is optional and defaults to the current buffer.
-   If OBJECT is a buffer, then overlay properties are considered as well as
-   text properties.
-   If OBJECT is a window, then that window's buffer is used, but
-   window-specific overlays are considered only if they are associated
-   with OBJECT. */
-Lisp_Object
-get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
+DEFUN ("get-pos-property", Fget_pos_property, Sget_pos_property, 2, 3, 0,
+       doc: /* Return the value of POSITION's property PROP, in OBJECT.
+Almost identical to `get-char-property' except for the following difference:
+Whereas `get-char-property' returns the property of the char at (i.e. right
+after) POSITION, this pays attention to properties's stickiness and overlays's
+advancement settings, in order to find the property of POSITION itself,
+i.e. the property that a char would inherit if it were inserted
+at POSITION.  */)
+  (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
 {
   CHECK_NUMBER_COERCE_MARKER (position);
 
@@ -484,7 +483,7 @@ find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
      specially.  */
   if (NILP (merge_at_boundary))
     {
-      Lisp_Object field = get_pos_property (pos, Qfield, Qnil);
+      Lisp_Object field = Fget_pos_property (pos, Qfield, Qnil);
       if (!EQ (field, after_field))
         at_field_end = 1;
       if (!EQ (field, before_field))
@@ -683,7 +682,7 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
       && (!NILP (Fget_char_property (new_pos, Qfield, Qnil))
           || !NILP (Fget_char_property (old_pos, Qfield, Qnil))
           /* To recognize field boundaries, we must also look at the
-             previous positions; we could use `get_pos_property'
+             previous positions; we could use `Fget_pos_property'
              instead, but in itself that would fail inside non-sticky
              fields (like comint prompts).  */
           || (XFASTINT (new_pos) > BEGV
@@ -694,10 +693,12 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
           /* Field boundaries are again a problem; but now we must
              decide the case exactly, so we need to call
              `get_pos_property' as well.  */
-          || (NILP (get_pos_property (old_pos, inhibit_capture_property, Qnil))
+          || (NILP (Fget_pos_property (old_pos, inhibit_capture_property, Qnil))
               && (XFASTINT (old_pos) <= BEGV
-                  || NILP (Fget_char_property (old_pos, inhibit_capture_property, Qnil))
-                  || NILP (Fget_char_property (prev_old, inhibit_capture_property, Qnil))))))
+                  || NILP (Fget_char_property
+                           (old_pos, inhibit_capture_property, Qnil))
+                  || NILP (Fget_char_property
+                           (prev_old, inhibit_capture_property, Qnil))))))
     /* It is possible that NEW_POS is not within the same field as
        OLD_POS; try to move NEW_POS so that it is.  */
     {
@@ -717,7 +718,7 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
           /* NEW_POS should be constrained, but only if either
              ONLY_IN_LINE is nil (in which case any constraint is OK),
              or NEW_POS and FIELD_BOUND are on the same line (in which
-             case the constraint is OK even if ONLY_IN_LINE is non-nil). */
+             case the constraint is OK even if ONLY_IN_LINE is non-nil).  */
           && (NILP (only_in_line)
               /* This is the ONLY_IN_LINE case, check that NEW_POS and
                  FIELD_BOUND are on the same line by seeing whether
@@ -3472,7 +3473,6 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
   else
     {
       Lisp_Object val = Fformat (nargs, args);
-#ifdef HAVE_MENUS
       Lisp_Object pane, menu;
       struct gcpro gcpro1;
 
@@ -3481,9 +3481,6 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
       menu = Fcons (val, pane);
       Fx_popup_dialog (Qt, menu, Qt);
       UNGCPRO;
-#else /* !HAVE_MENUS */
-      message3 (val);
-#endif
       return val;
     }
 }
@@ -3502,11 +3499,9 @@ message; let the minibuffer contents show.
 usage: (message-or-box FORMAT-STRING &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-#ifdef HAVE_MENUS
   if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
       && use_dialog_box)
     return Fmessage_box (nargs, args);
-#endif
   return Fmessage (nargs, args);
 }
 
@@ -4836,6 +4831,7 @@ functions if all the text being accessed has this property.  */);
   defsubr (&Sbuffer_substring);
   defsubr (&Sbuffer_substring_no_properties);
   defsubr (&Sbuffer_string);
+  defsubr (&Sget_pos_property);
 
   defsubr (&Spoint_marker);
   defsubr (&Smark_marker);
diff --git a/src/emacs.c b/src/emacs.c
index 22be1d82949..af69e2c4efe 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1539,6 +1539,10 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
   init_keyboard ();     /* This too must precede init_sys_modes.  */
   if (!noninteractive)
     init_display ();    /* Determine terminal type.  Calls init_sys_modes.  */
+#if HAVE_W32NOTIFY
+  else
+    init_crit ();       /* w32notify.c needs this in batch mode.  */
+#endif  /* HAVE_W32NOTIFY */
   init_xdisp ();
 #ifdef HAVE_WINDOW_SYSTEM
   init_fringe ();
@@ -2198,10 +2202,13 @@ synchronize_system_messages_locale (void)
 
 
 Lisp_Object
-decode_env_path (const char *evarname, const char *defalt)
+decode_env_path (const char *evarname, const char *defalt, bool empty)
 {
   const char *path, *p;
   Lisp_Object lpath, element, tem;
+  /* Default is to use "." for empty path elements.
+     But if argument EMPTY is true, use nil instead.  */
+  Lisp_Object empty_element = empty ? Qnil : build_string (".");
 #ifdef WINDOWSNT
   bool defaulted = 0;
   static const char *emacs_dir_env = "%emacs_dir%/";
@@ -2281,34 +2288,38 @@ decode_env_path (const char *evarname, const char *defalt)
       if (!p)
         p = path + strlen (path);
       element = (p - path ? make_unibyte_string (path, p - path)
-                 : build_string ("."));
+                 : empty_element);
+      if (! NILP (element))
+        {
 #ifdef WINDOWSNT
-      /* Relative file names in the default path are interpreted as
-         being relative to $emacs_dir.  */
-      if (emacs_dir && defaulted
-          && strncmp (path, emacs_dir_env, emacs_dir_len) == 0)
-        element = Fexpand_file_name (Fsubstring (element,
-                                                 make_number (emacs_dir_len),
-                                                 Qnil),
-                                     build_unibyte_string (emacs_dir));
-#endif
-
-      /* Add /: to the front of the name
-         if it would otherwise be treated as magic.  */
-      tem = Ffind_file_name_handler (element, Qt);
-
-      /* However, if the handler says "I'm safe",
-         don't bother adding /:.  */
-      if (SYMBOLP (tem))
-        {
-          Lisp_Object prop;
-          prop = Fget (tem, intern ("safe-magic"));
-          if (! NILP (prop))
-            tem = Qnil;
-        }
+          /* Relative file names in the default path are interpreted as
+             being relative to $emacs_dir.  */
+          if (emacs_dir && defaulted
+              && strncmp (path, emacs_dir_env, emacs_dir_len) == 0)
+            element = Fexpand_file_name (Fsubstring
+                                         (element,
+                                          make_number (emacs_dir_len),
+                                          Qnil),
+                                         build_unibyte_string (emacs_dir));
+#endif
+
+          /* Add /: to the front of the name
+             if it would otherwise be treated as magic.  */
+          tem = Ffind_file_name_handler (element, Qt);
+
+          /* However, if the handler says "I'm safe",
+             don't bother adding /:.  */
+          if (SYMBOLP (tem))
+            {
+              Lisp_Object prop;
+              prop = Fget (tem, intern ("safe-magic"));
+              if (! NILP (prop))
+                tem = Qnil;
+            }
 
-      if (! NILP (tem))
-        element = concat2 (build_string ("/:"), element);
+          if (! NILP (tem))
+            element = concat2 (build_string ("/:"), element);
+        } /* !NILP (element) */
 
       lpath = Fcons (element, lpath);
       if (*p)
diff --git a/src/epaths.in b/src/epaths.in
index 1f5701e5337..5bfc7158316 100644
--- a/src/epaths.in
+++ b/src/epaths.in
@@ -1,7 +1,6 @@
 /* Hey Emacs, this is -*- C -*- code!  */
 /*
-Copyright (C) 1993, 1995, 1997, 1999, 2001-2013 Free Software
-Foundation, Inc.
+Copyright (C) 1993, 1995, 1997, 1999, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -23,8 +22,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    load-path, which is the search path for the Lisp function "load".
    Configure (using "make epaths-force") sets this to
    ${standardlisppath}, which typically has a value like:
-   <datadir>/emacs/VERSION/lisp:<datadir>/emacs/VERSION/leim
-   where datadir is eg /usr/local/share.
+   <datadir>/emacs/VERSION/lisp where datadir is eg /usr/local/share.
 */
 #define PATH_LOADSEARCH "/usr/local/share/emacs/lisp"
 
diff --git a/src/eval.c b/src/eval.c
index d3fcec5aef4..81666830f4e 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3576,6 +3576,73 @@ NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'.
      from the debugger.  */
   return unbind_to (count, eval_sub (exp));
 }
+
+DEFUN ("backtrace--locals", Fbacktrace__locals, Sbacktrace__locals, 1, 2, NULL,
+       doc: /* Return names and values of local variables of a stack frame.
+NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'.  */)
+  (Lisp_Object nframes, Lisp_Object base)
+{
+  union specbinding *frame = get_backtrace_frame (nframes, base);
+  union specbinding *prevframe
+    = get_backtrace_frame (make_number (XFASTINT (nframes) - 1), base);
+  ptrdiff_t distance = specpdl_ptr - frame;
+  Lisp_Object result = Qnil;
+  eassert (distance >= 0);
+
+  if (!backtrace_p (prevframe))
+    error ("Activation frame not found!");
+  if (!backtrace_p (frame))
+    error ("Activation frame not found!");
+
+  /* The specpdl entries normally contain the symbol being bound along with its
+     `old_value', so it can be restored.  The new value to which it is bound is
+     available in one of two places: either in the current value of the
+     variable (if it hasn't been rebount yet) or in the `old_value' slot of the
+     next specpdl entry for it.
+     `backtrace_eval_unrewind' happens to swap the role of `old_value'
+     and "new value", so we abuse it here, to fetch the new value.
+     It's ugly (we'd rather not modify global data) and a bit inefficient,
+     but it does the job for now.  */
+  backtrace_eval_unrewind (distance);
+
+  /* Grab values.  */
+  {
+    union specbinding *tmp = prevframe;
+    for (; tmp > frame; tmp--)
+      {
+        switch (tmp->kind)
+          {
+          case SPECPDL_LET:
+          case SPECPDL_LET_DEFAULT:
+          case SPECPDL_LET_LOCAL:
+            {
+              Lisp_Object sym = specpdl_symbol (tmp);
+              Lisp_Object val = specpdl_old_value (tmp);
+              if (EQ (sym, Qinternal_interpreter_environment))
+                {
+                  Lisp_Object env = val;
+                  for (; CONSP (env); env = XCDR (env))
+                    {
+                      Lisp_Object binding = XCAR (env);
+                      if (CONSP (binding))
+                        result = Fcons (Fcons (XCAR (binding),
+                                               XCDR (binding)),
+                                        result);
+                    }
+                }
+              else
+                result = Fcons (Fcons (sym, val), result);
+            }
+          }
+      }
+  }
+
+  /* Restore values from specpdl to original place.  */
+  backtrace_eval_unrewind (-distance);
+
+  return result;
+}
+
 
 void
 mark_specpdl (void)
@@ -3824,6 +3891,7 @@ alist of active lexical bindings.  */);
   defsubr (&Sbacktrace);
   defsubr (&Sbacktrace_frame);
   defsubr (&Sbacktrace_eval);
+  defsubr (&Sbacktrace__locals);
   defsubr (&Sspecial_variable_p);
   defsubr (&Sfunctionp);
 }
diff --git a/src/fileio.c b/src/fileio.c
index 7b4bd7f196d..2ef3f1fe0f9 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3878,6 +3878,9 @@ by calling `format-decode', which see.  */)
           beg_offset += same_at_start - BEGV_BYTE;
           end_offset -= ZV_BYTE - same_at_end;
 
+          invalidate_buffer_caches (current_buffer,
+                                    BYTE_TO_CHAR (same_at_start),
+                                    BYTE_TO_CHAR (same_at_end));
           del_range_byte (same_at_start, same_at_end, 0);
           /* Insert from the file at the proper position.  */
           temp = BYTE_TO_CHAR (same_at_start);
@@ -3988,7 +3991,12 @@ by calling `format-decode', which see.  */)
         {
           /* Truncate the buffer to the size of the file.  */
           if (same_at_start != same_at_end)
-            del_range_byte (same_at_start, same_at_end, 0);
+            {
+              invalidate_buffer_caches (current_buffer,
+                                        BYTE_TO_CHAR (same_at_start),
+                                        BYTE_TO_CHAR (same_at_end));
+              del_range_byte (same_at_start, same_at_end, 0);
+            }
           inserted = 0;
 
           unbind_to (this_count, Qnil);
@@ -4036,6 +4044,9 @@ by calling `format-decode', which see.  */)
 
       if (same_at_end != same_at_start)
         {
+          invalidate_buffer_caches (current_buffer,
+                                    BYTE_TO_CHAR (same_at_start),
+                                    BYTE_TO_CHAR (same_at_end));
           del_range_byte (same_at_start, same_at_end, 0);
           temp = GPT;
           eassert (same_at_start == GPT_BYTE);
@@ -5793,6 +5804,24 @@ void
 init_fileio (void)
 {
   valid_timestamp_file_system = 0;
+
+  /* fsync can be a significant performance hit.  Often it doesn't
+     suffice to make the file-save operation survive a crash.  For
+     batch scripts, which are typically part of larger shell commands
+     that don't fsync other files, its effect on performance can be
+     significant so its utility is particularly questionable.
+     Hence, for now by default fsync is used only when interactive.
+
+     For more on why fsync often fails to work on today's hardware, see:
+     Zheng M et al. Understanding the robustness of SSDs under power fault.
+     11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
+     http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
+
+     For more on why fsync does not suffice even if it works properly, see:
+     Roche X. Necessary step(s) to synchronize filename operations on disk.
+     Austin Group Defect 672, 2013-03-19
+     http://austingroupbugs.net/view.php?id=672  */
+  write_region_inhibit_fsync = noninteractive;
 }
 
 void
@@ -6013,28 +6042,12 @@ in the buffer; this is the default behavior, because the auto-save
 file is usually more useful if it contains the deleted text.  */);
   Vauto_save_include_big_deletions = Qnil;
 
-  /* fsync can be a significant performance hit.  Often it doesn't
-     suffice to make the file-save operation survive a crash.  For
-     batch scripts, which are typically part of larger shell commands
-     that don't fsync other files, its effect on performance can be
-     significant so its utility is particularly questionable.
-     Hence, for now by default fsync is used only when interactive.
-
-     For more on why fsync often fails to work on today's hardware, see:
-     Zheng M et al. Understanding the robustness of SSDs under power fault.
-     11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
-     http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
-
-     For more on why fsync does not suffice even if it works properly, see:
-     Roche X. Necessary step(s) to synchronize filename operations on disk.
-     Austin Group Defect 672, 2013-03-19
-     http://austingroupbugs.net/view.php?id=672  */
   DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync,
                doc: /* Non-nil means don't call fsync in `write-region'.
 This variable affects calls to `write-region' as well as save commands.
 Setting this to nil may avoid data loss if the system loses power or
 the operating system crashes.  */);
-  write_region_inhibit_fsync = noninteractive;
+  write_region_inhibit_fsync = 0; /* See also `init_fileio' above.  */
 
   DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash,
                doc: /* Specifies whether to use the system's trash can.
diff --git a/src/fns.c b/src/fns.c
index 93829fb1d62..b13bb8d80dc 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -35,11 +35,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "window.h"
 #include "blockinput.h"
-#ifdef HAVE_MENUS
 #if defined (HAVE_X_WINDOWS)
 #include "xterm.h"
 #endif
-#endif /* HAVE_MENUS */
 
 Lisp_Object Qstring_lessp;
 static Lisp_Object Qprovide, Qrequire;
@@ -50,7 +48,7 @@ static Lisp_Object Qcodeset, Qdays, Qmonths, Qpaper;
 
 static Lisp_Object Qmd5, Qsha1, Qsha224, Qsha256, Qsha384, Qsha512;
 
-static bool internal_equal (Lisp_Object, Lisp_Object, int, bool);
+static bool internal_equal (Lisp_Object, Lisp_Object, int, bool, Lisp_Object);
 
 DEFUN ("identity", Fidentity, Sidentity, 1, 1, 0,
        doc: /* Return the argument unchanged.  */)
@@ -1357,7 +1355,7 @@ The value is actually the tail of LIST whose car is ELT.  */)
       register Lisp_Object tem;
       CHECK_LIST_CONS (tail, list);
       tem = XCAR (tail);
-      if (FLOATP (tem) && internal_equal (elt, tem, 0, 0))
+      if (FLOATP (tem) && internal_equal (elt, tem, 0, 0, Qnil))
         return tail;
       QUIT;
     }
@@ -1539,15 +1537,12 @@ Write `(setq foo (delq element foo))' to be sure of correctly changing
 the value of a list `foo'.  */)
   (register Lisp_Object elt, Lisp_Object list)
 {
-  register Lisp_Object tail, prev;
-  register Lisp_Object tem;
+  Lisp_Object tail, tortoise, prev = Qnil;
+  bool skip;
 
-  tail = list;
-  prev = Qnil;
-  while (CONSP (tail))
+  FOR_EACH_TAIL (tail, list, tortoise, skip)
     {
-      CHECK_LIST_CONS (tail, list);
-      tem = XCAR (tail);
+      Lisp_Object tem = XCAR (tail);
       if (EQ (elt, tem))
         {
           if (NILP (prev))
@@ -1557,8 +1552,6 @@ the value of a list `foo'.  */)
         }
       else
         prev = tail;
-      tail = XCDR (tail);
-      QUIT;
     }
   return list;
 }
@@ -1961,7 +1954,7 @@ Floating-point numbers of equal value are `eql', but they may not be `eq'.  */)
   (Lisp_Object obj1, Lisp_Object obj2)
 {
   if (FLOATP (obj1))
-    return internal_equal (obj1, obj2, 0, 0) ? Qt : Qnil;
+    return internal_equal (obj1, obj2, 0, 0, Qnil) ? Qt : Qnil;
   else
     return EQ (obj1, obj2) ? Qt : Qnil;
 }
@@ -1976,7 +1969,7 @@ Numbers are compared by value, but integers cannot equal floats.
 Symbols must match exactly.  */)
   (register Lisp_Object o1, Lisp_Object o2)
 {
-  return internal_equal (o1, o2, 0, 0) ? Qt : Qnil;
+  return internal_equal (o1, o2, 0, 0, Qnil) ? Qt : Qnil;
 }
 
 DEFUN ("equal-including-properties", Fequal_including_properties, Sequal_including_properties, 2, 2, 0,
@@ -1985,7 +1978,7 @@ This is like `equal' except that it compares the text properties
 of strings.  (`equal' ignores text properties.)  */)
   (register Lisp_Object o1, Lisp_Object o2)
 {
-  return internal_equal (o1, o2, 0, 1) ? Qt : Qnil;
+  return internal_equal (o1, o2, 0, 1, Qnil) ? Qt : Qnil;
 }
 
 /* DEPTH is current depth of recursion.  Signal an error if it
@@ -1993,10 +1986,39 @@ of strings.  (`equal' ignores text properties.)  */)
    PROPS means compare string text properties too.  */
 
 static bool
-internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
+internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
+                Lisp_Object ht)
 {
-  if (depth > 200)
-    error ("Stack overflow in equal");
+  if (depth > 10)
+    {
+      if (depth > 200)
+        error ("Stack overflow in equal");
+      if (NILP (ht))
+        {
+          Lisp_Object args[2] = { QCtest, Qeq };
+          ht = Fmake_hash_table (2, args);
+        }
+      switch (XTYPE (o1))
+        {
+        case Lisp_Cons: case Lisp_Misc: case Lisp_Vectorlike:
+          {
+            struct Lisp_Hash_Table *h = XHASH_TABLE (ht);
+            EMACS_UINT hash;
+            ptrdiff_t i = hash_lookup (h, o1, &hash);
+            if (i >= 0)
+              { /* `o1' was seen already.  */
+                Lisp_Object o2s = HASH_VALUE (h, i);
+                if (!NILP (Fmemq (o2, o2s)))
+                  return 1;
+                else
+                  set_hash_value_slot (h, i, Fcons (o2, o2s));
+              }
+            else
+              hash_put (h, o1, Fcons (o2, Qnil), hash);
+          }
+        default: ;
+        }
+    }
 
  tail_recurse:
   QUIT;
@@ -2019,10 +2041,11 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
       }
 
     case Lisp_Cons:
-      if (!internal_equal (XCAR (o1), XCAR (o2), depth + 1, props))
+      if (!internal_equal (XCAR (o1), XCAR (o2), depth + 1, props, ht))
         return 0;
       o1 = XCDR (o1);
       o2 = XCDR (o2);
+      /* FIXME: This inf-loops in a circular list!  */
       goto tail_recurse;
 
     case Lisp_Misc:
@@ -2031,9 +2054,9 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
       if (OVERLAYP (o1))
         {
           if (!internal_equal (OVERLAY_START (o1), OVERLAY_START (o2),
-                               depth + 1, props)
+                               depth + 1, props, ht)
               || !internal_equal (OVERLAY_END (o1), OVERLAY_END (o2),
-                                  depth + 1, props))
+                                  depth + 1, props, ht))
             return 0;
           o1 = XOVERLAY (o1)->plist;
           o2 = XOVERLAY (o2)->plist;
@@ -2085,7 +2108,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
             Lisp_Object v1, v2;
             v1 = AREF (o1, i);
             v2 = AREF (o2, i);
-            if (!internal_equal (v1, v2, depth + 1, props))
+            if (!internal_equal (v1, v2, depth + 1, props, ht))
               return 0;
           }
         return 1;
@@ -2416,7 +2439,6 @@ if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil.  */)
 
   CHECK_STRING (prompt);
 
-#ifdef HAVE_MENUS
   if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
       && use_dialog_box)
     {
@@ -2430,7 +2452,6 @@ if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil.  */)
       UNGCPRO;
       return obj;
     }
-#endif /* HAVE_MENUS */
 
   args[0] = prompt;
   args[1] = build_string ("(yes or no) ");
diff --git a/src/font.c b/src/font.c
index 1e1670b21af..ad604ebe744 100644
--- a/src/font.c
+++ b/src/font.c
@@ -2718,7 +2718,7 @@ font_list_entities (struct frame *f, Lisp_Object spec)
   ASET (scratch_font_spec, FONT_SPACING_INDEX, AREF (spec, FONT_SPACING_INDEX));
   ASET (scratch_font_spec, FONT_EXTRA_INDEX, AREF (spec, FONT_EXTRA_INDEX));
 
-  for (i = 0; driver_list; driver_list = driver_list->next)
+  for (; driver_list; driver_list = driver_list->next)
     if (driver_list->on
         && (NILP (ftype) || EQ (driver_list->driver->type, ftype)))
       {
diff --git a/src/font.h b/src/font.h
index 2db8d35af48..539ebeba52a 100644
--- a/src/font.h
+++ b/src/font.h
@@ -234,6 +234,11 @@ enum font_property_index
 #define FONT_SET_STYLE(font, prop, val) \
   ASET ((font), prop, make_number (font_style_to_value (prop, val, 1)))
 
+#define FONT_WIDTH(f) ((f)->max_width)
+#define FONT_HEIGHT(f) ((f)->height)
+#define FONT_BASE(f) ((f)->ascent)
+#define FONT_DESCENT(f) ((f)->descent)
+
 extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript;
 extern Lisp_Object QCavgwidth, QCantialias, QCfont_entity;
 extern Lisp_Object Qp;
@@ -307,6 +312,10 @@ struct font
   /* Ascent and descent of the font (in pixels).  */
   int ascent, descent;
 
+  /* The following members makes sense on graphic displays only.  */
+
+#if defined (HAVE_WINDOW_SYSTEM)
+
   /* Vertical pixel width of the underline.  If is zero if that
      information is not in the font.  */
   int underline_thickness;
@@ -369,12 +378,6 @@ struct font
      registered in char-table `use-default-ascent'.  */
   int default_ascent;
 
-  /* CCL program to calculate code points of the font.  */
-  struct ccl_program *font_encoder;
-
-  /* Font-driver for the font.  */
-  struct font_driver *driver;
-
   /* Charset to encode a character code into a glyph code of the font.
      -1 means that the font doesn't require this information to encode
      a character.  */
@@ -385,6 +388,11 @@ struct font
      determine it.  */
   int repertory_charset;
 
+#endif /* HAVE_WINDOW_SYSTEM */
+
+  /* Font-driver for the font.  */
+  struct font_driver *driver;
+
   /* There are more members in this structure, but they are private
      to the font-driver.  */
 };
@@ -412,7 +420,6 @@ struct font_bitmap
   int left;
   int top;
   int advance;
-  void *extra;
 };
 
 /* Predicates to check various font-related objects.  */
diff --git a/src/frame.c b/src/frame.c
index 4494edda5d7..03bdf696c47 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -78,6 +78,7 @@ Lisp_Object Qleft, Qright;
 Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
 Lisp_Object Qtooltip;
 Lisp_Object Qinternal_border_width;
+Lisp_Object Qright_divider_width, Qbottom_divider_width;
 Lisp_Object Qmouse_color;
 Lisp_Object Qminibuffer;
 Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
@@ -109,6 +110,8 @@ Lisp_Object Qalpha;
 
 Lisp_Object Qface_set_after_frame_default;
 
+static Lisp_Object Qfocus_in_hook;
+static Lisp_Object Qfocus_out_hook;
 static Lisp_Object Qdelete_frame_functions;
 
 static Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
@@ -195,9 +198,12 @@ static void
 set_menu_bar_lines_1 (Lisp_Object window, int n)
 {
   struct window *w = XWINDOW (window);
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
 
   w->top_line += n;
+  w->pixel_top += n * FRAME_LINE_HEIGHT (f);
   w->total_lines -= n;
+  w->pixel_height -= n * FRAME_LINE_HEIGHT (f);
 
   /* Handle just the top child in a vertical split.  */
   if (WINDOW_VERTICAL_COMBINATION_P (w))
@@ -234,6 +240,7 @@ set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       windows_or_buffers_changed = 14;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       FRAME_MENU_BAR_LINES (f) = nlines;
+      FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
       set_menu_bar_lines_1 (f->root_window, nlines - olines);
       adjust_frame_glyphs (f);
     }
@@ -323,6 +330,7 @@ make_frame (bool mini_p)
 {
   Lisp_Object frame;
   register struct frame *f;
+  register struct window *rw, *mw;
   register Lisp_Object root_window;
   register Lisp_Object mini_window;
 
@@ -337,33 +345,36 @@ make_frame (bool mini_p)
      non-Lisp data, so do it only for slots which should not be zero.
      To avoid subtle bugs and for the sake of readability, it's better to
      initialize enum members explicitly even if their values are zero.  */
-  f->wants_modeline = 1;
-  f->garbaged = 1;
+  f->wants_modeline = true;
+  f->redisplay = true;
+  f->garbaged = true;
   f->vertical_scroll_bar_type = vertical_scroll_bar_none;
-  f->column_width = 1;  /* !FRAME_WINDOW_P value */
-  f->line_height = 1;  /* !FRAME_WINDOW_P value */
+  f->column_width = 1;  /* !FRAME_WINDOW_P value.  */
+  f->line_height = 1;  /* !FRAME_WINDOW_P value.  */
 #ifdef HAVE_WINDOW_SYSTEM
   f->want_fullscreen = FULLSCREEN_NONE;
 #endif
 
   root_window = make_window ();
+  rw = XWINDOW (root_window);
   if (mini_p)
     {
       mini_window = make_window ();
-      wset_next (XWINDOW (root_window), mini_window);
-      wset_prev (XWINDOW (mini_window), root_window);
-      XWINDOW (mini_window)->mini = 1;
-      wset_frame (XWINDOW (mini_window), frame);
+      mw = XWINDOW (mini_window);
+      wset_next (rw, mini_window);
+      wset_prev (mw, root_window);
+      mw->mini = 1;
+      wset_frame (mw, frame);
       fset_minibuffer_window (f, mini_window);
     }
   else
     {
       mini_window = Qnil;
-      wset_next (XWINDOW (root_window), Qnil);
+      wset_next (rw, Qnil);
       fset_minibuffer_window (f, Qnil);
     }
 
-  wset_frame (XWINDOW (root_window), frame);
+  wset_frame (rw, frame);
 
   /* 10 is arbitrary,
      just so that there is "something there."
@@ -371,15 +382,22 @@ make_frame (bool mini_p)
 
   SET_FRAME_COLS (f, 10);
   FRAME_LINES (f) = 10;
+  SET_FRAME_WIDTH (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f));
+  SET_FRAME_HEIGHT (f, FRAME_LINES (f) * FRAME_LINE_HEIGHT (f));
 
-  XWINDOW (root_window)->total_cols = 10;
-  XWINDOW (root_window)->total_lines = mini_p ? 9 : 10;
+  rw->total_cols = 10;
+  rw->pixel_width = rw->total_cols * FRAME_COLUMN_WIDTH (f);
+  rw->total_lines = mini_p ? 9 : 10;
+  rw->pixel_height = rw->total_lines * FRAME_LINE_HEIGHT (f);
 
   if (mini_p)
     {
-      XWINDOW (mini_window)->total_cols = 10;
-      XWINDOW (mini_window)->top_line = 9;
-      XWINDOW (mini_window)->total_lines = 1;
+      mw->top_line = rw->total_lines;
+      mw->pixel_top = rw->pixel_height;
+      mw->total_cols = rw->total_cols;
+      mw->pixel_width = rw->pixel_width;
+      mw->total_lines = 1;
+      mw->pixel_height = FRAME_LINE_HEIGHT (f);
     }
 
   /* Choose a buffer for the frame's root window.  */
@@ -600,7 +618,8 @@ make_terminal_frame (struct terminal *terminal)
 #endif /* not MSDOS */
 
   FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
-  FRAME_MENU_BAR_LINES(f) = NILP (Vmenu_bar_mode) ? 0 : 1;
+  FRAME_MENU_BAR_LINES (f) = NILP (Vmenu_bar_mode) ? 0 : 1;
+  FRAME_MENU_BAR_HEIGHT (f) = FRAME_MENU_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
 
   /* Set the top frame to the newly created frame. */
   if (FRAMEP (FRAME_TTY (f)->top_frame)
@@ -720,7 +739,7 @@ affects all frames on the same terminal device.  */)
   {
     int width, height;
     get_tty_size (fileno (FRAME_TTY (f)->input), &width, &height);
-    change_frame_size (f, height, width, 0, 0, 0);
+    change_frame_size (f, width, height, 0, 0, 0, 0);
   }
 
   adjust_frame_glyphs (f);
@@ -783,9 +802,6 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
   if (sf == XFRAME (frame))
     return frame;
 
-  /* This is too greedy; it causes inappropriate focus redirection
-     that's hard to get rid of.  */
-#if 0
   /* If a frame's focus has been redirected toward the currently
      selected frame, we should change the redirection to point to the
      newly selected frame.  This means that if the focus is redirected
@@ -793,6 +809,9 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
      can use `other-window' to switch between all the frames using
      that minibuffer frame, and the focus redirection will follow us
      around.  */
+#if 0
+  /* This is too greedy; it causes inappropriate focus redirection
+     that's hard to get rid of.  */
   if (track)
     {
       Lisp_Object tail;
@@ -885,27 +904,6 @@ This function returns FRAME, or nil if FRAME has been deleted.  */)
   return do_switch_frame (frame, 1, 0, norecord);
 }
 
-DEFUN ("handle-focus-in", Fhandle_focus_in, Shandle_focus_in, 1, 1, "e",
-       doc: /* Handle a focus-in event.
-Focus in events are usually bound to this function.
-Focus in events occur when a frame has focus, but a switch-frame event
-is not generated.
-This function checks if blink-cursor timers should be turned on again.  */)
-  (Lisp_Object event)
-{
-  return call0 (intern ("blink-cursor-check"));
-}
-
-DEFUN ("handle-focus-out", Fhandle_focus_out, Shandle_focus_out, 1, 1, "e",
-       doc: /* Handle a focus-out event.
-Focus out events are usually bound to this function.
-Focus out events occur when no frame has focus.
-This function checks if blink-cursor timers should be turned off.  */)
-  (Lisp_Object event)
-{
-  return call0 (intern ("blink-cursor-suspend"));
-}
-
 DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
        doc: /* Handle a switch-frame event EVENT.
 Switch-frame events are usually bound to this function.
@@ -920,7 +918,8 @@ to that frame.  */)
   /* Preserve prefix arg that the command loop just cleared.  */
   kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
   Frun_hooks (1, &Qmouse_leave_buffer_hook);
-  Fhandle_focus_in (event); // switch-frame implies a focus in.
+  /* `switch-frame' implies a focus in.  */
+  call1 (intern ("handle-focus-in"), event);
   return do_switch_frame (event, 0, 0, Qnil);
 }
 
@@ -1699,7 +1698,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
   make_frame_visible_1 (f->root_window);
 
   /* Make menu bar update for the Buffers and Frames menus.  */
-  windows_or_buffers_changed = 15;
+  /* windows_or_buffers_changed = 15; FIXME: Why?  */
 
   XSETFRAME (frame, f);
   return frame;
@@ -2028,6 +2027,20 @@ set_term_frame_name (struct frame *f, Lisp_Object name)
   update_mode_lines = 16;
 }
 
+#ifdef HAVE_NTGUI
+void
+set_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
+{
+  register Lisp_Object old_alist_elt;
+
+  old_alist_elt = Fassq (prop, f->param_alist);
+  if (EQ (old_alist_elt, Qnil))
+    fset_param_alist (f, Fcons (Fcons (prop, val), f->param_alist));
+  else
+    Fsetcdr (old_alist_elt, val);
+}
+#endif
+
 void
 store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
 {
@@ -2181,9 +2194,17 @@ If FRAME is omitted or nil, return information on the currently selected frame.
                                     :"tty"));
     }
   store_in_alist (&alist, Qname, f->name);
-  height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
+  height = (f->new_height
+            ? (f->new_pixelwise
+               ? (f->new_height / FRAME_LINE_HEIGHT (f))
+               : f->new_height)
+            : FRAME_LINES (f));
   store_in_alist (&alist, Qheight, make_number (height));
-  width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
+  width = (f->new_width
+           ? (f->new_pixelwise
+              ? (f->new_width / FRAME_COLUMN_WIDTH (f))
+              : f->new_width)
+           : FRAME_COLS (f));
   store_in_alist (&alist, Qwidth, make_number (width));
   store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
   store_in_alist (&alist, Qminibuffer,
@@ -2454,80 +2475,180 @@ is used.  */)
 #endif
   return make_number (0);
 }
+
+DEFUN ("frame-text-cols", Fframe_text_cols, Sframe_text_cols, 0, 1, 0,
+       doc: /* Return width in columns of FRAME's text area.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_COLS (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-text-lines", Fframe_text_lines, Sframe_text_lines, 0, 1, 0,
+       doc: /* Return height in lines of FRAME's text area.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_LINES (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-total-cols", Fframe_total_cols, Sframe_total_cols, 0, 1, 0,
+       doc: /* Return total columns of FRAME.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_TOTAL_COLS (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-text-width", Fframe_text_width, Sframe_text_width, 0, 1, 0,
+       doc: /* Return text area width of FRAME in pixels.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_TEXT_WIDTH (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-text-height", Fframe_text_height, Sframe_text_height, 0, 1, 0,
+       doc: /* Return text area height of FRAME in pixels.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_TEXT_HEIGHT (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-scroll-bar-width", Fscroll_bar_width, Sscroll_bar_width, 0, 1, 0,
+       doc: /* Return scroll bar width of FRAME in pixels.  */)
+  (Lisp_Object frame)
+{
+  return make_number (decode_any_frame (frame)->scroll_bar_actual_width);
+}
+
+DEFUN ("frame-fringe-width", Ffringe_width, Sfringe_width, 0, 1, 0,
+       doc: /* Return fringe width of FRAME in pixels.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_TOTAL_FRINGE_WIDTH (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-border-width", Fborder_width, Sborder_width, 0, 1, 0,
+       doc: /* Return border width of FRAME in pixels.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_INTERNAL_BORDER_WIDTH (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-right-divider-width", Fright_divider_width, Sright_divider_width, 0, 1, 0,
+       doc: /* Return width (in pixels) of vertical window dividers on FRAME.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_RIGHT_DIVIDER_WIDTH (decode_any_frame (frame)));
+}
+
+DEFUN ("frame-bottom-divider-width", Fbottom_divider_width, Sbottom_divider_width, 0, 1, 0,
+       doc: /* Return width (in pixels) of horizontal window dividers on FRAME.  */)
+  (Lisp_Object frame)
+{
+  return make_number (FRAME_BOTTOM_DIVIDER_WIDTH (decode_any_frame (frame)));
+}
 
-DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
-       doc: /* Specify that the frame FRAME has LINES lines.
-If FRAME is nil, the selected frame is used.  Optional third arg
-non-nil means that redisplay should use LINES lines but that the
-idea of the actual height of the frame should not be changed.  */)
-  (Lisp_Object frame, Lisp_Object lines, Lisp_Object pretend)
+DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 4, 0,
+       doc: /* Specify that the frame FRAME has HEIGHT text lines.
+Optional third arg PRETEND non-nil means that redisplay should use
+HEIGHT lines but that the idea of the actual height of the frame should
+not be changed.  Optional fourth argument PIXELWISE non-nil means that
+FRAME should be HEIGHT pixels high.  */)
+  (Lisp_Object frame, Lisp_Object height, Lisp_Object pretend, Lisp_Object pixelwise)
 {
   register struct frame *f = decode_live_frame (frame);
 
-  CHECK_TYPE_RANGED_INTEGER (int, lines);
+  CHECK_TYPE_RANGED_INTEGER (int, height);
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
     {
-      if (XINT (lines) != FRAME_LINES (f))
-        x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
-      do_pending_window_change (0);
+      if (NILP (pixelwise))
+        {
+          if (XINT (height) != FRAME_LINES (f))
+            x_set_window_size (f, 1, FRAME_COLS (f), XINT (height), 0);
+
+          do_pending_window_change (0);
+        }
+      else if (XINT (height) != FRAME_TEXT_HEIGHT (f))
+        {
+          x_set_window_size (f, 1, FRAME_TEXT_WIDTH (f), XINT (height), 1);
+          do_pending_window_change (0);
+        }
     }
   else
 #endif
-    change_frame_size (f, XINT (lines), 0, !NILP (pretend), 0, 0);
+    change_frame_size (f, 0, XINT (height), !NILP (pretend), 0, 0,
+                       NILP (pixelwise) ? 0 : 1);
   return Qnil;
 }
 
-DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
-       doc: /* Specify that the frame FRAME has COLS columns.
-If FRAME is nil, the selected frame is used.  Optional third arg
-non-nil means that redisplay should use COLS columns but that the
-idea of the actual width of the frame should not be changed.  */)
-  (Lisp_Object frame, Lisp_Object cols, Lisp_Object pretend)
+DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 4, 0,
+       doc: /* Specify that the frame FRAME has WIDTH columns.
+Optional third arg PRETEND non-nil means that redisplay should use WIDTH
+columns but that the idea of the actual width of the frame should not
+be changed.  Optional fourth argument PIXELWISE non-nil means that FRAME
+should be WIDTH pixels wide.  */)
+  (Lisp_Object frame, Lisp_Object width, Lisp_Object pretend, Lisp_Object pixelwise)
 {
   register struct frame *f = decode_live_frame (frame);
 
-  CHECK_TYPE_RANGED_INTEGER (int, cols);
+  CHECK_TYPE_RANGED_INTEGER (int, width);
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
     {
-      if (XINT (cols) != FRAME_COLS (f))
-        x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
-      do_pending_window_change (0);
+      if (NILP (pixelwise))
+        {
+          if (XINT (width) != FRAME_COLS (f))
+            x_set_window_size (f, 1, XINT (width), FRAME_LINES (f), 0);
+
+          do_pending_window_change (0);
+        }
+      else if (XINT (width) != FRAME_TEXT_WIDTH (f))
+        {
+          x_set_window_size (f, 1, XINT (width), FRAME_TEXT_HEIGHT (f), 1);
+          do_pending_window_change (0);
+        }
     }
   else
 #endif
-    change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0, 0);
+    change_frame_size (f, XINT (width), 0, !NILP (pretend), 0, 0,
+                       NILP (pixelwise) ? 0 : 1);
   return Qnil;
 }
 
-DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
-       doc: /* Sets size of FRAME to COLS by ROWS, measured in characters.
-If FRAME is nil, the selected frame is used.  */)
-  (Lisp_Object frame, Lisp_Object cols, Lisp_Object rows)
+DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 4, 0,
+       doc: /* Sets size of FRAME to WIDTH by HEIGHT, measured in characters.
+Optional argument PIXELWISE non-nil means to measure in pixels.  */)
+  (Lisp_Object frame, Lisp_Object width, Lisp_Object height, Lisp_Object pixelwise)
 {
   register struct frame *f = decode_live_frame (frame);
 
-  CHECK_TYPE_RANGED_INTEGER (int, cols);
-  CHECK_TYPE_RANGED_INTEGER (int, rows);
+  CHECK_TYPE_RANGED_INTEGER (int, width);
+  CHECK_TYPE_RANGED_INTEGER (int, height);
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
     {
-      if (XINT (rows) != FRAME_LINES (f)
-          || XINT (cols) != FRAME_COLS (f)
-          || f->new_text_lines || f->new_text_cols)
-        x_set_window_size (f, 1, XINT (cols), XINT (rows));
-      do_pending_window_change (0);
+      if (!NILP (pixelwise)
+          ? (XINT (width) != FRAME_TEXT_WIDTH (f)
+             || XINT (height) != FRAME_TEXT_HEIGHT (f)
+             || f->new_height || f->new_width)
+          : (XINT (width) != FRAME_COLS (f)
+             || XINT (height) != FRAME_LINES (f)
+             || f->new_height || f->new_width))
+        {
+          x_set_window_size (f, 1, XINT (width), XINT (height),
+                             NILP (pixelwise) ? 0 : 1);
+          do_pending_window_change (0);
+        }
     }
   else
 #endif
-    change_frame_size (f, XINT (rows), XINT (cols), 0, 0, 0);
+    change_frame_size (f, XINT (width), XINT (height), 0, 0, 0,
+                       NILP (pixelwise) ? 0 : 1);
 
   return Qnil;
 }
@@ -2586,6 +2707,8 @@ static const struct frame_parm_table frame_parms[] =
   {"icon-name",                 &Qicon_name},
   {"icon-type",                 &Qicon_type},
   {"internal-border-width",     &Qinternal_border_width},
+  {"right-divider-width",       &Qright_divider_width},
+  {"bottom-divider-width",      &Qbottom_divider_width},
   {"menu-bar-lines",            &Qmenu_bar_lines},
   {"mouse-color",               &Qmouse_color},
   {"name",                      &Qname},
@@ -2720,8 +2843,16 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
   icon_left = icon_top = Qunbound;
 
   /* Provide default values for HEIGHT and WIDTH.  */
-  width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
-  height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
+  width = (f->new_width
+           ? (f->new_pixelwise
+              ? (f->new_width / FRAME_COLUMN_WIDTH (f))
+              : f->new_width)
+           : FRAME_COLS (f));
+  height = (f->new_height
+            ? (f->new_pixelwise
+               ? (f->new_height / FRAME_LINE_HEIGHT (f))
+               : f->new_height)
+            : FRAME_LINES (f));
 
   /* Process foreground_color and background_color before anything else.
      They are independent of other properties, but other properties (e.g.,
@@ -2847,15 +2978,16 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
   {
     Lisp_Object frame;
 
-    check_frame_size (f, &height, &width);
+    /* Make this 1, eventually.  */
+    check_frame_size (f, &width, &height, 0);
 
     XSETFRAME (frame, f);
 
     if (size_changed
         && (width != FRAME_COLS (f)
             || height != FRAME_LINES (f)
-            || f->new_text_lines || f->new_text_cols))
-        Fset_frame_size (frame, make_number (width), make_number (height));
+            || f->new_height || f->new_width))
+      Fset_frame_size (frame, make_number (width), make_number (height), Qnil);
 
     if ((!NILP (left) || !NILP (top))
         && ! (left_no_change && top_no_change)
@@ -2963,6 +3095,10 @@ x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
                   make_number (f->border_width));
   store_in_alist (alistptr, Qinternal_border_width,
                   make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
+  store_in_alist (alistptr, Qright_divider_width,
+                  make_number (FRAME_RIGHT_DIVIDER_WIDTH (f)));
+  store_in_alist (alistptr, Qbottom_divider_width,
+                  make_number (FRAME_BOTTOM_DIVIDER_WIDTH (f)));
   store_in_alist (alistptr, Qleft_fringe,
                   make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
   store_in_alist (alistptr, Qright_fringe,
@@ -3295,7 +3431,53 @@ x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldva
 
   if (FRAME_X_WINDOW (f) != 0)
     {
-      x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+      x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
+      SET_FRAME_GARBAGED (f);
+      do_pending_window_change (0);
+    }
+  else
+    SET_FRAME_GARBAGED (f);
+}
+
+void
+x_set_right_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
+{
+  int old = FRAME_RIGHT_DIVIDER_WIDTH (f);
+
+  CHECK_TYPE_RANGED_INTEGER (int, arg);
+  FRAME_RIGHT_DIVIDER_WIDTH (f) = XINT (arg);
+  if (FRAME_RIGHT_DIVIDER_WIDTH (f) < 0)
+    FRAME_RIGHT_DIVIDER_WIDTH (f) = 0;
+
+  if (FRAME_RIGHT_DIVIDER_WIDTH (f) == old)
+    return;
+
+  if (FRAME_X_WINDOW (f) != 0)
+    {
+      x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
+      SET_FRAME_GARBAGED (f);
+      do_pending_window_change (0);
+    }
+  else
+    SET_FRAME_GARBAGED (f);
+}
+
+void
+x_set_bottom_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
+{
+  int old = FRAME_BOTTOM_DIVIDER_WIDTH (f);
+
+  CHECK_TYPE_RANGED_INTEGER (int, arg);
+  FRAME_BOTTOM_DIVIDER_WIDTH (f) = XINT (arg);
+  if (FRAME_BOTTOM_DIVIDER_WIDTH (f) < 0)
+    FRAME_BOTTOM_DIVIDER_WIDTH (f) = 0;
+
+  if (FRAME_BOTTOM_DIVIDER_WIDTH (f) == old)
+    return;
+
+  if (FRAME_X_WINDOW (f) != 0)
+    {
+      x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
       SET_FRAME_GARBAGED (f);
       do_pending_window_change (0);
     }
@@ -3361,7 +3543,8 @@ x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval
          However, if the window hasn't been created yet, we shouldn't
          call x_set_window_size.  */
       if (FRAME_X_WINDOW (f))
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+        x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f),
+                           FRAME_TEXT_HEIGHT (f), 1);
       do_pending_window_change (0);
     }
 }
@@ -3369,27 +3552,29 @@ x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval
 void
 x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
-  int wid = FRAME_COLUMN_WIDTH (f);
+  int unit = FRAME_COLUMN_WIDTH (f);
 
   if (NILP (arg))
     {
       x_set_scroll_bar_default_width (f);
 
       if (FRAME_X_WINDOW (f))
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+        x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f),
+                           FRAME_TEXT_HEIGHT (f), 1);
       do_pending_window_change (0);
     }
   else if (RANGED_INTEGERP (1, arg, INT_MAX)
            && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
     {
       FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
-      FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
+      FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + unit - 1) / unit;
       if (FRAME_X_WINDOW (f))
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+        x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f),
+                           FRAME_TEXT_HEIGHT (f), 1);
       do_pending_window_change (0);
     }
 
-  change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
+  change_frame_size (f, 0, 0, 0, 0, 0, 1);
   XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
   XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
 }
@@ -4002,17 +4187,20 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p)
   /* Default values if we fall through.
      Actually, if that happens we should get
      window manager prompting.  */
+  SET_FRAME_WIDTH (f, DEFAULT_COLS * FRAME_COLUMN_WIDTH (f));
   SET_FRAME_COLS (f, DEFAULT_COLS);
+  SET_FRAME_HEIGHT (f, DEFAULT_ROWS * FRAME_LINE_HEIGHT (f));
   FRAME_LINES (f) = DEFAULT_ROWS;
+
   /* Window managers expect that if program-specified
      positions are not (0,0), they're intentional, not defaults.  */
   f->top_pos = 0;
   f->left_pos = 0;
 
-  /* Ensure that old new_text_cols and new_text_lines will not override the
+  /* Ensure that old new_width and new_height will not override the
      values set here.  */
   /* ++KFS: This was specific to W32, but seems ok for all platforms */
-  f->new_text_cols = f->new_text_lines = 0;
+  f->new_width = f->new_height = f->new_pixelwise = 0;
 
   tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
   tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
@@ -4053,7 +4241,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p)
      change the frame size.  This is done so that users can create
      tall Emacs frames without having to guess how tall the tool-bar
      will get.  */
-  if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
+  if (toolbar_p && FRAME_TOOL_BAR_HEIGHT (f))
     {
       int margin, relief, bar_height;
 
@@ -4069,14 +4257,15 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p)
       else
         margin = 0;
 
+      /* PXW: We should be able to not round here.  */
       bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
       FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
     }
 
   compute_fringe_widths (f, 0);
 
-  FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
-  FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
+  SET_FRAME_WIDTH (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f));
+  SET_FRAME_HEIGHT(f, FRAME_LINES (f) * FRAME_LINE_HEIGHT (f));
 
   tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
   tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
@@ -4465,6 +4654,16 @@ when the mouse is over clickable text.  */);
 The pointer becomes visible again when the mouse is moved.  */);
   Vmake_pointer_invisible = Qt;
 
+  DEFVAR_LISP ("focus-in-hook", Vfocus_in_hook,
+               doc: /* Normal hook run when a frame gains input focus.  */);
+  Vfocus_in_hook = Qnil;
+  DEFSYM (Qfocus_in_hook, "focus-in-hook");
+
+  DEFVAR_LISP ("focus-out-hook", Vfocus_out_hook,
+               doc: /* Normal hook run when a frame loses input focus.  */);
+  Vfocus_out_hook = Qnil;
+  DEFSYM (Qfocus_out_hook, "focus-out-hook");
+
   DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
                doc: /* Functions run before deleting a frame.
 The functions are run with one arg, the frame to be deleted.
@@ -4519,6 +4718,12 @@ handles focus, since there is no way in general for Emacs to find out
 automatically.  See also `mouse-autoselect-window'.  */);
   focus_follows_mouse = 0;
 
+  DEFVAR_BOOL ("frame-resize-pixelwise", frame_resize_pixelwise,
+               doc: /* Non-nil means frames are resized pixelwise.
+If this is nil, resizing a frame will round sizes to the frame's
+current values of `frame-char-height' and `frame-char-width'.  */);
+  frame_resize_pixelwise = 0;
+
   staticpro (&Vframe_list);
 
   defsubr (&Sframep);
@@ -4526,8 +4731,6 @@ automatically.  See also `mouse-autoselect-window'.  */);
   defsubr (&Swindow_system);
   defsubr (&Smake_terminal_frame);
   defsubr (&Shandle_switch_frame);
-  defsubr (&Shandle_focus_in);
-  defsubr (&Shandle_focus_out);
   defsubr (&Sselect_frame);
   defsubr (&Sselected_frame);
   defsubr (&Sframe_list);
@@ -4560,6 +4763,16 @@ automatically.  See also `mouse-autoselect-window'.  */);
   defsubr (&Sframe_char_width);
   defsubr (&Sframe_pixel_height);
   defsubr (&Sframe_pixel_width);
+  defsubr (&Sframe_text_cols);
+  defsubr (&Sframe_text_lines);
+  defsubr (&Sframe_total_cols);
+  defsubr (&Sframe_text_width);
+  defsubr (&Sframe_text_height);
+  defsubr (&Sscroll_bar_width);
+  defsubr (&Sfringe_width);
+  defsubr (&Sborder_width);
+  defsubr (&Sright_divider_width);
+  defsubr (&Sbottom_divider_width);
   defsubr (&Stool_bar_pixel_width);
   defsubr (&Sset_frame_height);
   defsubr (&Sset_frame_width);
diff --git a/src/frame.h b/src/frame.h
index 8dfcaae114b..8369cf6b17e 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -214,45 +214,64 @@ struct frame
   /* Nonzero means that cursor type has been changed.  */
   unsigned cursor_type_changed : 1;
 
+  /* True if it needs to be redisplayed.  */
+  unsigned redisplay : 1;
+
   /* Margin at the top of the frame.  Used to display the tool-bar.  */
   int tool_bar_lines;
 
+  /* Pixel height of tool bar.  */
+  int tool_bar_height;
+
   int n_tool_bar_rows;
   int n_tool_bar_items;
 
-  /* A buffer for decode_mode_line. */
+  /* A buffer for decode_mode_line.  */
   char *decode_mode_spec_buffer;
 
-  /* See do_line_insertion_deletion_costs for info on these arrays. */
-  /* Cost of inserting 1 line on this frame */
+  /* See do_line_insertion_deletion_costs for info on these arrays.  */
+  /* Cost of inserting 1 line on this frame.  */
   int *insert_line_cost;
-  /* Cost of deleting 1 line on this frame */
+  /* Cost of deleting 1 line on this frame.  */
   int *delete_line_cost;
-  /* Cost of inserting n lines on this frame */
+  /* Cost of inserting n lines on this frame.  */
   int *insert_n_lines_cost;
-  /* Cost of deleting n lines on this frame */
+  /* Cost of deleting n lines on this frame.  */
   int *delete_n_lines_cost;
 
-  /* Size of this frame, excluding fringes, scroll bars etc.,
-     in units of canonical characters.  */
-  int text_lines, text_cols;
+  /* Text width of this frame (excluding fringes, scroll bars and
+     internal border width) and text height (excluding internal border
+     width) in units of canonical characters.  */
+  int text_cols, text_lines;
+
+  /* Total width of this frame (including fringes and scroll bars) in
+     units of canonical characters.  */
+  int total_cols;
+
+  /* Text width of this frame (excluding fringes, scroll bars and
+     internal border width) and text height (excluding internal border
+     width) in pixels.  */
+  int text_width, text_height;
 
-  /* Total size of this frame (i.e. its native window), in units of
-     canonical characters.  */
-  int total_lines, total_cols;
+  /* New text height and width for pending size change.  0 if no change
+     pending.  These values represent pixels or canonical character units
+     according to the value of new_pixelwise and correlate to the the
+     text width/height of the frame.  */
+  int new_width, new_height;
 
-  /* New text height and width for pending size change.
-     0 if no change pending.  */
-  int new_text_lines, new_text_cols;
+  /* Whether new_height and new_width shall be interpreted
+     in pixels.  */
+  bool new_pixelwise;
 
   /* Pixel position of the frame window (x and y offsets in root window).  */
   int left_pos, top_pos;
 
-  /* Size of the frame window in pixels.  */
-  int pixel_height, pixel_width;
+  /* Size of the frame window (including internal border widths) in
+     pixels.  */
+  int pixel_width, pixel_height;
 
   /* These many pixels are the difference between the outer window (i.e. the
-     left and top of the window manager decoration) and FRAME_X_WINDOW. */
+     left and top of the window manager decoration) and FRAME_X_WINDOW.  */
   int x_pixels_diff, y_pixels_diff;
 
   /* This is the gravity value for the specified window position.  */
@@ -269,6 +288,10 @@ struct frame
      a highlighting is displayed inside the internal border.  */
   int internal_border_width;
 
+  /* Width of borders between this frame's windows.  */
+  int right_divider_width;
+  int bottom_divider_width;
+
   /* Canonical X unit.  Width of default font, in pixels.  */
   int column_width;
 
@@ -281,23 +304,23 @@ struct frame
   enum output_method output_method;
 
   /* The terminal device that this frame uses.  If this is NULL, then
-     the frame has been deleted. */
+     the frame has been deleted.  */
   struct terminal *terminal;
 
   /* Device-dependent, frame-local auxiliary data used for displaying
      the contents.  When the frame is deleted, this data is deleted as
-     well. */
+     well.  */
   union output_data
   {
-    struct tty_output *tty;     /* termchar.h */
-    struct x_output *x;         /* xterm.h */
-    struct w32_output *w32;     /* w32term.h */
-    struct ns_output *ns;       /* nsterm.h */
+    struct tty_output *tty;     /* From termchar.h.  */
+    struct x_output *x;         /* From xterm.h.  */
+    struct w32_output *w32;     /* From w32term.h.  */
+    struct ns_output *ns;       /* From nsterm.h.  */
     intptr_t nothing;
   }
   output_data;
 
-  /* List of font-drivers available on the frame. */
+  /* List of font-drivers available on the frame.  */
   struct font_driver_list *font_driver_list;
   /* List of data specific to font-driver and frame, but common to
      faces.  */
@@ -313,39 +336,38 @@ struct frame
   /* The extra width (in pixels) currently allotted for fringes.  */
   int left_fringe_width, right_fringe_width;
 
-  /* See FULLSCREEN_ enum below */
+  /* See FULLSCREEN_ enum below.  */
   enum fullscreen_type want_fullscreen;
 
   /* Number of lines of menu bar.  */
   int menu_bar_lines;
 
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
-    || defined (HAVE_NS) || defined (USE_GTK)
-  /* Nonzero means using a menu bar that comes from the X toolkit.  */
-  unsigned int external_menu_bar : 1;
-#endif
+  /* Pixel height of menubar.  */
+  int menu_bar_height;
 
 #if defined (HAVE_X_WINDOWS)
   /* Used by x_wait_for_event when watching for an X event on this frame.  */
   int wait_event_type;
 #endif
 
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
+    || defined (HAVE_NS) || defined (USE_GTK)
+  /* Nonzero means using a menu bar that comes from the X toolkit.  */
+  unsigned external_menu_bar : 1;
+#endif
+
   /* Next two bitfields are mutually exclusive.  They might both be
      zero if the frame has been made invisible without an icon.  */
 
   /* Nonzero if the frame is currently displayed; we check
      it to see if we should bother updating the frame's contents.
 
-     Note that, since invisible frames aren't updated, whenever a
-     frame becomes visible again, it must be marked as garbaged.
-
      On ttys and on Windows NT/9X, to avoid wasting effort updating
      visible frames that are actually completely obscured by other
      windows on the display, we bend the meaning of visible slightly:
      if equal to 2, then the frame is obscured - we still consider
      it to be "visible" as seen from lisp, but we don't bother
-     updating it.  We must take care to garbage the frame when it
-     ceases to be obscured though.  See SET_FRAME_VISIBLE below.  */
+     updating it.  */
   unsigned visible : 2;
 
   /* Nonzero if the frame is currently iconified.  Do not
@@ -379,10 +401,10 @@ struct frame
 
   /* Nonzero if the mouse has moved on this display device
      since the last time we checked.  */
-  unsigned mouse_moved :1;
+  unsigned mouse_moved : 1;
 
-  /* Nonzero means that the pointer is invisible. */
-  unsigned pointer_invisible :1;
+  /* Nonzero means that the pointer is invisible.  */
+  unsigned pointer_invisible : 1;
 
   /* Nonzero means that all windows except mini-window and
      selected window on this frame have frozen window starts.  */
@@ -659,20 +681,28 @@ default_pixels_per_inch_y (void)
   (WINDOWP (f->minibuffer_window)                               \
    && XFRAME (XWINDOW (f->minibuffer_window)->frame) == f)
 
+/* Pixel width of frame F.  */
+#define FRAME_PIXEL_WIDTH(f) ((f)->pixel_width)
+
 /* Pixel height of frame F, including non-toolkit menu bar and
    non-toolkit tool bar lines.  */
 #define FRAME_PIXEL_HEIGHT(f) ((f)->pixel_height)
 
-/* Pixel width of frame F.  */
-#define FRAME_PIXEL_WIDTH(f) ((f)->pixel_width)
+/* Width of frame F, measured in canonical character columns,
+   not including scroll bars if any.  */
+#define FRAME_COLS(f) (f)->text_cols
 
 /* Height of frame F, measured in canonical lines, including
    non-toolkit menu bar and non-toolkit tool bar lines.  */
 #define FRAME_LINES(f) (f)->text_lines
 
-/* Width of frame F, measured in canonical character columns,
-   not including scroll bars if any.  */
-#define FRAME_COLS(f) (f)->text_cols
+/* Width of frame F, measured in pixels not including the width for
+   fringes, scroll bar, and internal borders.  */
+#define FRAME_TEXT_WIDTH(f) (f)->text_width
+
+/* Height of frame F, measured in pixels not including the height
+   for internal borders.  */
+#define FRAME_TEXT_HEIGHT(f) (f)->text_height
 
 /* Number of lines of frame F used for menu bar.
    This is relevant on terminal frames and on
@@ -680,6 +710,9 @@ default_pixels_per_inch_y (void)
    These lines are counted in FRAME_LINES.  */
 #define FRAME_MENU_BAR_LINES(f) (f)->menu_bar_lines
 
+/* Pixel height of frame F's menu bar.  */
+#define FRAME_MENU_BAR_HEIGHT(f) (f)->menu_bar_height
+
 /* Nonzero if this frame should display a tool bar
    in a way that does not use any text lines.  */
 #if defined (USE_GTK) || defined (HAVE_NS)
@@ -689,19 +722,18 @@ default_pixels_per_inch_y (void)
 #endif
 
 /* Number of lines of frame F used for the tool-bar.  */
-
 #define FRAME_TOOL_BAR_LINES(f) (f)->tool_bar_lines
 
+/* Pixel height of frame F's tool-bar.  */
+#define FRAME_TOOL_BAR_HEIGHT(f) (f)->tool_bar_height
 
 /* Lines above the top-most window in frame F.  */
-
 #define FRAME_TOP_MARGIN(F) \
   (FRAME_MENU_BAR_LINES (F) + FRAME_TOOL_BAR_LINES (F))
 
-/* Pixel height of the top margin above.  */
-
-#define FRAME_TOP_MARGIN_HEIGHT(f) \
-  (FRAME_TOP_MARGIN (f) * FRAME_LINE_HEIGHT (f))
+/* Pixel height of frame F's top margin.  */
+#define FRAME_TOP_MARGIN_HEIGHT(F)                              \
+  (FRAME_MENU_BAR_HEIGHT (F) + FRAME_TOOL_BAR_HEIGHT (F))
 
 /* Nonzero if this frame should display a menu bar
    in a way that does not use any text lines.  */
@@ -720,7 +752,8 @@ default_pixels_per_inch_y (void)
 #define FRAME_ICONIFIED_P(f) (f)->iconified
 
 /* Mark frame F as currently garbaged.  */
-#define SET_FRAME_GARBAGED(f) (frame_garbaged = 1, f->garbaged = 1)
+#define SET_FRAME_GARBAGED(f)                           \
+  (frame_garbaged = true, fset_redisplay (f), f->garbaged = true)
 
 /* Nonzero if frame F is currently garbaged.  */
 #define FRAME_GARBAGED_P(f) (f)->garbaged
@@ -788,7 +821,7 @@ default_pixels_per_inch_y (void)
 
 #define FRAME_LEFT_SCROLL_BAR_AREA_WIDTH(f)                             \
   (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f)                           \
-   ? (FRAME_CONFIG_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f))        \
+   ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f)                                  \
    : 0)
 
 /* Width of a scroll bar in frame F, measured in columns (characters),
@@ -804,7 +837,7 @@ default_pixels_per_inch_y (void)
 
 #define FRAME_RIGHT_SCROLL_BAR_AREA_WIDTH(f)                            \
   (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f)                          \
-   ? (FRAME_CONFIG_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f))        \
+   ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f)                                  \
    : 0)
 
 /* Actual width of a scroll bar in frame F, measured in columns.  */
@@ -818,29 +851,36 @@ default_pixels_per_inch_y (void)
 
 #define FRAME_SCROLL_BAR_AREA_WIDTH(f)                                  \
   (FRAME_HAS_VERTICAL_SCROLL_BARS (f)                                   \
-   ? (FRAME_CONFIG_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f))        \
+   ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f)                                  \
    : 0)
 
 /* Total width of frame F, in columns (characters),
    including the width used by scroll bars if any.  */
-
 #define FRAME_TOTAL_COLS(f) ((f)->total_cols)
 
-/* Set the width of frame F to VAL.
-   VAL is the width of a full-frame window,
-   not including scroll bars and fringes.  */
-
-#define SET_FRAME_COLS(f, val)                                          \
-  (FRAME_COLS (f) = (val),                                              \
-   (f)->total_cols = FRAME_TOTAL_COLS_ARG (f, FRAME_COLS (f)))
-
-/* Given a value WIDTH for frame F's nominal width,
-   return the value that FRAME_TOTAL_COLS should have.  */
-
-#define FRAME_TOTAL_COLS_ARG(f, width)          \
-  ((width)                                      \
-   + FRAME_SCROLL_BAR_COLS (f)                  \
-   + FRAME_FRINGE_COLS (f))
+/* Set the character widths of frame F.  WIDTH specifies a nominal
+   character text width.  */
+#define SET_FRAME_COLS(f, width)                                        \
+  ((f)->text_cols = (width),                                            \
+   (f)->total_cols = ((width)                                           \
+                      + FRAME_SCROLL_BAR_COLS (f)                       \
+                      + FRAME_FRINGE_COLS (f)))
+
+/* Set the pixel widths of frame F.  WIDTH specifies a nominal pixel
+   text width.  */
+#define SET_FRAME_WIDTH(f, width)                                       \
+  ((f)->text_width = (width),                                           \
+   (f)->pixel_width = ((width)                                          \
+                       + FRAME_SCROLL_BAR_AREA_WIDTH (f)                \
+                       + FRAME_TOTAL_FRINGE_WIDTH (f)                   \
+                       + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)))
+
+/* Set the pixel heights of frame F.  HEIGHT specifies a nominal pixel
+   text width.  */
+#define SET_FRAME_HEIGHT(f, height)                                     \
+  ((f)->text_height = (height),                                         \
+   (f)->pixel_height = ((height)                                        \
+                       + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)))
 
 /* Maximum + 1 legitimate value for FRAME_CURSOR_X.  */
 
@@ -911,11 +951,14 @@ default_pixels_per_inch_y (void)
       }                                                         \
   } while (0)
 
-/* Set visibility of frame F, marking F as garbaged if needed.  */
+/* Set visibility of frame F.
+   We call redisplay_other_windows to make sure the frame gets redisplayed
+   if some changes were applied to it while it wasn't visible (and hence
+   wasn't redisplayed).  */
 
-#define SET_FRAME_VISIBLE(f, v)                         \
-  (((f)->visible == 0 || ((f)->visible == 2))           \
-   && ((v) == 1) ? SET_FRAME_GARBAGED (f) : 0,          \
+#define SET_FRAME_VISIBLE(f, v)                                 \
+  (((f)->visible == 0 || ((f)->visible == 2)) && ((v) == 1)     \
+   ? redisplay_other_windows () : 0,                            \
    (f)->visible = (eassert (0 <= (v) && (v) <= 2), (v)))
 
 /* Set iconify of frame F.  */
@@ -1001,11 +1044,13 @@ extern Lisp_Object Vframe_list;
 #define FRAME_TOTAL_FRINGE_WIDTH(F) \
   (FRAME_LEFT_FRINGE_WIDTH (F) + FRAME_RIGHT_FRINGE_WIDTH (F))
 
-
 /* Pixel-width of internal border lines */
-
 #define FRAME_INTERNAL_BORDER_WIDTH(F) ((F)->internal_border_width)
 
+/* Pixel-size of window border lines */
+#define FRAME_RIGHT_DIVIDER_WIDTH(F) ((F)->right_divider_width)
+#define FRAME_BOTTOM_DIVIDER_WIDTH(F) ((F)->bottom_divider_width)
+
 #else /* not HAVE_WINDOW_SYSTEM */
 
 #define FRAME_FRINGE_COLS(F)    0
@@ -1013,11 +1058,10 @@ extern Lisp_Object Vframe_list;
 #define FRAME_LEFT_FRINGE_WIDTH(F)  0
 #define FRAME_RIGHT_FRINGE_WIDTH(F) 0
 #define FRAME_INTERNAL_BORDER_WIDTH(F) 0
+#define FRAME_RIGHT_DIVIDER_WIDTH(F) 0
+#define FRAME_BOTTOM_DIVIDER_WIDTH(F) 0
 
 #endif /* not HAVE_WINDOW_SYSTEM */
-
-
-
 
 /***********************************************************************
             Conversion between canonical units and pixels
@@ -1074,58 +1118,81 @@ extern Lisp_Object Vframe_list;
    Return the upper/left pixel position of the character cell on frame F
    at ROW/COL.  */
 
-#define FRAME_LINE_TO_PIXEL_Y(f, row) \
+#define FRAME_LINE_TO_PIXEL_Y(f, row)                                   \
   (((row) < FRAME_TOP_MARGIN (f) ? 0 : FRAME_INTERNAL_BORDER_WIDTH (f)) \
    + (row) * FRAME_LINE_HEIGHT (f))
 
-#define FRAME_COL_TO_PIXEL_X(f, col) \
-  (FRAME_INTERNAL_BORDER_WIDTH (f) \
+#define FRAME_COL_TO_PIXEL_X(f, col)            \
+  (FRAME_INTERNAL_BORDER_WIDTH (f)              \
    + (col) * FRAME_COLUMN_WIDTH (f))
 
 /* Return the pixel width/height of frame F if it has
    COLS columns/LINES rows.  */
 
 #define FRAME_TEXT_COLS_TO_PIXEL_WIDTH(f, cols) \
-  (FRAME_COL_TO_PIXEL_X (f, cols) \
-   + (f)->scroll_bar_actual_width \
-   + FRAME_TOTAL_FRINGE_WIDTH (f)      \
+  (FRAME_COL_TO_PIXEL_X (f, cols)               \
+   + FRAME_SCROLL_BAR_AREA_WIDTH (f)            \
+   + FRAME_TOTAL_FRINGE_WIDTH (f)               \
    + FRAME_INTERNAL_BORDER_WIDTH (f))
 
 #define FRAME_TEXT_LINES_TO_PIXEL_HEIGHT(f, lines) \
-  ((lines) * FRAME_LINE_HEIGHT (f) \
+  ((lines) * FRAME_LINE_HEIGHT (f)                 \
    + 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
 
-
 /* Return the row/column (zero-based) of the character cell containing
    the pixel on FRAME at Y/X.  */
 
-#define FRAME_PIXEL_Y_TO_LINE(f, y) \
-  (((y) < FRAME_TOP_MARGIN_HEIGHT (f)   \
-    ? (y)       \
+#define FRAME_PIXEL_Y_TO_LINE(f, y)                                     \
+  (((y) < FRAME_TOP_MARGIN_HEIGHT (f)                                   \
+    ? (y)                                                               \
     : ((y) < FRAME_TOP_MARGIN_HEIGHT (f) + FRAME_INTERNAL_BORDER_WIDTH (f) \
        ? (y) - (FRAME_TOP_MARGIN_HEIGHT (f) + FRAME_INTERNAL_BORDER_WIDTH (f) \
-                /* Arrange for the division to round down.  */  \
-                + FRAME_LINE_HEIGHT (f) - 1)    \
-       : (y) - FRAME_INTERNAL_BORDER_WIDTH (f)))        \
+                /* Arrange for the division to round down.  */          \
+                + FRAME_LINE_HEIGHT (f) - 1)                            \
+       : (y) - FRAME_INTERNAL_BORDER_WIDTH (f)))                        \
    / FRAME_LINE_HEIGHT (f))
 
-#define FRAME_PIXEL_X_TO_COL(f, x) \
+#define FRAME_PIXEL_X_TO_COL(f, x)              \
   (((x) - FRAME_INTERNAL_BORDER_WIDTH (f))      \
    / FRAME_COLUMN_WIDTH (f))
 
 /* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on
    frame F?  */
 
-#define FRAME_PIXEL_WIDTH_TO_TEXT_COLS(f, width)                \
-  (FRAME_PIXEL_X_TO_COL (f, ((width)                            \
-                             - FRAME_INTERNAL_BORDER_WIDTH (f)  \
-                             - FRAME_TOTAL_FRINGE_WIDTH (f)     \
-                             - (f)->scroll_bar_actual_width)))
+#define FRAME_PIXEL_WIDTH_TO_TEXT_COLS(f, width)                        \
+  (FRAME_PIXEL_X_TO_COL (f, ((width)                                    \
+                             - FRAME_INTERNAL_BORDER_WIDTH (f)          \
+                             - FRAME_TOTAL_FRINGE_WIDTH (f)             \
+                             - FRAME_SCROLL_BAR_AREA_WIDTH (f))))       \
 
-#define FRAME_PIXEL_HEIGHT_TO_TEXT_LINES(f, height) \
-  (FRAME_PIXEL_Y_TO_LINE (f, ((height) \
+#define FRAME_PIXEL_HEIGHT_TO_TEXT_LINES(f, height)                     \
+  (FRAME_PIXEL_Y_TO_LINE (f, ((height)                                  \
                               - FRAME_INTERNAL_BORDER_WIDTH (f))))
 
+/* Return the pixel width/height of frame F with a text size of
+   width/height.  */
+
+#define FRAME_TEXT_TO_PIXEL_WIDTH(f, width)       \
+  ((width)                                        \
+   + FRAME_SCROLL_BAR_AREA_WIDTH (f)              \
+   + FRAME_TOTAL_FRINGE_WIDTH (f)                 \
+   + 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
+
+#define FRAME_TEXT_TO_PIXEL_HEIGHT(f, height)        \
+  ((height) + 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
+
+/* Return the text width/height of frame F with a pixel size of
+   width/height.  */
+
+#define FRAME_PIXEL_TO_TEXT_WIDTH(f, width)       \
+  ((width)                                        \
+   - FRAME_SCROLL_BAR_AREA_WIDTH (f)              \
+   - FRAME_TOTAL_FRINGE_WIDTH (f)                 \
+   - 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
+
+#define FRAME_PIXEL_TO_TEXT_HEIGHT(f, height)           \
+  ((height) - 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
+
 /* Value is the smallest width of any character in any font on frame F.  */
 
 #define FRAME_SMALLEST_CHAR_WIDTH(f)            \
@@ -1148,6 +1215,7 @@ extern Lisp_Object Qfont;
 extern Lisp_Object Qbackground_color, Qforeground_color;
 extern Lisp_Object Qicon, Qicon_name, Qicon_type, Qicon_left, Qicon_top;
 extern Lisp_Object Qinternal_border_width;
+extern Lisp_Object Qright_divider_width, Qbottom_divider_width;
 extern Lisp_Object Qtooltip;
 extern Lisp_Object Qmenu_bar_lines, Qtool_bar_lines, Qtool_bar_position;
 extern Lisp_Object Qmouse_color;
@@ -1211,6 +1279,10 @@ extern void x_set_fringe_width (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_set_border_width (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_set_internal_border_width (struct frame *, Lisp_Object,
                                          Lisp_Object);
+extern void x_set_right_divider_width (struct frame *, Lisp_Object,
+                                       Lisp_Object);
+extern void x_set_bottom_divider_width (struct frame *, Lisp_Object,
+                                        Lisp_Object);
 extern void x_set_visibility (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_set_autoraise (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_set_autolower (struct frame *, Lisp_Object, Lisp_Object);
@@ -1234,7 +1306,7 @@ extern Lisp_Object display_x_get_resource (Display_Info *,
 
 extern void set_frame_menubar (struct frame *f, bool first_time, bool deep_p);
 extern void x_set_window_size (struct frame *f, int change_grav,
-                              int cols, int rows);
+                               int width, int height, bool pixelwise);
 extern Lisp_Object x_get_focus_frame (struct frame *);
 extern void x_set_mouse_position (struct frame *f, int h, int v);
 extern void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
@@ -1243,9 +1315,7 @@ extern void x_make_frame_invisible (struct frame *f);
 extern void x_iconify_frame (struct frame *f);
 extern void x_set_frame_alpha (struct frame *f);
 extern void x_set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
-extern void x_set_tool_bar_lines (struct frame *f,
-                                  Lisp_Object value,
-                                  Lisp_Object oldval);
+extern void x_set_tool_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_activate_menubar (struct frame *);
 extern void x_real_positions (struct frame *, int *, int *);
 extern void free_frame_menubar (struct frame *);
diff --git a/src/fringe.c b/src/fringe.c
index 9c77e6557f4..db4f92d6ce4 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -659,6 +659,10 @@ draw_fringe_bitmap_1 (struct window *w, struct glyph_row *row, int left_p, int o
         {
           /* If W has a vertical border to its left, don't draw over it.  */
           wd -= ((!WINDOW_LEFTMOST_P (w)
+                  /* This could be wrong when we allow window local
+                     right dividers - but the window on the left is hard
+                     to get.  */
+                  && !FRAME_RIGHT_DIVIDER_WIDTH (f)
                   && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
                   /* But don't reduce the fringe width if the window
                      has a left margin, because that means we are not
diff --git a/src/ftfont.c b/src/ftfont.c
index 224b8e82500..6a2303ab4a7 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1478,7 +1478,6 @@ ftfont_get_bitmap (struct font *font, unsigned int code, struct font_bitmap *bit
   bitmap->left = ft_face->glyph->bitmap_left;
   bitmap->top = ft_face->glyph->bitmap_top;
   bitmap->advance = ft_face->glyph->metrics.horiAdvance >> 6;
-  bitmap->extra = NULL;
 
   return 0;
 }
diff --git a/src/gnutls.c b/src/gnutls.c
index 19617cea4b2..9ea3f59100d 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -56,8 +56,10 @@ static Lisp_Object QCgnutls_bootprop_verify_hostname_error;
 static Lisp_Object QCgnutls_bootprop_callbacks_verify;
 
 static void gnutls_log_function (int, const char *);
-static void gnutls_audit_log_function (gnutls_session_t, const char *);
 static void gnutls_log_function2 (int, const char*, const char*);
+#ifdef HAVE_GNUTLS3
+static void gnutls_audit_log_function (gnutls_session_t, const char *);
+#endif
 
 
 #ifdef WINDOWSNT
@@ -262,6 +264,7 @@ init_gnutls_functions (void)
 #endif /* !WINDOWSNT */
 
 
+#ifdef HAVE_GNUTLS3
 /* Function to log a simple audit message.  */
 static void
 gnutls_audit_log_function (gnutls_session_t session, const char* string)
@@ -271,6 +274,7 @@ gnutls_audit_log_function (gnutls_session_t session, const char* string)
       message ("gnutls.c: [audit] %s", string);
     }
 }
+#endif
 
 /* Function to log a simple message.  */
 static void
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 192b64a7e62..ef422989c61 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -904,7 +904,7 @@ xg_clear_under_internal_border (struct frame *f)
 void
 xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
 {
-  int rows, columns;
+  int width, height;
 
   if (pixelwidth == -1 && pixelheight == -1)
     {
@@ -916,11 +916,11 @@ xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
     }
 
 
-  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixelheight);
-  columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixelwidth);
+  width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth);
+  height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight);
 
-  if (columns != FRAME_COLS (f)
-      || rows != FRAME_LINES (f)
+  if (width != FRAME_TEXT_WIDTH (f)
+      || height != FRAME_TEXT_HEIGHT (f)
       || pixelwidth != FRAME_PIXEL_WIDTH (f)
       || pixelheight != FRAME_PIXEL_HEIGHT (f))
     {
@@ -928,7 +928,7 @@ xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
       FRAME_PIXEL_HEIGHT (f) = pixelheight;
 
       xg_clear_under_internal_border (f);
-      change_frame_size (f, rows, columns, 0, 1, 0);
+      change_frame_size (f, width, height, 0, 1, 0, 1);
       SET_FRAME_GARBAGED (f);
       cancel_mouse_face (f);
     }
@@ -938,38 +938,23 @@ xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
    COLUMNS/ROWS is the size the edit area shall have after the resize.  */
 
 void
-xg_frame_set_char_size (struct frame *f, int cols, int rows)
+xg_frame_set_char_size (struct frame *f, int width, int height)
 {
-  int pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
-    + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
-  int pixelwidth;
+  int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
+  int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
 
   if (FRAME_PIXEL_HEIGHT (f) == 0)
     return;
 
-  /* Take into account the size of the scroll bar.  Always use the
-     number of columns occupied by the scroll bar here otherwise we
-     might end up with a frame width that is not a multiple of the
-     frame's character width which is bad for vertically split
-     windows.  */
-  f->scroll_bar_actual_width
-    = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
-
-  compute_fringe_widths (f, 0);
-
-  /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
-     after calculating that value.  */
-  pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols)
-    + FRAME_TOOLBAR_WIDTH (f);
-
-
   /* Do this before resize, as we don't know yet if we will be resized.  */
   xg_clear_under_internal_border (f);
 
   /* Must resize our top level widget.  Font size may have changed,
      but not rows/cols.  */
   gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
-                     pixelwidth, pixelheight);
+                     pixelwidth + FRAME_TOOLBAR_WIDTH (f),
+                     pixelheight + FRAME_TOOLBAR_HEIGHT (f)
+                     + FRAME_MENUBAR_HEIGHT (f));
   x_wm_set_size_hint (f, 0, 0);
 
   SET_FRAME_GARBAGED (f);
@@ -990,11 +975,7 @@ xg_frame_set_char_size (struct frame *f, int cols, int rows)
       x_wait_for_event (f, ConfigureNotify);
     }
   else
-    {
-      change_frame_size (f, rows, cols, 0, 1, 0);
-      FRAME_PIXEL_WIDTH (f) = pixelwidth;
-      FRAME_PIXEL_HEIGHT (f) = pixelheight;
-     }
+    change_frame_size (f, width, height, 0, 1, 0, 1);
 }
 
 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
@@ -1098,7 +1079,7 @@ style_changed_cb (GObject *go,
               && FRAME_X_DISPLAY (f) == dpy)
             {
               x_set_scroll_bar_default_width (f);
-              xg_frame_set_char_size (f, FRAME_COLS (f), FRAME_LINES (f));
+              xg_frame_set_char_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f));
             }
         }
     }
@@ -1381,7 +1362,7 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
   base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
     + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
 
-  check_frame_size (f, &min_rows, &min_cols);
+  check_frame_size (f, &min_cols, &min_rows, 0);
   if (min_cols > 0) --min_cols; /* We used one col in base_width = ... 1); */
   if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
 
diff --git a/src/gtkutil.h b/src/gtkutil.h
index 1c26d2aa44b..a2c5bb3ee76 100644
--- a/src/gtkutil.h
+++ b/src/gtkutil.h
@@ -139,7 +139,7 @@ extern void xg_change_toolbar_position (struct frame *f, Lisp_Object pos);
 extern void xg_frame_resized (struct frame *f,
                               int pixelwidth,
                               int pixelheight);
-extern void xg_frame_set_char_size (struct frame *f, int cols, int rows);
+extern void xg_frame_set_char_size (struct frame *f, int width, int height);
 extern GtkWidget * xg_win_to_widget (Display *dpy, Window wdesc);
 
 extern void xg_display_open (char *display_name, Display **dpy);
diff --git a/src/image.c b/src/image.c
index 89e4f863d53..38a92277299 100644
--- a/src/image.c
+++ b/src/image.c
@@ -8105,7 +8105,7 @@ imagemagick_compute_animated_image (MagickWand *super_wand, int ino)
             {
               /* Sanity check.  This shouldn't happen, but apparently
                  also does in some pictures.  */
-              if (x + source_left > dest_width)
+              if (x + source_left > dest_width - 1)
                 break;
               /* Normally we only copy over non-transparent pixels,
                  but if the disposal method is "Background", then we
@@ -9517,7 +9517,7 @@ A cross is always drawn on black & white displays.  */);
 
   DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path,
     doc: /* List of directories to search for window system bitmap files.  */);
-  Vx_bitmap_file_path = decode_env_path (0, PATH_BITMAPS);
+  Vx_bitmap_file_path = decode_env_path (0, PATH_BITMAPS, 0);
 
   DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay,
     doc: /* Maximum time after which images are removed from the cache.
diff --git a/src/indent.c b/src/indent.c
index 891b42788ed..502611b534a 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1146,7 +1146,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
   /* Negative width means use all available text columns.  */
   if (width < 0)
     {
-      width = window_body_cols (win);
+      width = window_body_width (win, 0);
       /* We must make room for continuation marks if we don't have fringes.  */
 #ifdef HAVE_WINDOW_SYSTEM
       if (!FRAME_WINDOW_P (XFRAME (win->frame)))
@@ -1756,7 +1756,7 @@ visible section of the buffer, and pass LINE and COL as TOPOS.  */)
                          ? window_internal_height (w)
                          : XINT (XCDR (topos))),
                         (NILP (topos)
-                         ? (window_body_cols (w)
+                         ? (window_body_width (w, 0)
                             - (
 #ifdef HAVE_WINDOW_SYSTEM
                                FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
diff --git a/src/insdel.c b/src/insdel.c
index 8de4f095396..db7ac0e3ad5 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1804,11 +1804,7 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
   if (!NILP (BVAR (current_buffer, read_only)))
     Fbarf_if_buffer_read_only ();
 
-  /* If we're modifying the buffer other than shown in a selected window,
-     let redisplay consider other windows if this buffer is visible.  */
-  if (XBUFFER (XWINDOW (selected_window)->contents) != current_buffer
-      && buffer_window_count (current_buffer))
-    windows_or_buffers_changed = 20;
+  bset_redisplay (current_buffer);
 
   if (buffer_intervals (current_buffer))
     {
diff --git a/src/intervals.c b/src/intervals.c
index 5aa68a359d6..0e3b684f570 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -2232,7 +2232,7 @@ get_local_map (ptrdiff_t position, struct buffer *buffer, Lisp_Object type)
      editing a field with a `local-map' property, we want insertion at the end
      to obey the `local-map' property.  */
   if (NILP (prop))
-    prop = get_pos_property (lispy_position, type, lispy_buffer);
+    prop = Fget_pos_property (lispy_position, type, lispy_buffer);
 
   SET_BUF_BEGV_BOTH (buffer, old_begv, old_begv_byte);
   SET_BUF_ZV_BOTH (buffer, old_zv, old_zv_byte);
diff --git a/src/intervals.h b/src/intervals.h
index 51dfa09c5c4..40f32645ba0 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -296,8 +296,6 @@ Lisp_Object get_char_property_and_overlay (Lisp_Object, Lisp_Object,
                                            Lisp_Object, Lisp_Object*);
 extern int text_property_stickiness (Lisp_Object prop, Lisp_Object pos,
                                      Lisp_Object buffer);
-extern Lisp_Object get_pos_property (Lisp_Object pos, Lisp_Object prop,
-                                     Lisp_Object object);
 
 extern void syms_of_textprop (void);
 
diff --git a/src/keyboard.c b/src/keyboard.c
index 450592a07b6..b50c06b4154 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -347,6 +347,7 @@ static Lisp_Object Qmodifier_cache;
 /* Symbols to use for parts of windows.  */
 Lisp_Object Qmode_line;
 Lisp_Object Qvertical_line;
+Lisp_Object Qright_divider, Qbottom_divider;
 static Lisp_Object Qvertical_scroll_bar;
 Lisp_Object Qmenu_bar;
 
@@ -1771,8 +1772,8 @@ adjust_point_for_property (ptrdiff_t last_pt, bool modified)
                     than skip both boundaries.  However, this code
                     also stops anywhere in a non-sticky text-property,
                     which breaks (e.g.) Org mode.  */
-                 && (val = get_pos_property (make_number (end),
-                                             Qinvisible, Qnil),
+                 && (val = Fget_pos_property (make_number (end),
+                                              Qinvisible, Qnil),
                      TEXT_PROP_MEANS_INVISIBLE (val))
 #endif
                  && !NILP (val = get_char_property_and_overlay
@@ -1789,8 +1790,8 @@ adjust_point_for_property (ptrdiff_t last_pt, bool modified)
             }
           while (beg > BEGV
 #if 0
-                 && (val = get_pos_property (make_number (beg),
-                                             Qinvisible, Qnil),
+                 && (val = Fget_pos_property (make_number (beg),
+                                              Qinvisible, Qnil),
                      TEXT_PROP_MEANS_INVISIBLE (val))
 #endif
                  && !NILP (val = get_char_property_and_overlay
@@ -1843,12 +1844,12 @@ adjust_point_for_property (ptrdiff_t last_pt, bool modified)
                    to the other end would mean moving backwards and thus
                    could lead to an infinite loop.  */
                 ;
-              else if (val = get_pos_property (make_number (PT),
-                                               Qinvisible, Qnil),
+              else if (val = Fget_pos_property (make_number (PT),
+                                                Qinvisible, Qnil),
                        TEXT_PROP_MEANS_INVISIBLE (val)
-                       && (val = get_pos_property
-                           (make_number (PT == beg ? end : beg),
-                            Qinvisible, Qnil),
+                       && (val = (Fget_pos_property
+                                  (make_number (PT == beg ? end : beg),
+                                   Qinvisible, Qnil)),
                            !TEXT_PROP_MEANS_INVISIBLE (val)))
                 (check_composition = check_display = 1,
                  SET_PT (PT == beg ? end : beg));
@@ -3222,8 +3223,6 @@ read_char (int commandflag, Lisp_Object map,
   RETURN_UNGCPRO (c);
 }
 
-#ifdef HAVE_MENUS
-
 /* Record a key that came from a mouse menu.
    Record it for echoing, for this-command-keys, and so on.  */
 
@@ -3254,13 +3253,11 @@ record_menu_key (Lisp_Object c)
   /* Record this character as part of the current key.  */
   add_command_key (c);
 
-  /* Re-reading in the middle of a command */
+  /* Re-reading in the middle of a command.  */
   last_input_event = c;
   num_input_events++;
 }
 
-#endif /* HAVE_MENUS */
-
 /* Return true if should recognize C as "the help character".  */
 
 static bool
@@ -5306,6 +5303,20 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
           dy = yret = wy;
         }
       /* Nothing special for part == ON_SCROLL_BAR.  */
+      else if (part == ON_RIGHT_DIVIDER)
+        {
+          posn = Qright_divider;
+          width = WINDOW_RIGHT_DIVIDER_WIDTH (w);
+          dx = xret = wx;
+          dy = yret = wy;
+        }
+      else if (part == ON_BOTTOM_DIVIDER)
+        {
+          posn = Qbottom_divider;
+          width = WINDOW_BOTTOM_DIVIDER_WIDTH (w);
+          dx = xret = wx;
+          dy = yret = wy;
+        }
 
       /* For clicks in the text area, fringes, or margins, call
          buffer_posn_from_coords to extract TEXTPOS, the buffer
@@ -8359,7 +8370,6 @@ read_char_x_menu_prompt (Lisp_Object map,
   if (! menu_prompting)
     return Qnil;
 
-#ifdef HAVE_MENUS
   /* If we got to this point via a mouse click,
      use a real menu for mouse selection.  */
   if (EVENT_HAS_PARAMETERS (prev_event)
@@ -8405,7 +8415,6 @@ read_char_x_menu_prompt (Lisp_Object map,
         *used_mouse_menu = 1;
       return value;
     }
-#endif /* HAVE_MENUS */
   return Qnil ;
 }
 
@@ -10148,7 +10157,7 @@ On such systems, Emacs starts a subshell instead of suspending.  */)
      with a window system; but suspend should be disabled in that case.  */
   get_tty_size (fileno (CURTTY ()->input), &width, &height);
   if (width != old_width || height != old_height)
-    change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
+    change_frame_size (SELECTED_FRAME (), width, height, 0, 0, 0, 0);
 
   /* Run suspend-resume-hook.  */
   hook = intern ("suspend-resume-hook");
@@ -10984,6 +10993,8 @@ syms_of_keyboard (void)
   DEFSYM (Qvertical_line, "vertical-line");
   DEFSYM (Qvertical_scroll_bar, "vertical-scroll-bar");
   DEFSYM (Qmenu_bar, "menu-bar");
+  DEFSYM (Qright_divider, "right-divider");
+  DEFSYM (Qbottom_divider, "bottom-divider");
 
   DEFSYM (Qmouse_fixup_help_message, "mouse-fixup-help-message");
 
diff --git a/src/keyboard.h b/src/keyboard.h
index b8aad959dd9..a1aa59fe988 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -457,6 +457,7 @@ extern Lisp_Object Qhelp_echo;
 
 /* Symbols to use for non-text mouse positions.  */
 extern Lisp_Object Qmode_line, Qvertical_line, Qheader_line;
+extern Lisp_Object Qright_divider, Qbottom_divider;
 
 /* True while doing kbd input.  */
 extern bool waiting_for_input;
diff --git a/src/lisp.h b/src/lisp.h
index a5aec41be38..d8cf6b6960e 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1,7 +1,6 @@
 /* Fundamental definitions for GNU Emacs Lisp interpreter.
 
-Copyright (C) 1985-1987, 1993-1995, 1997-2013 Free Software Foundation,
-Inc.
+Copyright (C) 1985-1987, 1993-1995, 1997-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1213,6 +1212,7 @@ struct Lisp_Bool_Vector
     /* This is the size in bits.  */
     EMACS_INT size;
     /* The actual bits, packed into bytes.
+       Zeros fill out the last word if needed.
        The bits are in little-endian order in the bytes, and
        the bytes are in little-endian order in the words.  */
     bits_word data[FLEXIBLE_ARRAY_MEMBER];
@@ -3523,7 +3523,7 @@ extern void pop_message_unwind (void);
 extern Lisp_Object restore_message_unwind (Lisp_Object);
 extern void restore_message (void);
 extern Lisp_Object current_message (void);
-extern void clear_message (int, int);
+extern void clear_message (bool, bool);
 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
 extern void message1 (const char *);
 extern void message1_nolog (const char *);
@@ -4042,6 +4042,7 @@ extern void syms_of_indent (void);
 /* Defined in frame.c.  */
 extern Lisp_Object Qonly, Qnone;
 extern Lisp_Object Qvisible;
+extern void set_frame_param (struct frame *, Lisp_Object, Lisp_Object);
 extern void store_frame_param (struct frame *, Lisp_Object, Lisp_Object);
 extern void store_in_alist (Lisp_Object *, Lisp_Object, Lisp_Object);
 extern Lisp_Object do_switch_frame (Lisp_Object, int, int, Lisp_Object);
@@ -4057,7 +4058,7 @@ extern int initial_argc;
 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS)
 extern bool display_arg;
 #endif
-extern Lisp_Object decode_env_path (const char *, const char *);
+extern Lisp_Object decode_env_path (const char *, const char *, bool);
 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
 extern Lisp_Object Qfile_name_handler_alist;
 extern _Noreturn void terminate_due_to_signal (int, int);
@@ -4442,6 +4443,20 @@ extern void *record_xmalloc (size_t);
       memory_full (SIZE_MAX);                                  \
   } while (0)
 
+/* Loop over all tails of a list, checking for cycles.
+   FIXME: Make tortoise and n internal declarations.
+   FIXME: Unroll the loop body so we don't need `n'.  */
+#define FOR_EACH_TAIL(hare, list, tortoise, n)  \
+  for (tortoise = hare = (list), n = true;                      \
+       CONSP (hare);                                            \
+       (hare = XCDR (hare), n = !n,                             \
+        (n                                                      \
+         ? ((EQ (hare, tortoise)                                \
+             && (xsignal1 (Qcircular_list, (list)), 0)))        \
+         /* Move tortoise before the next iteration, in case */ \
+         /* the next iteration does an Fsetcdr.  */             \
+         : (tortoise = XCDR (tortoise), 0))))
+
 /* Do a `for' loop over alist values.  */
 
 #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var)             \
diff --git a/src/lisp.mk b/src/lisp.mk
index c12deebd893..d61f7f71c2f 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -164,6 +164,8 @@ lisp = \
         $(lispsource)/emacs-lisp/float-sup.elc \
         $(lispsource)/vc/vc-hooks.elc \
         $(lispsource)/vc/ediff-hook.elc \
+        $(lispsource)/electric.elc \
+        $(lispsource)/uniquify.elc \
         $(lispsource)/tooltip.elc
 
 
diff --git a/src/lread.c b/src/lread.c
index 6c1b17f62b7..a64f083a5ac 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1,7 +1,6 @@
 /* Lisp parsing and input streams.
 
-Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation,
-Inc.
+Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -3538,7 +3537,7 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
   return vector;
 }
 
-/* FLAG means check for ] to terminate rather than ) and .  */
+/* FLAG means check for ']' to terminate rather than ')' and '.'.  */
 
 static Lisp_Object
 read_list (bool flag, Lisp_Object readcharfun)
@@ -4106,17 +4105,17 @@ defvar_kboard (struct Lisp_Kboard_Objfwd *ko_fwd,
   SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)ko_fwd);
 }
 
-/* Check that the elements of Vload_path exist.  */
+/* Check that the elements of lpath exist.  */
 
 static void
-load_path_check (void)
+load_path_check (Lisp_Object lpath)
 {
   Lisp_Object path_tail;
 
   /* The only elements that might not exist are those from
      PATH_LOADSEARCH, EMACSLOADPATH.  Anything else is only added if
      it exists.  */
-  for (path_tail = Vload_path; !NILP (path_tail); path_tail = XCDR (path_tail))
+  for (path_tail = lpath; !NILP (path_tail); path_tail = XCDR (path_tail))
     {
       Lisp_Object dirfile;
       dirfile = Fcar (path_tail);
@@ -4133,19 +4132,23 @@ load_path_check (void)
    so we can see if the site changed it later during dumping.  */
 static Lisp_Object dump_path;
 
-/* Compute the default Vload_path, with the following logic:
-   If CANNOT_DUMP:
-   use EMACSLOADPATH env-var if set; otherwise use PATH_LOADSEARCH,
-   prepending PATH_SITELOADSEARCH unless --no-site-lisp.
+/* Return the default load-path, to be used if EMACSLOADPATH is unset.
+   This does not include the standard site-lisp directories
+   under the installation prefix (i.e., PATH_SITELOADSEARCH),
+   but it does (unless no_site_lisp is set) include site-lisp
+   directories in the source/build directories if those exist and we
+   are running uninstalled.
+
+   Uses the following logic:
+   If CANNOT_DUMP: Use PATH_LOADSEARCH.
    The remainder is what happens when dumping works:
    If purify-flag (ie dumping) just use PATH_DUMPLOADSEARCH.
-   Otherwise use EMACSLOADPATH if set, else PATH_LOADSEARCH.
+   Otherwise use PATH_LOADSEARCH.
 
-   If !initialized, then just set both Vload_path and dump_path.
-   If initialized, then if Vload_path != dump_path, do nothing.
+   If !initialized, then just set dump_path and return PATH_DUMPLOADSEARCH.
+   If initialized, then if Vload_path != dump_path, return just Vload_path.
    (Presumably the load-path has already been changed by something.
-   This can only be from a site-load file during dumping,
-   or because EMACSLOADPATH is set.)
+   This can only be from a site-load file during dumping.)
    If Vinstallation_directory is not nil (ie, running uninstalled):
    If installation-dir/lisp exists and not already a member,
    we must be running uninstalled.  Reset the load-path
@@ -4154,20 +4157,17 @@ static Lisp_Object dump_path;
    are not yet installed, we should not use them, even if they exist.)
    If installation-dir/lisp does not exist, just add dump_path at the
    end instead.
-   Add installation-dir/leim (if exists and not already a member) at the front.
    Add installation-dir/site-lisp (if !no_site_lisp, and exists
    and not already a member) at the front.
    If installation-dir != source-dir (ie running an uninstalled,
    out-of-tree build) AND install-dir/src/Makefile exists BUT
    install-dir/src/Makefile.in does NOT exist (this is a sanity
-   check), then repeat the above steps for source-dir/lisp,
-   leim and site-lisp.
-   Finally, add the site-lisp directories at the front (if !no_site_lisp).
-*/
+   check), then repeat the above steps for source-dir/lisp, site-lisp.  */
 
-void
-init_lread (void)
+static Lisp_Object
+load_path_default (bool changed)
 {
+  Lisp_Object lpath = Qnil;
   const char *normal;
 
 #ifdef CANNOT_DUMP
@@ -4177,63 +4177,48 @@ init_lread (void)
 
   normal = PATH_LOADSEARCH;
 #ifdef HAVE_NS
-  Vload_path = decode_env_path ("EMACSLOADPATH", loadpath ? loadpath : normal);
+  lpath = decode_env_path (0, loadpath ? loadpath : normal, 0);
 #else
-  Vload_path = decode_env_path ("EMACSLOADPATH", normal);
+  lpath = decode_env_path (0, normal, 0);
 #endif
 
-  load_path_check ();
-
-  /* FIXME CANNOT_DUMP platforms should get source-dir/lisp etc added
-   to their load-path too, AFAICS.  I don't think we can tell the
-   difference between initialized and !initialized in this case,
-   so we'll have to do it unconditionally when Vinstallation_directory
-   is non-nil.  */
-  if (!no_site_lisp && !egetenv ("EMACSLOADPATH"))
-    {
-      Lisp_Object sitelisp;
-      sitelisp = decode_env_path (0, PATH_SITELOADSEARCH);
-      if (! NILP (sitelisp)) Vload_path = nconc2 (sitelisp, Vload_path);
-    }
 #else  /* !CANNOT_DUMP */
-  if (NILP (Vpurify_flag))
-    {
-      normal = PATH_LOADSEARCH;
-      /* If the EMACSLOADPATH environment variable is set, use its value.
-         This doesn't apply if we're dumping.  */
-      if (egetenv ("EMACSLOADPATH"))
-        Vload_path = decode_env_path ("EMACSLOADPATH", normal);
-    }
-  else
-    normal = PATH_DUMPLOADSEARCH;
+
+  normal = NILP (Vpurify_flag) ? PATH_LOADSEARCH : PATH_DUMPLOADSEARCH;
 
   /* In a dumped Emacs, we normally reset the value of Vload_path using
      PATH_LOADSEARCH, since the value that was dumped uses lisp/ in
      the source directory, instead of the path of the installed elisp
      libraries.  However, if it appears that Vload_path has already been
      changed from the default that was saved before dumping, don't
-     change it further.  Changes can only be due to EMACSLOADPATH, or
-     site-lisp files that were processed during dumping.  */
+     change it further.  Changes can only be due to site-lisp
+     files that were processed during dumping.  */
+  /* FIXME?  AFAICS, it does not make sense to change load-path in a
+     dumped site-lisp file, so maybe we should just drop this check.
+     E.g., if you add an element to load-path, you are going to be
+     adding it to PATH_DUMPLOADSEARCH, which refers to the source directory.
+     This will make no sense (and may not still exist) in an installed Emacs.
+     And the only change it is sensible to make to load-path is to add
+     something to the front, which you should do with configure's
+     --enable-locallisppath option if you really want to have it dumped.  */
   if (initialized)
     {
-      if (NILP (Fequal (dump_path, Vload_path)))
+      if (changed || NILP (Fequal (dump_path, Vload_path)))
         {
-          /* Do not make any changes, just check the elements exist.  */
-          /* Note: --no-site-lisp is ignored.
-             I don't know what to do about this.  */
-          load_path_check ();
+          /* Do not make any changes.  */
+          return Vload_path;
         }
       else
-        {
+        {
 #ifdef HAVE_NS
-          const char *loadpath = ns_load_path ();
-          Vload_path = decode_env_path (0, loadpath ? loadpath : normal);
+          const char *loadpath = ns_load_path ();
+          lpath = decode_env_path (0, loadpath ? loadpath : normal, 0);
 #else
-          Vload_path = decode_env_path (0, normal);
+          lpath = decode_env_path (0, normal, 0);
 #endif
-          if (!NILP (Vinstallation_directory))
-            {
-              Lisp_Object tem, tem1;
+          if (!NILP (Vinstallation_directory))
+            {
+              Lisp_Object tem, tem1;
 
               /* Add to the path the lisp subdir of the installation
                  dir, if it is accessible.  Note: in out-of-tree builds,
@@ -4243,29 +4228,19 @@ init_lread (void)
               tem1 = Ffile_accessible_directory_p (tem);
               if (!NILP (tem1))
                 {
-                  if (NILP (Fmember (tem, Vload_path)))
+                  if (NILP (Fmember (tem, lpath)))
                     {
                       /* We are running uninstalled.  The default load-path
-                         points to the eventual installed lisp, leim
-                         directories.  We should not use those now, even
-                         if they exist, so start over from a clean slate.  */
-                      Vload_path = list1 (tem);
+                         points to the eventual installed lisp directories.
+                         We should not use those now, even if they exist,
+                         so start over from a clean slate.  */
+                      lpath = list1 (tem);
                     }
                 }
               else
                 /* That dir doesn't exist, so add the build-time
                    Lisp dirs instead.  */
-                Vload_path = nconc2 (Vload_path, dump_path);
-
-              /* Add leim under the installation dir, if it is accessible. */
-              tem = Fexpand_file_name (build_string ("leim"),
-                                       Vinstallation_directory);
-              tem1 = Ffile_accessible_directory_p (tem);
-              if (!NILP (tem1))
-                {
-                  if (NILP (Fmember (tem, Vload_path)))
-                    Vload_path = Fcons (tem, Vload_path);
-                }
+                lpath = nconc2 (lpath, dump_path);
 
               /* Add site-lisp under the installation dir, if it exists.  */
               if (!no_site_lisp)
@@ -4275,14 +4250,14 @@ init_lread (void)
                   tem1 = Ffile_accessible_directory_p (tem);
                   if (!NILP (tem1))
                     {
-                      if (NILP (Fmember (tem, Vload_path)))
-                        Vload_path = Fcons (tem, Vload_path);
+                      if (NILP (Fmember (tem, lpath)))
+                        lpath = Fcons (tem, lpath);
                     }
                 }
 
               /* If Emacs was not built in the source directory,
                  and it is run from where it was built, add to load-path
-                 the lisp, leim and site-lisp dirs under that directory.  */
+                 the lisp and site-lisp dirs under that directory.  */
 
               if (NILP (Fequal (Vinstallation_directory, Vsource_directory)))
                 {
@@ -4304,14 +4279,8 @@ init_lread (void)
                       tem = Fexpand_file_name (build_string ("lisp"),
                                                Vsource_directory);
 
-                      if (NILP (Fmember (tem, Vload_path)))
-                        Vload_path = Fcons (tem, Vload_path);
-
-                      tem = Fexpand_file_name (build_string ("leim"),
-                                               Vsource_directory);
-
-                      if (NILP (Fmember (tem, Vload_path)))
-                        Vload_path = Fcons (tem, Vload_path);
+                      if (NILP (Fmember (tem, lpath)))
+                        lpath = Fcons (tem, lpath);
 
                       if (!no_site_lisp)
                         {
@@ -4320,47 +4289,113 @@ init_lread (void)
                           tem1 = Ffile_accessible_directory_p (tem);
                           if (!NILP (tem1))
                             {
-                              if (NILP (Fmember (tem, Vload_path)))
-                                Vload_path = Fcons (tem, Vload_path);
+                              if (NILP (Fmember (tem, lpath)))
+                                lpath = Fcons (tem, lpath);
                             }
                         }
                     }
                 } /* Vinstallation_directory != Vsource_directory */
 
-            } /* if Vinstallation_directory */
+            } /* if Vinstallation_directory */
 
-          /* Check before adding the site-lisp directories.
-             The install should have created them, but they are not
-             required, so no need to warn if they are absent.
-             Or we might be running before installation.  */
-          load_path_check ();
-
-          /* Add the site-lisp directories at the front.  */
-          if (!no_site_lisp)
-            {
-              Lisp_Object sitelisp;
-              sitelisp = decode_env_path (0, PATH_SITELOADSEARCH);
-              if (! NILP (sitelisp)) Vload_path = nconc2 (sitelisp, Vload_path);
-            }
-        } /* if dump_path == Vload_path */
+        } /* if dump_path == Vload_path */
     }
   else                          /* !initialized */
     {
       /* NORMAL refers to PATH_DUMPLOADSEARCH, ie the lisp dir in the
          source directory.  We used to add ../lisp (ie the lisp dir in
          the build directory) at the front here, but that caused trouble
-         because it was copied from dump_path into Vload_path, above,
-         when Vinstallation_directory was non-nil.  It should not be
+         because it was copied from dump_path into Vload_path, above,
+         when Vinstallation_directory was non-nil.  It should not be
          necessary, since in out of tree builds lisp/ is empty, save
          for Makefile.  */
-      Vload_path = decode_env_path (0, normal);
-      dump_path = Vload_path;
-      /* No point calling load_path_check; load-path only contains essential
-         elements from the source directory at this point.  They cannot
-         be missing unless something went extremely (and improbably)
-         wrong, in which case the build will fail in obvious ways.  */
+      lpath = decode_env_path (0, normal, 0);
+      dump_path = lpath;
     }
-#endif  /* !CANNOT_DUMP */
+#endif /* !CANNOT_DUMP */
+
+  return lpath;
+}
+
+void
+init_lread (void)
+{
+  /* First, set Vload_path.  */
+
+  /* NB: Do not change Vload_path before calling load_path_default,
+     since it may check it against dump_path.
+     (This behavior could be changed.)  */
+
+  /* We explicitly ignore EMACSLOADPATH when dumping.  */
+  if (NILP (Vpurify_flag) && egetenv ("EMACSLOADPATH"))
+    {
+      Lisp_Object elpath = decode_env_path ("EMACSLOADPATH", 0, 1);
+
+      /* Check (non-nil) user-supplied elements.  */
+      load_path_check (elpath);
+
+      /* If no nils in the environment variable, use as-is.
+         Otherwise, replace any nils with the default.  */
+      if (NILP (Fmemq (Qnil, elpath)))
+        {
+          Vload_path = elpath;
+        }
+      else
+        {
+          Lisp_Object elem, default_lpath = load_path_default (0);
+
+          /* Check defaults, before adding site-lisp.  */
+          load_path_check (default_lpath);
+
+          /* Add the site-lisp directories to the front of the default.  */
+          if (!no_site_lisp)
+            {
+              Lisp_Object sitelisp;
+              sitelisp = decode_env_path (0, PATH_SITELOADSEARCH, 0);
+              if (! NILP (sitelisp))
+                default_lpath = nconc2 (sitelisp, default_lpath);
+            }
+
+          Vload_path = Qnil;
+
+          /* Replace nils from EMACSLOADPATH by default.  */
+          while (CONSP (elpath))
+            {
+              Lisp_Object arg[2];
+              elem = XCAR (elpath);
+              elpath = XCDR (elpath);
+              arg[0] = Vload_path;
+              arg[1] = NILP (elem) ? default_lpath : Fcons (elem, Qnil);
+              Vload_path = Fappend (2, arg);
+            }
+        }                       /* Fmemq (Qnil, Vload_path) */
+    }
+  else                          /* Vpurify_flag || !EMACSLOADPATH */
+    {
+#ifdef CANNOT_DUMP
+      bool changed = 0;
+#else
+      bool changed = initialized && NILP (Fequal (dump_path, Vload_path));
+#endif
+
+      Vload_path = load_path_default (changed);
+
+      /* Check before adding site-lisp directories.
+         The install should have created them, but they are not
+         required, so no need to warn if they are absent.
+         Or we might be running before installation.  */
+      load_path_check (Vload_path);
+
+      /* Add the site-lisp directories at the front, unless the
+         load-path has already been changed.
+         FIXME?  Should we ignore changed here?  */
+      if (initialized && !no_site_lisp && !changed)
+        {
+          Lisp_Object sitelisp;
+          sitelisp = decode_env_path (0, PATH_SITELOADSEARCH, 0);
+          if (! NILP (sitelisp)) Vload_path = nconc2 (sitelisp, Vload_path);
+        }
+    }                           /* !Vpurify_flag && EMACSLOADPATH */
 
   Vvalues = Qnil;
 
@@ -4467,9 +4502,8 @@ were read in.  */);
 
   DEFVAR_LISP ("load-path", Vload_path,
                doc: /* List of directories to search for files to load.
-Each element is a string (directory name) or nil (try default directory).
-Initialized based on EMACSLOADPATH environment variable, if any,
-otherwise to default specified by file `epaths.h' when Emacs was built.  */);
+Each element is a string (directory name) or nil (meaning `default-directory').
+Initialized during startup as described in Info node `(elisp)Library Search'.  */);
 
   DEFVAR_LISP ("load-suffixes", Vload_suffixes,
                doc: /* List of suffixes for (compiled or source) Emacs Lisp files.
@@ -4585,7 +4619,7 @@ and is not meant for users to change.  */);
 You cannot count on them to still be there!  */);
   Vsource_directory
     = Fexpand_file_name (build_string ("../"),
-                         Fcar (decode_env_path (0, PATH_DUMPLOADSEARCH)));
+                         Fcar (decode_env_path (0, PATH_DUMPLOADSEARCH, 0)));
 
   DEFVAR_LISP ("preloaded-file-list", Vpreloaded_file_list,
                doc: /* List of files that were preloaded (when dumping Emacs).  */);
diff --git a/src/menu.c b/src/menu.c
index 96b8f73824a..e33c647d020 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -1178,7 +1178,6 @@ no quit occurs and `x-popup-menu' returns nil.  */)
        keybinding equivalents, but we don't do that any more anyway.  */
     return Qnil;
 
-#ifdef HAVE_MENUS
   {
     bool get_current_pos_p = 0;
 
@@ -1315,7 +1314,6 @@ no quit occurs and `x-popup-menu' returns nil.  */)
 
     XSETFRAME (Vmenu_updating_frame, f);
   }
-#endif /* HAVE_MENUS */
 
   /* Now parse the lisp menus.  */
   record_unwind_protect_void (unuse_menu_items);
@@ -1398,7 +1396,6 @@ no quit occurs and `x-popup-menu' returns nil.  */)
 
   unbind_to (specpdl_count, Qnil);
 
-#ifdef HAVE_MENUS
 #ifdef HAVE_WINDOW_SYSTEM
   /* Hide a previous tip, if any.  */
   if (!FRAME_TERMCAP_P (f))
@@ -1460,16 +1457,12 @@ no quit occurs and `x-popup-menu' returns nil.  */)
     FRAME_DISPLAY_INFO (f)->grabbed = 0;
 #endif
 
-#endif /* HAVE_MENUS */
-
   UNGCPRO;
 
   if (error_name) error ("%s", error_name);
   return selection;
 }
 
-#ifdef HAVE_MENUS
-
 DEFUN ("x-popup-dialog", Fx_popup_dialog, Sx_popup_dialog, 2, 3, 0,
        doc: /* Pop up a dialog box and return user's selection.
 POSITION specifies which frame to use.
@@ -1605,8 +1598,6 @@ for instance using the window manager, then this produces a quit and
   }
 }
 
-#endif  /* HAVE_MENUS */
-
 void
 syms_of_menu (void)
 {
@@ -1615,9 +1606,6 @@ syms_of_menu (void)
   menu_items_inuse = Qnil;
 
   defsubr (&Sx_popup_menu);
-
-#ifdef HAVE_MENUS
   defsubr (&Sx_popup_dialog);
-#endif
   defsubr (&Smenu_bar_menu_at_x_y);
 }
diff --git a/src/minibuf.c b/src/minibuf.c
index 8eb1a2890e0..c8ae8eae2a4 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -865,9 +865,6 @@ read_minibuf_unwind (void)
   if (minibuf_level == 0)
     resize_mini_window (XWINDOW (window), 0);
 
-  /* Enforce full redisplay.  FIXME: make it more selective.  */
-  windows_or_buffers_changed = 22;
-
   /* In case the previous minibuffer displayed in this miniwindow is
      dead, we may keep displaying this buffer (tho it's inactive), so reset it,
      to make sure we don't leave around bindings and stuff which only
diff --git a/src/nsfns.m b/src/nsfns.m
index ee6020f2b43..8f14915ea65 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -703,7 +703,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
         }
     }
 
-  x_set_window_size (f, 0, f->text_cols, f->text_lines);
+  x_set_window_size (f, 0, f->text_cols, f->text_lines, 0);
 }
 
 
@@ -946,6 +946,8 @@ frame_parm_handler ns_frame_parm_handlers[] =
   x_set_icon_name,
   x_set_icon_type,
   x_set_internal_border_width, /* generic OK */
+  0, /* x_set_right_divider_width */
+  0, /* x_set_bottom_divider_width */
   x_set_menu_bar_lines,
   x_set_mouse_color,
   x_explicitly_set_name,
@@ -1235,6 +1237,13 @@ This function is an internal primitive--use `make-frame' instead.  */)
 
   init_frame_faces (f);
 
+  /* Read comment about this code in corresponding place in xfns.c.  */
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
+
   /* The resources controlling the menu-bar and tool-bar are
      processed specially at startup, and reflected in the mode
      variables; ignore them here.  */
@@ -1266,6 +1275,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.ns->hand_cursor = [NSCursor pointingHandCursor];
   f->output_data.ns->hourglass_cursor = [NSCursor disappearingItemCursor];
   f->output_data.ns->horizontal_drag_cursor = [NSCursor resizeLeftRightCursor];
+  f->output_data.ns->vertical_drag_cursor = [NSCursor resizeUpDownCursor];
   FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor
      = [NSCursor arrowCursor];
   f->output_data.ns->current_pointer = f->output_data.ns->text_cursor;
@@ -1298,12 +1308,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
   x_default_parameter (f, parms, Qfullscreen, Qnil,
                        "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
 
-  width = FRAME_COLS (f);
-  height = FRAME_LINES (f);
-
-  SET_FRAME_COLS (f, 0);
-  FRAME_LINES (f) = 0;
-  change_frame_size (f, height, width, 1, 0, 0);
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
 
   if (! f->output_data.ns->explicit_parent)
     {
diff --git a/src/nsfont.m b/src/nsfont.m
index 58663804a2f..0f546408316 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -829,7 +829,6 @@ nsfont_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
   font->vertical_centering = 0;
   font->baseline_offset = 0;
   font->relative_compose = 0;
-  font->font_encoder = NULL;
 
   font->props[FONT_FORMAT_INDEX] = Qns;
   font->props[FONT_FILE_INDEX] = Qnil;
diff --git a/src/nsterm.h b/src/nsterm.h
index 22a8aec9436..976347ad3b4 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -654,6 +654,7 @@ struct ns_output
   Cursor hand_cursor;
   Cursor hourglass_cursor;
   Cursor horizontal_drag_cursor;
+  Cursor vertical_drag_cursor;
 
   /* NS-specific */
   Cursor current_pointer;
@@ -719,11 +720,6 @@ struct x_output
 #define FRAME_NS_TITLEBAR_HEIGHT(f) ((f)->output_data.ns->titlebar_height)
 #define FRAME_TOOLBAR_HEIGHT(f) ((f)->output_data.ns->toolbar_height)
 
-#define FONT_WIDTH(f)   ((f)->max_width)
-#define FONT_HEIGHT(f)  ((f)->height)
-#define FONT_BASE(f)    ((f)->ascent)
-#define FONT_DESCENT(f) ((f)->descent)
-
 #define FRAME_DEFAULT_FACE(f) FACE_FROM_ID (f, DEFAULT_FACE_ID)
 
 #define FRAME_NS_VIEW(f) ((f)->output_data.ns->view)
diff --git a/src/nsterm.m b/src/nsterm.m
index 0e7667b6dc6..37edfb238a9 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -1,7 +1,7 @@
 /* NeXT/Open/GNUstep / MacOSX communication module.
 
-Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2013 Free Software
-Foundation, Inc.
+Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2013
+  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -445,8 +445,8 @@ ns_exec_path (void)
 const char *
 ns_load_path (void)
 /* If running as a self-contained app bundle, return as a path string
-   the filenames of the site-lisp, lisp and leim directories.
-   Ie, site-lisp:lisp:leim.  Otherwise, return nil.  */
+   the filenames of the site-lisp and lisp directories.
+   Ie, site-lisp:lisp.  Otherwise, return nil.  */
 {
   NSBundle *bundle = [NSBundle mainBundle];
   NSString *resourceDir = [bundle resourcePath];
@@ -456,7 +456,7 @@ ns_load_path (void)
   BOOL isDir;
   NSArray *paths = [resourceDir stringsByAppendingPaths:
                               [NSArray arrayWithObjects:
-                                         @"site-lisp", @"lisp", @"leim", nil]];
+                                         @"site-lisp", @"lisp", nil]];
   NSEnumerator *pathEnum = [paths objectEnumerator];
   resourcePaths = @"";
 
@@ -771,7 +771,12 @@ ns_update_window_end (struct window *w, bool cursor_on_p,
                                 w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
-        x_draw_vertical_border (w);
+        {
+          if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+            x_draw_right_divider (w);
+          else
+            x_draw_vertical_border (w);
+        }
 
       unblock_input ();
     }
@@ -1235,7 +1240,11 @@ x_set_offset (struct frame *f, int xoff, int yoff, int change_grav)
 
 
 void
-x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
+x_set_window_size (struct frame *f,
+                   int change_grav,
+                   int width,
+                   int height,
+                   bool pixelwise)
 /* --------------------------------------------------------------------------
      Adjust window pixel size based on given character grid size
      Impl is a bit more complex than other terms, need to do some
@@ -1247,23 +1256,36 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
   NSRect wr = [window frame];
   int tb = FRAME_EXTERNAL_TOOL_BAR (f);
   int pixelwidth, pixelheight;
+  int rows, cols;
 
   NSTRACE (x_set_window_size);
 
   if (view == nil)
     return;
 
-/*fprintf (stderr, "\tsetWindowSize: %d x %d, font size %d x %d\n", cols, rows, FRAME_COLUMN_WIDTH (f), FRAME_LINE_HEIGHT (f)); */
+/*fprintf (stderr, "\tsetWindowSize: %d x %d, pixelwise %d, font size %d x %d\n", width, height, pixelwise, FRAME_COLUMN_WIDTH (f), FRAME_LINE_HEIGHT (f));*/
 
   block_input ();
 
-  check_frame_size (f, &rows, &cols);
+  check_frame_size (f, &width, &height, pixelwise);
 
   f->scroll_bar_actual_width = NS_SCROLL_BAR_WIDTH (f);
   compute_fringe_widths (f, 0);
 
-  pixelwidth =  FRAME_TEXT_COLS_TO_PIXEL_WIDTH   (f, cols);
-  pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+  if (pixelwise)
+    {
+      pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
+      pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
+      cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixelwidth);
+      rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixelheight);
+    }
+  else
+    {
+      pixelwidth =  FRAME_TEXT_COLS_TO_PIXEL_WIDTH   (f, width);
+      pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
+      cols = width;
+      rows = height;
+    }
 
   /* If we have a toolbar, take its height into account. */
   if (tb && ! [view isFullscreen])
@@ -1298,7 +1320,7 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
   [view setRows: rows andColumns: cols];
   [window setFrame: wr display: YES];
 
-/*fprintf (stderr, "\tx_set_window_size %d, %d\t%d, %d\n", cols, rows, pixelwidth, pixelheight); */
+  fprintf (stderr, "\tx_set_window_size %d, %d\t%d, %d\n", cols, rows, pixelwidth, pixelheight);
 
   /* This is a trick to compensate for Emacs' managing the scrollbar area
      as a fixed number of standard character columns.  Instead of leaving
@@ -1316,9 +1338,7 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
     [view setBoundsOrigin: origin];
   }
 
-  change_frame_size (f, rows, cols, 0, 1, 0); /* pretend, delay, safe */
-  FRAME_PIXEL_WIDTH (f) = pixelwidth;
-  FRAME_PIXEL_HEIGHT (f) = pixelheight;
+  change_frame_size (f, width, height, 0, 1, 0, pixelwise);
 /*  SET_FRAME_GARBAGED (f); // this short-circuits expose call in drawRect */
 
   mark_window_cursors_off (XWINDOW (f->root_window));
@@ -1385,7 +1405,7 @@ ns_index_color (NSColor *color, struct frame *f)
       color_table->empty_indices = [[NSMutableSet alloc] init];
     }
 
-  /* do we already have this color ? */
+  /* Do we already have this color?  */
   for (i = 1; i < color_table->avail; i++)
     if (color_table->colors[i] && [color_table->colors[i] isEqual: color])
       return i;
@@ -2504,6 +2524,28 @@ ns_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
 }
 
 
+static void
+ns_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
+/* --------------------------------------------------------------------------
+     External (RIF): Draw a window divider.
+   -------------------------------------------------------------------------- */
+{
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+  struct face *face;
+  NSRect r = NSMakeRect (x0, y0, x1-x0, y1-y0);
+
+  NSTRACE (ns_draw_window_divider);
+
+  face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
+  if (face)
+      [ns_lookup_indexed_color(face->foreground, f) set];
+
+  ns_focus (f, &r, 1);
+  NSRectFill(r);
+  ns_unfocus (f);
+}
+
+
 void
 show_hourglass (struct atimer *timer)
 {
@@ -4017,6 +4059,7 @@ static struct redisplay_interface ns_redisplay_interface =
   ns_clear_frame_area,
   ns_draw_window_cursor,
   ns_draw_vertical_window_border,
+  ns_draw_window_divider,
   ns_shift_glyphs_for_insert
 };
 
@@ -4385,7 +4428,7 @@ ns_term_shutdown (int sig)
 
     shouldKeepRunning = YES;
     do
-    {
+      {
         [pool release];
         pool = [[NSAutoreleasePool alloc] init];
 
@@ -4404,6 +4447,9 @@ ns_term_shutdown (int sig)
 - (void)stop: (id)sender
 {
     shouldKeepRunning = NO;
+    // Stop possible dialog also.  Noop if no dialog present.
+    // The file dialog still leaks 7k - 10k on 10.9 though.
+    [super stop:sender];
 }
 #endif
 
@@ -5617,44 +5663,39 @@ not_in_argv (NSString *arg)
   NSWindow *window = [self window];
   NSRect wr = [window frame];
   int extra = 0;
-  int gsextra = 0;
-#ifdef NS_IMPL_GNUSTEP
-  gsextra = 3;
-#endif
-
   int oldc = cols, oldr = rows;
   int oldw = FRAME_PIXEL_WIDTH (emacsframe),
     oldh = FRAME_PIXEL_HEIGHT (emacsframe);
   int neww, newh;
 
-  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, wr.size.width + gsextra);
-
-  if (cols < MINWIDTH)
-    cols = MINWIDTH;
-
   if (! [self isFullscreen])
     {
       extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
-        + FRAME_TOOLBAR_HEIGHT (emacsframe) - gsextra;
+        + FRAME_TOOLBAR_HEIGHT (emacsframe);
     }
 
-  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, wr.size.height - extra);
+  neww = (int)wr.size.width - emacsframe->border_width;
+  newh = (int)wr.size.height - extra;
+
+  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, neww);
+  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, newh);
+
+  if (cols < MINWIDTH)
+    cols = MINWIDTH;
 
   if (rows < MINHEIGHT)
     rows = MINHEIGHT;
 
-  neww = (int)wr.size.width - emacsframe->border_width;
-  newh = (int)wr.size.height - extra;
-
   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
     {
       NSView *view = FRAME_NS_VIEW (emacsframe);
       NSWindow *win = [view window];
       NSSize sz = [win resizeIncrements];
 
-      FRAME_PIXEL_WIDTH (emacsframe) = neww;
-      FRAME_PIXEL_HEIGHT (emacsframe) = newh;
-      change_frame_size (emacsframe, rows, cols, 0, delay, 0);
+      change_frame_size (emacsframe,
+                         FRAME_PIXEL_TO_TEXT_WIDTH (emacsframe, neww),
+                         FRAME_PIXEL_TO_TEXT_HEIGHT (emacsframe, newh),
+                         0, delay, 0, 1);
       SET_FRAME_GARBAGED (emacsframe);
       cancel_mouse_face (emacsframe);
 
@@ -5676,10 +5717,6 @@ not_in_argv (NSString *arg)
 /* normalize frame to gridded text size */
 {
   int extra = 0;
-  int gsextra = 0;
-#ifdef NS_IMPL_GNUSTEP
-  gsextra = 3;
-#endif
 
   NSTRACE (windowWillResize);
 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
@@ -5697,8 +5734,13 @@ not_in_argv (NSString *arg)
   if (fs_state == FULLSCREEN_NONE)
     maximized_width = maximized_height = -1;
 
-  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe,
-                                         frameSize.width + gsextra);
+  if (! [self isFullscreen])
+    {
+      extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
+        + FRAME_TOOLBAR_HEIGHT (emacsframe);
+    }
+
+  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, frameSize.width);
   if (cols < MINWIDTH)
     cols = MINWIDTH;
 
@@ -7294,6 +7336,7 @@ Lisp_Object
 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
 {
   struct font *font = XFONT_OBJECT (font_object);
+  EmacsView *view = FRAME_NS_VIEW (f);
 
   if (fontset < 0)
     fontset = fontset_from_font (font_object);
@@ -7326,8 +7369,9 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
     }
 
   /* Now make the frame display the given font.  */
-  if (FRAME_NS_WINDOW (f) != 0)
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+  if (FRAME_NS_WINDOW (f) != 0 && ! [view isFullscreen])
+    x_set_window_size (f, 0, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
+                       FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 1);
 
   return font_object;
 }
@@ -7554,5 +7598,5 @@ baseline level.  The default value is nil.  */);
 #else
   Fprovide (Qgnustep, Qnil);
 #endif
-  
+
 }
diff --git a/src/print.c b/src/print.c
index e3c56a6de62..6e8aec37ba5 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1119,7 +1119,7 @@ print (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
    string (its text properties will be traced), or a symbol that has
    no obarray (this is for the print-gensym feature).
    The status fields of Vprint_number_table mean whether each object appears
-   more than once in OBJ: Qnil at the first time, and Qt after that .  */
+   more than once in OBJ: Qnil at the first time, and Qt after that.  */
 static void
 print_preprocess (Lisp_Object obj)
 {
@@ -1766,8 +1766,9 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
         }
       else if (WINDOWP (obj))
         {
-          void *ptr = XWINDOW (obj);
-          int len = sprintf (buf, "#<window %p", ptr);
+          int len;
+          strout ("#<window ", -1, -1, printcharfun);
+          len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number);
           strout (buf, len, len, printcharfun);
           if (BUFFERP (XWINDOW (obj)->contents))
             {
diff --git a/src/process.c b/src/process.c
index 307eab3ab30..7050bf9822e 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1,7 +1,7 @@
 /* Asynchronous subprocess control for GNU Emacs.
 
-Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2013 Free Software
-Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2013
+  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -812,13 +812,14 @@ get_process (register Lisp_Object name)
   else
     obj = name;
 
-  /* Now obj should be either a buffer object or a process object.
-   */
+  /* Now obj should be either a buffer object or a process object.  */
   if (BUFFERP (obj))
     {
+      if (NILP (BVAR (XBUFFER (obj), name)))
+        error ("Attempt to get process for a dead buffer");
       proc = Fget_buffer_process (obj);
       if (NILP (proc))
-        error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj), name)));
+        error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj), name)));
     }
   else
     {
diff --git a/src/regex.c b/src/regex.c
index 615fb3fdf34..b45dbcaada7 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -5907,7 +5907,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
             EXTRACT_NUMBER_AND_INCR (mcnt, p);
             /* Here, we discard `const', making re_match non-reentrant.  */
             p2 = (unsigned char*) p + mcnt;
-            /* Signedness doesn't matter since we only copy MCNT's bits .  */
+            /* Signedness doesn't matter since we only copy MCNT's bits.  */
             EXTRACT_NUMBER_AND_INCR (mcnt, p);
             DEBUG_PRINT ("  Setting %p to %d.\n", p2, mcnt);
             PUSH_NUMBER (p2, mcnt);
diff --git a/src/term.c b/src/term.c
index f86d71ac2f4..4d900020ce6 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2407,7 +2407,7 @@ frame's terminal). */)
              was suspended.  */
           get_tty_size (fileno (t->display_info.tty->input), &width, &height);
           if (width != old_width || height != old_height)
-            change_frame_size (f, height, width, 0, 0, 0);
+            change_frame_size (f, width, height, 0, 0, 0, 0);
           SET_FRAME_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
         }
 
@@ -2739,7 +2739,7 @@ DEFUN ("gpm-mouse-stop", Fgpm_mouse_stop, Sgpm_mouse_stop,
                                Menus
  ***********************************************************************/
 
-#if defined (HAVE_MENUS) && !defined (MSDOS)
+#if !defined (MSDOS)
 
 /* TTY menu implementation and main ideas are borrowed from msdos.c.
 
@@ -3816,7 +3816,7 @@ tty_menu_show (struct frame *f, int x, int y, bool for_click, bool keymaps,
   return entry;
 }
 
-#endif  /* HAVE_MENUS && !MSDOS */
+#endif  /* !MSDOS */
 
 
 #ifndef MSDOS
@@ -3825,7 +3825,7 @@ tty_menu_show (struct frame *f, int x, int y, bool for_click, bool keymaps,
  ***********************************************************************/
 
 /* Initialize the tty-dependent part of frame F.  The frame must
-   already have its device initialized. */
+   already have its device initialized.  */
 
 void
 create_tty_output (struct frame *f)
@@ -3839,7 +3839,7 @@ create_tty_output (struct frame *f)
   f->output_data.tty = t;
 }
 
-/* Delete frame F's face cache, and its tty-dependent part. */
+/* Delete frame F's face cache, and its tty-dependent part.  */
 
 static void
 tty_free_frame_resources (struct frame *f)
@@ -3854,7 +3854,7 @@ tty_free_frame_resources (struct frame *f)
 
 #else  /* MSDOS */
 
-/* Delete frame F's face cache. */
+/* Delete frame F's face cache.  */
 
 static void
 tty_free_frame_resources (struct frame *f)
diff --git a/src/textprop.c b/src/textprop.c
index b804f345047..5597a781a61 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -1819,32 +1819,30 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
 int
 text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
 {
-  Lisp_Object prev_pos, front_sticky;
-  bool is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
+  bool ignore_previous_character;
+  Lisp_Object prev_pos = make_number (XINT (pos) - 1);
+  Lisp_Object front_sticky;
+  bool is_rear_sticky = true, is_front_sticky = false; /* defaults */
   Lisp_Object defalt = Fassq (prop, Vtext_property_default_nonsticky);
 
   if (NILP (buffer))
     XSETBUFFER (buffer, current_buffer);
 
-  if (CONSP (defalt) && !NILP (XCDR (defalt)))
-    is_rear_sticky = 0;
+  ignore_previous_character = XINT (pos) <= BUF_BEGV (XBUFFER (buffer));
 
-  if (XINT (pos) > BUF_BEGV (XBUFFER (buffer)))
-    /* Consider previous character.  */
+  if (ignore_previous_character || (CONSP (defalt) && !NILP (XCDR (defalt))))
+    is_rear_sticky = false;
+  else
     {
-      Lisp_Object rear_non_sticky;
-
-      prev_pos = make_number (XINT (pos) - 1);
-      rear_non_sticky = Fget_text_property (prev_pos, Qrear_nonsticky, buffer);
+      Lisp_Object rear_non_sticky
+        = Fget_text_property (prev_pos, Qrear_nonsticky, buffer);
 
       if (!NILP (CONSP (rear_non_sticky)
                  ? Fmemq (prop, rear_non_sticky)
                  : rear_non_sticky))
         /* PROP is rear-non-sticky.  */
-        is_rear_sticky = 0;
+        is_rear_sticky = false;
     }
-  else
-    return 0;
 
   /* Consider following character.  */
   /* This signals an arg-out-of-range error if pos is outside the
@@ -1855,7 +1853,7 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
       || (CONSP (front_sticky)
           && !NILP (Fmemq (prop, front_sticky))))
     /* PROP is inherited from after.  */
-    is_front_sticky = 1;
+    is_front_sticky = true;
 
   /* Simple cases, where the properties are consistent.  */
   if (is_rear_sticky && !is_front_sticky)
@@ -1869,7 +1867,7 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
      disambiguate.  Basically, rear-sticky wins, _except_ if the
      property that would be inherited has a value of nil, in which case
      front-sticky wins.  */
-  if (XINT (pos) == BUF_BEGV (XBUFFER (buffer))
+  if (ignore_previous_character
       || NILP (Fget_text_property (prev_pos, prop, buffer)))
     return 1;
   else
diff --git a/src/tparam.c b/src/tparam.c
index c3ecfb9e3a3..e97544d9234 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -79,7 +79,7 @@ tparam1 (const char *string, char *outstring, int len,
   register int tem;
   int *old_argp = argp;                 /* can move */
   int *fixed_argp = argp;               /* never moves */
-  int explicit_param_p = 0;             /* set by %p */
+  bool explicit_param_p = 0;            /* set by %p */
   ptrdiff_t doleft = 0;
   ptrdiff_t doup = 0;
   ptrdiff_t append_len = 0;
diff --git a/src/undo.c b/src/undo.c
index 234b8510f0a..88cca102b6d 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -55,7 +55,7 @@ static Lisp_Object pending_boundary;
 static void
 record_point (ptrdiff_t pt)
 {
-  int at_boundary;
+  bool at_boundary;
 
   /* Don't record position of pt when undo_inhibit_record_point holds.  */
   if (undo_inhibit_record_point)
@@ -77,7 +77,7 @@ record_point (ptrdiff_t pt)
 
   if (CONSP (BVAR (current_buffer, undo_list)))
     {
-      /* Set AT_BOUNDARY to 1 only when we have nothing other than
+      /* Set AT_BOUNDARY only when we have nothing other than
          marker adjustment before undo boundary.  */
 
       Lisp_Object tail = BVAR (current_buffer, undo_list), elt;
@@ -244,7 +244,7 @@ record_property_change (ptrdiff_t beg, ptrdiff_t length,
 {
   Lisp_Object lbeg, lend, entry;
   struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
-  int boundary = 0;
+  bool boundary = 0;
 
   if (EQ (BVAR (buf, undo_list), Qt))
     return;
diff --git a/src/w32fns.c b/src/w32fns.c
index a4f9e320fc4..b3e6d29b973 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1384,6 +1384,17 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     horizontal_drag_cursor
       = XCreateFontCursor (FRAME_X_DISPLAY (f), XC_sb_h_double_arrow);
 
+  if (!NILP (Vx_window_vertical_drag_shape))
+    {
+      CHECK_NUMBER (Vx_window_vertical_drag_shape);
+      vertical_drag_cursor
+        = XCreateFontCursor (FRAME_X_DISPLAY (f),
+                             XINT (Vx_window_vertical_drag_shape));
+    }
+  else
+    vertical_drag_cursor
+      = XCreateFontCursor (FRAME_X_DISPLAY (f), XC_sb_v_double_arrow);
+
   /* Check and report errors with the above calls.  */
   x_check_errors (FRAME_W32_DISPLAY (f), "can't set cursor shape: %s");
   x_uncatch_errors (FRAME_W32_DISPLAY (f), count);
@@ -1624,6 +1635,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     nlines = 0;
 
   FRAME_MENU_BAR_LINES (f) = 0;
+  FRAME_MENU_BAR_HEIGHT (f) = 0;
   if (nlines)
     FRAME_EXTERNAL_MENU_BAR (f) = 1;
   else
@@ -1635,7 +1647,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       /* Adjust the frame size so that the client (text) dimensions
          remain the same.  This depends on FRAME_EXTERNAL_MENU_BAR being
          set correctly.  */
-      x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+      x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
       do_pending_window_change (0);
     }
   adjust_frame_glyphs (f);
@@ -1643,16 +1655,17 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
 
 /* Set the number of lines used for the tool bar of frame F to VALUE.
-   VALUE not an integer, or < 0 means set the lines to zero.  OLDVAL
-   is the old number of tool bar lines.  This function changes the
-   height of all windows on frame F to match the new tool bar height.
-   The frame's height doesn't change.  */
+   VALUE not an integer, or < 0 means set the lines to zero.  OLDVAL is
+   the old number of tool bar lines (and is unused).  This function may
+   change the height of all windows on frame F to match the new tool bar
+   height.  By design, the frame's height doesn't change (but maybe it
+   should if we don't get enough space otherwise).  */
 
 void
 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 {
   int delta, nlines, root_height;
-  Lisp_Object root_window;
+  int unit = FRAME_LINE_HEIGHT (f);
 
   /* Treat tool bars like menu bars.  */
   if (FRAME_MINIBUF_ONLY_P (f))
@@ -1667,19 +1680,25 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
   /* Make sure we redisplay all windows in this frame.  */
   windows_or_buffers_changed = 23;
 
-  delta = nlines - FRAME_TOOL_BAR_LINES (f);
+  /* DELTA is in pixels now.  */
+  delta = (nlines - FRAME_TOOL_BAR_LINES (f)) * unit;
 
-  /* Don't resize the tool-bar to more than we have room for.  */
-  root_window = FRAME_ROOT_WINDOW (f);
-  root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
-  if (root_height - delta < 1)
+  /* Don't resize the tool-bar to more than we have room for.  FIXME:
+     This must use window_sizable eventually !!!!!!!!!!!!  */
+  if (delta > 0)
     {
-      delta = root_height - 1;
-      nlines = FRAME_TOOL_BAR_LINES (f) + delta;
+      root_height = WINDOW_PIXEL_HEIGHT (XWINDOW (FRAME_ROOT_WINDOW (f)));
+      if (root_height - delta < unit)
+        {
+          delta = root_height - unit;
+          nlines = (root_height / unit) + min (1, (root_height % unit));
+        }
     }
 
   FRAME_TOOL_BAR_LINES (f) = nlines;
-  resize_frame_windows (f, FRAME_LINES (f), 0);
+  FRAME_TOOL_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
+  ++windows_or_buffers_changed;
+  resize_frame_windows (f, FRAME_TEXT_HEIGHT (f), 0, 1);
   adjust_frame_glyphs (f);
 
   /* We also have to make sure that the internal border at the top of
@@ -1688,7 +1707,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
      below the tool bar if one is displayed, but is below the menu bar
      if there isn't a tool bar.  The tool bar draws into the area
      below the menu bar.  */
-  if (FRAME_W32_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
+  if (FRAME_W32_WINDOW (f) && FRAME_TOOL_BAR_HEIGHT (f) == 0)
     {
       clear_frame (f);
       clear_current_matrices (f);
@@ -1701,7 +1720,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     {
       int height = FRAME_INTERNAL_BORDER_WIDTH (f);
       int width = FRAME_PIXEL_WIDTH (f);
-      int y = nlines * FRAME_LINE_HEIGHT (f);
+      int y = nlines * unit;
 
       block_input ();
       {
@@ -1949,7 +1968,7 @@ w32_createwindow (struct frame *f)
       SetWindowLong (hwnd, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
       SetWindowLong (hwnd, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
       SetWindowLong (hwnd, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
-      SetWindowLong (hwnd, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width);
+      SetWindowLong (hwnd, WND_SCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_WIDTH (f));
       SetWindowLong (hwnd, WND_BACKGROUND_INDEX, FRAME_BACKGROUND_PIXEL (f));
 
       /* Enable drag-n-drop.  */
@@ -3225,6 +3244,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                                - WINDOW_RIGHT_MARGIN_WIDTH (w)
                                - WINDOW_RIGHT_FRINGE_WIDTH (w));
           form.rcArea.bottom = (WINDOW_BOTTOM_EDGE_Y (w)
+                                - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
                                 - w32_system_caret_mode_height);
 
           /* Punt if the window was deleted behind our back.  */
@@ -3774,7 +3794,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
     case WM_WINDOWPOSCHANGING:
       /* Don't restrict the sizing of tip frames.  */
-      if (hwnd == tip_window)
+      if (frame_resize_pixelwise || hwnd == tip_window)
         return 0;
 
       /* Don't restrict the sizing of fullscreened frames, allowing them to be
@@ -4453,6 +4473,10 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* Default internalBorderWidth to 0 on Windows to match other programs.  */
   x_default_parameter (f, parameters, Qinternal_border_width, make_number (0),
                        "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
+  x_default_parameter (f, parameters, Qright_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
+  x_default_parameter (f, parameters, Qbottom_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
   x_default_parameter (f, parameters, Qvertical_scroll_bars, Qright,
                        "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
 
@@ -4482,6 +4506,20 @@ This function is an internal primitive--use `make-frame' instead.  */)
      happen.  */
   init_frame_faces (f);
 
+  /* PXW: This is a duplicate from below.  We have to do it here since
+     otherwise x_set_tool_bar_lines will work with the character sizes
+     installed by init_frame_faces while the frame's pixel size is still
+     calculated from a character size of 1 and we subsequently hit the
+     eassert (height >= 0) assertion in window_box_height.  The
+     non-pixelwise code apparently worked around this because it had one
+     frame line vs one toolbar line which left us with a zero root
+     window height which was obviously wrong as well ...  */
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
+
   /* The X resources controlling the menu-bar and tool-bar are
      processed specially at startup, and reflected in the mode
      variables; ignore them here.  */
@@ -4510,6 +4548,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.w32->hand_cursor = w32_load_cursor (IDC_HAND);
   f->output_data.w32->hourglass_cursor = w32_load_cursor (IDC_WAIT);
   f->output_data.w32->horizontal_drag_cursor = w32_load_cursor (IDC_SIZEWE);
+  f->output_data.w32->vertical_drag_cursor = w32_load_cursor (IDC_SIZENS);
 
   f->output_data.w32->current_cursor = f->output_data.w32->nontext_cursor;
 
@@ -4547,12 +4586,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
      Change will not be effected unless different from the current
      FRAME_LINES (f).  */
-  width = FRAME_COLS (f);
-  height = FRAME_LINES (f);
-
-  FRAME_LINES (f) = 0;
-  SET_FRAME_COLS (f, 0);
-  change_frame_size (f, height, width, 1, 0, 0);
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
 
   /* Tell the server what size and position, etc, we want, and how
      badly we want them.  This should be done after we have the menu
@@ -5690,6 +5728,10 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
                        "internalBorderWidth", "internalBorderWidth",
                        RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qright_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
 
   /* Also do the stuff which must be set before the window exists.  */
   x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
@@ -5734,14 +5776,14 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   x_default_parameter (f, parms, Qcursor_type, Qbox,
                        "cursorType", "CursorType", RES_TYPE_SYMBOL);
 
-  /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
-     Change will not be effected unless different from the current
-     FRAME_LINES (f).  */
+  /* Dimensions, especially FRAME_LINES (f), must be done via
+     change_frame_size.  Change will not be effected unless different
+     from the current FRAME_LINES (f).  */
   width = FRAME_COLS (f);
   height = FRAME_LINES (f);
   FRAME_LINES (f) = 0;
   SET_FRAME_COLS (f, 0);
-  change_frame_size (f, height, width, 1, 0, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 0);
 
   /* Add `tooltip' frame parameter's default value. */
   if (NILP (Fframe_parameter (frame, Qtooltip)))
@@ -5999,6 +6041,10 @@ Text larger than the specified size is clipped.  */)
     parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
   if (NILP (Fassq (Qinternal_border_width, parms)))
     parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
+  if (NILP (Fassq (Qright_divider_width, parms)))
+    parms = Fcons (Fcons (Qright_divider_width, make_number (0)), parms);
+  if (NILP (Fassq (Qbottom_divider_width, parms)))
+    parms = Fcons (Fcons (Qbottom_divider_width, make_number (0)), parms);
   if (NILP (Fassq (Qborder_width, parms)))
     parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
   if (NILP (Fassq (Qborder_color, parms)))
@@ -6020,6 +6066,8 @@ Text larger than the specified size is clipped.  */)
   w = XWINDOW (FRAME_ROOT_WINDOW (f));
   w->left_col = 0;
   w->top_line = 0;
+  w->pixel_left = 0;
+  w->pixel_top = 0;
 
   if (CONSP (Vx_max_tooltip_size)
       && INTEGERP (XCAR (Vx_max_tooltip_size))
@@ -6036,6 +6084,9 @@ Text larger than the specified size is clipped.  */)
       w->total_lines = 40;
     }
 
+  w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (f);
+  w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (f);
+
   FRAME_TOTAL_COLS (f) = WINDOW_TOTAL_COLS (w);
   adjust_frame_glyphs (f);
   w->pseudo_window_p = 1;
@@ -6101,11 +6152,17 @@ Text larger than the specified size is clipped.  */)
      width of the frame.  */
   if (seen_reversed_p)
     {
-      /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
+      /* PXW: Why do we do the pixel-to-cols conversion only if
+         seen_reversed_p holds?  Don't we have to set other fields of
+         the window/frame structure?
+
+         w->total_cols and FRAME_TOTAL_COLS want the width in columns,
          not in pixels.  */
+      w->pixel_width = width;
       width /= WINDOW_FRAME_COLUMN_WIDTH (w);
       w->total_cols = width;
       FRAME_TOTAL_COLS (f) = width;
+      SET_FRAME_WIDTH (f, width);
       adjust_frame_glyphs (f);
       w->pseudo_window_p = 1;
       clear_glyph_matrix (w->desired_matrix);
@@ -6135,16 +6192,15 @@ Text larger than the specified size is clipped.  */)
         }
     }
 
-  /* Round up the height to an integral multiple of FRAME_LINE_HEIGHT.  */
-  if (height % FRAME_LINE_HEIGHT (f) != 0)
-    height += FRAME_LINE_HEIGHT (f) - height % FRAME_LINE_HEIGHT (f);
   /* Add the frame's internal border to the width and height the w32
      window should have.  */
   height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
   width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
 
   /* Move the tooltip window where the mouse pointer is.  Resize and
-     show it.  */
+     show it.
+
+     PXW: This should use the frame's pixel coordinates.  */
   compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
 
   {
@@ -7212,6 +7268,29 @@ This is a direct interface to the Windows API FindWindow function.  */)
   return Qt;
 }
 
+DEFUN ("w32-frame-rect", Fw32_frame_rect, Sw32_frame_rect, 0, 2, 0,
+       doc: /* Return boundary rectangle of FRAME in screen coordinates.
+FRAME must be a live frame and defaults to the selected one.
+
+The boundary rectangle is a list of four elements, specifying the left,
+top, right and bottom screen coordinates of FRAME including menu and
+title bar and decorations.  Optional argument CLIENT non-nil means to
+return the boundaries of the client rectangle which excludes menu and
+title bar and decorations.  */)
+  (Lisp_Object frame, Lisp_Object client)
+{
+  struct frame *f = decode_live_frame (frame);
+  RECT rect;
+
+  if (!NILP (client))
+    GetClientRect (FRAME_W32_WINDOW (f), &rect);
+  else
+    GetWindowRect (FRAME_W32_WINDOW (f), &rect);
+
+  return list4 (make_number (rect.left), make_number (rect.top),
+                make_number (rect.right), make_number (rect.bottom));
+}
+
 DEFUN ("w32-battery-status", Fw32_battery_status, Sw32_battery_status, 0, 0, 0,
        doc: /* Get power status information from Windows system.
 
@@ -7868,6 +7947,8 @@ frame_parm_handler w32_frame_parm_handlers[] =
   x_set_icon_name,
   x_set_icon_type,
   x_set_internal_border_width,
+  x_set_right_divider_width,
+  x_set_bottom_divider_width,
   x_set_menu_bar_lines,
   x_set_mouse_color,
   x_explicitly_set_name,
@@ -8119,6 +8200,13 @@ or when you set the mouse color.  */);
 This variable takes effect when you create a new frame
 or when you set the mouse color.  */);
   Vx_window_horizontal_drag_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-vertical-drag-cursor",
+               Vx_window_vertical_drag_shape,
+               doc: /* Pointer shape to use for indicating a window can be dragged vertically.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_vertical_drag_shape = Qnil;
 #endif
 
   DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
@@ -8211,6 +8299,7 @@ only be necessary if the default setting causes problems.  */);
   defsubr (&Sw32_reconstruct_hot_key);
   defsubr (&Sw32_toggle_lock_key);
   defsubr (&Sw32_window_exists_p);
+  defsubr (&Sw32_frame_rect);
   defsubr (&Sw32_battery_status);
 
 #ifdef WINDOWSNT
@@ -8238,61 +8327,35 @@ only be necessary if the default setting causes problems.  */);
 #endif
 }
 
+
 
-/*
-        globals_of_w32fns is used to initialize those global variables that
-        must always be initialized on startup even when the global variable
-        initialized is non zero (see the function main in emacs.c).
-        globals_of_w32fns is called from syms_of_w32fns when the global
-        variable initialized is 0 and directly from main when initialized
-        is non zero.
- */
-void
-globals_of_w32fns (void)
-{
-  HMODULE user32_lib = GetModuleHandle ("user32.dll");
-  /*
-    TrackMouseEvent not available in all versions of Windows, so must load
-    it dynamically.  Do it once, here, instead of every time it is used.
-  */
-  track_mouse_event_fn = (TrackMouseEvent_Proc)
-    GetProcAddress (user32_lib, "TrackMouseEvent");
-
-  monitor_from_point_fn = (MonitorFromPoint_Proc)
-    GetProcAddress (user32_lib, "MonitorFromPoint");
-  get_monitor_info_fn = (GetMonitorInfo_Proc)
-    GetProcAddress (user32_lib, "GetMonitorInfoA");
-  monitor_from_window_fn = (MonitorFromWindow_Proc)
-    GetProcAddress (user32_lib, "MonitorFromWindow");
-  enum_display_monitors_fn = (EnumDisplayMonitors_Proc)
-    GetProcAddress (user32_lib, "EnumDisplayMonitors");
-
-  {
-    HMODULE imm32_lib = GetModuleHandle ("imm32.dll");
-    get_composition_string_fn = (ImmGetCompositionString_Proc)
-      GetProcAddress (imm32_lib, "ImmGetCompositionStringW");
-    get_ime_context_fn = (ImmGetContext_Proc)
-      GetProcAddress (imm32_lib, "ImmGetContext");
-    release_ime_context_fn = (ImmReleaseContext_Proc)
-      GetProcAddress (imm32_lib, "ImmReleaseContext");
-    set_ime_composition_window_fn = (ImmSetCompositionWindow_Proc)
-      GetProcAddress (imm32_lib, "ImmSetCompositionWindow");
-  }
-  DEFVAR_INT ("w32-ansi-code-page",
-              w32_ansi_code_page,
-              doc: /* The ANSI code page used by the system.  */);
-  w32_ansi_code_page = GetACP ();
+/* Crashing and reporting backtrace.  */
 
-  if (os_subtype == OS_NT)
-    w32_unicode_gui = 1;
-  else
-    w32_unicode_gui = 0;
-
-  /* MessageBox does not work without this when linked to comctl32.dll 6.0.  */
-  InitCommonControls ();
+#ifndef CYGWIN
+static LONG CALLBACK my_exception_handler (EXCEPTION_POINTERS *);
+static LPTOP_LEVEL_EXCEPTION_FILTER prev_exception_handler;
+#endif
+static DWORD except_code;
+static PVOID except_addr;
 
-  syms_of_w32uniscribe ();
+#ifndef CYGWIN
+/* This handler records the exception code and the address where it
+   was triggered so that this info could be included in the backtrace.
+   Without that, the backtrace in some cases has no information
+   whatsoever about the offending code, and looks as if the top-level
+   exception handler in the MinGW startup code di the one that
+   crashed.  */
+static LONG CALLBACK
+my_exception_handler (EXCEPTION_POINTERS * exception_data)
+{
+  except_code = exception_data->ExceptionRecord->ExceptionCode;
+  except_addr = exception_data->ExceptionRecord->ExceptionAddress;
+
+  if (prev_exception_handler)
+    return prev_exception_handler (exception_data);
+  return EXCEPTION_EXECUTE_HANDLER;
 }
+#endif
 
 typedef USHORT (WINAPI * CaptureStackBackTrace_proc) (ULONG, ULONG, PVOID *,
                                                       PULONG);
@@ -8349,21 +8412,32 @@ emacs_abort (void)
 
         if (i)
           {
+            int errfile_fd = -1;
+            int j;
+            char buf[sizeof ("\r\nException  at this address:\r\n\r\n")
+                     + 2 * INT_BUFSIZE_BOUND (void *)];
 #ifdef CYGWIN
             int stderr_fd = 2;
 #else
             HANDLE errout = GetStdHandle (STD_ERROR_HANDLE);
             int stderr_fd = -1;
-#endif
-            int errfile_fd = -1;
-            int j;
 
-#ifndef CYGWIN
             if (errout && errout != INVALID_HANDLE_VALUE)
               stderr_fd = _open_osfhandle ((intptr_t)errout, O_APPEND | O_BINARY);
 #endif
+
+            /* We use %p, not 0x%p, as %p produces a leading "0x" on XP,
+               but not on Windows 7.  addr2line doesn't mind a missing
+               "0x", but will be confused by an extra one.  */
+            if (except_addr)
+              sprintf (buf, "\r\nException 0x%lx at this address:\r\n%p\r\n",
+                       except_code, except_addr);
             if (stderr_fd >= 0)
-              write (stderr_fd, "\r\nBacktrace:\r\n", 14);
+              {
+                if (except_addr)
+                  write (stderr_fd, buf, strlen (buf));
+                write (stderr_fd, "\r\nBacktrace:\r\n", 14);
+              }
 #ifdef CYGWIN
 #define _open open
 #endif
@@ -8371,17 +8445,17 @@ emacs_abort (void)
             if (errfile_fd >= 0)
               {
                 lseek (errfile_fd, 0L, SEEK_END);
+                if (except_addr)
+                  write (errfile_fd, buf, strlen (buf));
                 write (errfile_fd, "\r\nBacktrace:\r\n", 14);
               }
 
             for (j = 0; j < i; j++)
               {
-                char buf[INT_BUFSIZE_BOUND (void *)];
-
                 /* stack[] gives the return addresses, whereas we want
                    the address of the call, so decrease each address
                    by approximate size of 1 CALL instruction.  */
-                sprintf (buf, "0x%p\r\n", (char *)stack[j] - sizeof(void *));
+                sprintf (buf, "%p\r\n", (char *)stack[j] - sizeof(void *));
                 if (stderr_fd >= 0)
                   write (stderr_fd, buf, strlen (buf));
                 if (errfile_fd >= 0)
@@ -8403,6 +8477,72 @@ emacs_abort (void)
     }
 }
 
+
+
+/* Initialization.  */
+
+/*
+        globals_of_w32fns is used to initialize those global variables that
+        must always be initialized on startup even when the global variable
+        initialized is non zero (see the function main in emacs.c).
+        globals_of_w32fns is called from syms_of_w32fns when the global
+        variable initialized is 0 and directly from main when initialized
+        is non zero.
+ */
+void
+globals_of_w32fns (void)
+{
+  HMODULE user32_lib = GetModuleHandle ("user32.dll");
+  /*
+    TrackMouseEvent not available in all versions of Windows, so must load
+    it dynamically.  Do it once, here, instead of every time it is used.
+  */
+  track_mouse_event_fn = (TrackMouseEvent_Proc)
+    GetProcAddress (user32_lib, "TrackMouseEvent");
+
+  monitor_from_point_fn = (MonitorFromPoint_Proc)
+    GetProcAddress (user32_lib, "MonitorFromPoint");
+  get_monitor_info_fn = (GetMonitorInfo_Proc)
+    GetProcAddress (user32_lib, "GetMonitorInfoA");
+  monitor_from_window_fn = (MonitorFromWindow_Proc)
+    GetProcAddress (user32_lib, "MonitorFromWindow");
+  enum_display_monitors_fn = (EnumDisplayMonitors_Proc)
+    GetProcAddress (user32_lib, "EnumDisplayMonitors");
+
+  {
+    HMODULE imm32_lib = GetModuleHandle ("imm32.dll");
+    get_composition_string_fn = (ImmGetCompositionString_Proc)
+      GetProcAddress (imm32_lib, "ImmGetCompositionStringW");
+    get_ime_context_fn = (ImmGetContext_Proc)
+      GetProcAddress (imm32_lib, "ImmGetContext");
+    release_ime_context_fn = (ImmReleaseContext_Proc)
+      GetProcAddress (imm32_lib, "ImmReleaseContext");
+    set_ime_composition_window_fn = (ImmSetCompositionWindow_Proc)
+      GetProcAddress (imm32_lib, "ImmSetCompositionWindow");
+  }
+
+  except_code = 0;
+  except_addr = 0;
+#ifndef CYGWIN
+  prev_exception_handler = SetUnhandledExceptionFilter (my_exception_handler);
+#endif
+
+  DEFVAR_INT ("w32-ansi-code-page",
+              w32_ansi_code_page,
+              doc: /* The ANSI code page used by the system.  */);
+  w32_ansi_code_page = GetACP ();
+
+  if (os_subtype == OS_NT)
+    w32_unicode_gui = 1;
+  else
+    w32_unicode_gui = 0;
+
+  /* MessageBox does not work without this when linked to comctl32.dll 6.0.  */
+  InitCommonControls ();
+
+  syms_of_w32uniscribe ();
+}
+
 #ifdef NTGUI_UNICODE
 
 Lisp_Object
diff --git a/src/w32font.c b/src/w32font.c
index effedfc04e1..654e0d9cae4 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -149,6 +149,7 @@ static BOOL g_b_init_get_outline_metrics_w;
 static BOOL g_b_init_get_text_metrics_w;
 static BOOL g_b_init_get_glyph_outline_w;
 static BOOL g_b_init_get_glyph_outline_w;
+static BOOL g_b_init_get_char_width_32_w;
 
 typedef UINT (WINAPI * GetOutlineTextMetricsW_Proc) (
    HDC hdc,
@@ -165,6 +166,11 @@ typedef DWORD (WINAPI * GetGlyphOutlineW_Proc) (
    DWORD cbBuffer,
    LPVOID lpvBuffer,
    const MAT2 *lpmat2);
+typedef BOOL (WINAPI * GetCharWidth32W_Proc) (
+   HDC hdc,
+   UINT uFirstChar,
+   UINT uLastChar,
+   LPINT lpBuffer);
 
 /* Several "wide" functions we use to support the font backends are
    unavailable on Windows 9X, unless UNICOWS.DLL is installed (their
@@ -274,6 +280,23 @@ get_glyph_outline_w (HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
                                    lpvBuffer, lpmat2);
 }
 
+static DWORD WINAPI get_char_width_32_w (HDC hdc, UINT uFirstChar,
+                                         UINT uLastChar, LPINT lpBuffer)
+{
+  static GetCharWidth32W_Proc s_pfn_Get_Char_Width_32W = NULL;
+  HMODULE hm_unicows = NULL;
+  if (g_b_init_get_char_width_32_w == 0)
+    {
+      g_b_init_get_char_width_32_w = 1;
+      hm_unicows = w32_load_unicows_or_gdi32 ();
+      if (hm_unicows)
+        s_pfn_Get_Char_Width_32W = (GetCharWidth32W_Proc)
+          GetProcAddress (hm_unicows, "GetCharWidth32W");
+    }
+  eassert (s_pfn_Get_Char_Width_32W != NULL);
+  return s_pfn_Get_Char_Width_32W (hdc, uFirstChar, uLastChar, lpBuffer);
+}
+
 static int
 memq_no_quit (Lisp_Object elt, Lisp_Object list)
 {
@@ -989,7 +1012,6 @@ w32font_open_internal (struct frame *f, Lisp_Object font_entity,
   font->baseline_offset = 0;
   font->relative_compose = 0;
   font->default_ascent = w32_font->metrics.tmAscent;
-  font->font_encoder = NULL;
   font->pixel_size = size;
   font->driver = &w32font_driver;
   /* Use format cached during list, as the information we have access to
@@ -2437,6 +2459,7 @@ compute_metrics (HDC dc, struct w32font_info *w32_font, unsigned int code,
   GLYPHMETRICS gm;
   MAT2 transform;
   unsigned int options = GGO_METRICS;
+  INT width;
 
   if (w32_font->glyph_idx)
     options |= GGO_GLYPH_INDEX;
@@ -2453,6 +2476,13 @@ compute_metrics (HDC dc, struct w32font_info *w32_font, unsigned int code,
       metrics->width = gm.gmCellIncX;
       metrics->status = W32METRIC_SUCCESS;
     }
+  else if (get_char_width_32_w (dc, code, code, &width) != 0)
+    {
+      metrics->lbearing = 0;
+      metrics->rbearing = width;
+      metrics->width = width;
+      metrics->status = W32METRIC_SUCCESS;
+    }
   else
     metrics->status = W32METRIC_FAIL;
 }
@@ -2727,4 +2757,5 @@ globals_of_w32font (void)
   g_b_init_get_outline_metrics_w = 0;
   g_b_init_get_text_metrics_w = 0;
   g_b_init_get_glyph_outline_w = 0;
+  g_b_init_get_char_width_32_w = 0;
 }
diff --git a/src/w32inevt.c b/src/w32inevt.c
index dc587de1183..d4c96bd9b8a 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -587,7 +587,7 @@ resize_event (WINDOW_BUFFER_SIZE_RECORD *event)
 {
   struct frame *f = get_frame ();
 
-  change_frame_size (f, event->dwSize.Y, event->dwSize.X, 0, 1, 0);
+  change_frame_size (f, event->dwSize.X, event->dwSize.Y, 0, 1, 0, 0);
   SET_FRAME_GARBAGED (f);
 }
 
@@ -602,13 +602,13 @@ maybe_generate_resize_event (void)
   /* It is okay to call this unconditionally, since it will do nothing
      if the size hasn't actually changed.  */
   change_frame_size (f,
-                     1 + info.srWindow.Bottom - info.srWindow.Top,
                      1 + info.srWindow.Right - info.srWindow.Left,
-                     0, 0, 0);
+                     1 + info.srWindow.Bottom - info.srWindow.Top,
+                     0, 0, 0, 0);
 }
 
 #if HAVE_W32NOTIFY
-static int
+int
 handle_file_notifications (struct input_event *hold_quit)
 {
   BYTE *p = file_notifications;
@@ -676,7 +676,7 @@ handle_file_notifications (struct input_event *hold_quit)
   return nevents;
 }
 #else  /* !HAVE_W32NOTIFY */
-static int
+int
 handle_file_notifications (struct input_event *hold_quit)
 {
   return 0;
diff --git a/src/w32menu.c b/src/w32menu.c
index b25652017cd..4f8e8dbef05 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -114,7 +114,6 @@ static int fill_in_menu (HMENU, widget_value *);
 
 void w32_free_menu_strings (HWND);
 
-#ifdef HAVE_MENUS
 #ifdef HAVE_DIALOGS
 Lisp_Object
 w32_popup_dialog (struct frame *f, Lisp_Object header, Lisp_Object contents)
@@ -506,7 +505,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
     /* Force the window size to be recomputed so that the frame's text
        area remains the same, if menubar has just been created.  */
     if (old_widget == NULL)
-      x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+      x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
   }
 
   unblock_input ();
@@ -1602,21 +1601,15 @@ w32_free_menu_strings (HWND hwnd)
   current_popup_menu = NULL;
 }
 
-#endif /* HAVE_MENUS */
-
 /* The following is used by delayed window autoselection.  */
 
 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_p, 0, 0, 0,
        doc: /* Return t if a menu or popup dialog is active on selected frame.  */)
   (void)
 {
-#ifdef HAVE_MENUS
   struct frame *f;
   f = SELECTED_FRAME ();
   return (f->output_data.w32->menubar_active > 0) ? Qt : Qnil;
-#else
-  return Qnil;
-#endif /* HAVE_MENUS */
 }
 
 void
diff --git a/src/w32notify.c b/src/w32notify.c
index a48a83daf53..373e20e8e92 100644
--- a/src/w32notify.c
+++ b/src/w32notify.c
@@ -163,7 +163,12 @@ send_notifications (BYTE *info, DWORD info_size, void *desc,
                && PostThreadMessage (dwMainThreadId, WM_EMACS_FILENOTIFY, 0, 0))
               || (FRAME_W32_P (f)
                   && PostMessage (FRAME_W32_WINDOW (f),
-                                  WM_EMACS_FILENOTIFY, 0, 0)))
+                                  WM_EMACS_FILENOTIFY, 0, 0))
+              /* When we are running in batch mode, there's no one to
+                 send a message, so we just signal the data is
+                 available and hope sys_select will be called soon and
+                 will read the data.  */
+              || (FRAME_INITIAL_P (f) && noninteractive))
             notification_buffer_in_use = 1;
           done = 1;
         }
@@ -324,7 +329,7 @@ add_watch (const char *parent_dir, const char *file, BOOL subdirs, DWORD flags)
   HANDLE hdir;
   struct notification *dirwatch = NULL;
 
-  if (!file || !*file)
+  if (!file)
     return NULL;
 
   hdir = CreateFile (parent_dir,
@@ -526,13 +531,21 @@ generate notifications correctly, though.  */)
       report_file_error ("GetFullPathName failed",
                          Fcons (lisp_errstr, Fcons (file, Qnil)));
     }
-  /* We need the parent directory without the slash that follows it.
-     If BASENAME is NULL, the argument was the root directory on its
-     drive.  */
-  if (basename)
-    basename[-1] = '\0';
+  /* filenotify.el always passes us a directory, either the parent
+     directory of a file to be watched, or the directory to be
+     watched.  */
+  if (file_directory_p (parent_dir))
+    basename = "";
   else
-    subdirs = TRUE;
+    {
+      /* This should only happen if we are called directly, not via
+         filenotify.el.  If BASENAME is NULL, the argument was the
+         root directory on its drive.  */
+      if (basename)
+        basename[-1] = '\0';
+      else
+        subdirs = TRUE;
+    }
 
   if (!NILP (Fmember (Qsubtree, filter)))
     subdirs = TRUE;
diff --git a/src/w32proc.c b/src/w32proc.c
index d2751d50680..7d4fb9825fa 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1941,12 +1941,17 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
   FD_ZERO (rfds);
   nr = 0;
 
-  /* Always wait on interrupt_handle, to detect C-g (quit).  */
-  wait_hnd[0] = interrupt_handle;
-  fdindex[0] = -1;
+  /* If interrupt_handle is available and valid, always wait on it, to
+     detect C-g (quit).  */
+  nh = 0;
+  if (interrupt_handle && interrupt_handle != INVALID_HANDLE_VALUE)
+    {
+      wait_hnd[0] = interrupt_handle;
+      fdindex[0] = -1;
+      nh++;
+    }
 
   /* Build a list of pipe handles to wait on.  */
-  nh = 1;
   for (i = 0; i < nfds; i++)
     if (FD_ISSET (i, &orfds))
       {
@@ -1967,6 +1972,11 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
                 FD_SET (i, rfds);
                 return 1;
               }
+            else if (noninteractive)
+              {
+                if (handle_file_notifications (NULL))
+                  return 1;
+              }
           }
         else
           {
@@ -2067,6 +2077,11 @@ count_children:
     {
       if (timeout)
         Sleep (timeout_ms);
+      if (noninteractive)
+        {
+          if (handle_file_notifications (NULL))
+            return 1;
+        }
       return 0;
     }
 
@@ -2093,6 +2108,11 @@ count_children:
     }
   else if (active == WAIT_TIMEOUT)
     {
+      if (noninteractive)
+        {
+          if (handle_file_notifications (NULL))
+            return 1;
+        }
       return 0;
     }
   else if (active >= WAIT_OBJECT_0
@@ -2199,6 +2219,12 @@ count_children:
           break;
     } while (active < nh + nc);
 
+  if (noninteractive)
+    {
+      if (handle_file_notifications (NULL))
+        nr++;
+    }
+
   /* If no input has arrived and timeout hasn't expired, wait again.  */
   if (nr == 0)
     {
diff --git a/src/w32term.c b/src/w32term.c
index b29087ef57b..9c74304a83a 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -181,7 +181,7 @@ void x_lower_frame (struct frame *);
 void x_scroll_bar_clear (struct frame *);
 void x_wm_set_size_hint (struct frame *, long, bool);
 void x_raise_frame (struct frame *);
-void x_set_window_size (struct frame *, int, int, int);
+void x_set_window_size (struct frame *, int, int, int, bool);
 void x_wm_set_window_state (struct frame *, int);
 void x_wm_set_icon_pixmap (struct frame *, int);
 static void w32_initialize (void);
@@ -622,6 +622,32 @@ w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
 }
 
 
+/* Draw a window divider from (x0, y0) to (x1, y1)  */
+
+static void
+w32_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
+{
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+  RECT r;
+  HDC hdc;
+  struct face *face;
+
+  r.left = x0;
+  r.right = x1;
+  r.top = y0;
+  r.bottom = y1;
+
+  hdc = get_frame_dc (f);
+  face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
+  if (face)
+    w32_fill_rect (f, hdc, face->foreground, &r);
+  else
+    w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
+
+  release_frame_dc (f, hdc);
+}
+
+
 /* End update of window W.
 
    Draw vertical borders between horizontally adjacent windows, and
@@ -649,7 +675,12 @@ x_update_window_end (struct window *w, bool cursor_on_p,
                                 w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
-        x_draw_vertical_border (w);
+        {
+          if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+            x_draw_right_divider (w);
+          else
+            x_draw_vertical_border (w);
+        }
 
       unblock_input ();
     }
@@ -778,8 +809,7 @@ w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
           if (sb_width > 0)
             {
               int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
-              int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
-                                    * FRAME_COLUMN_WIDTH (f));
+              int bar_area_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
 
               if (bx < 0)
                 {
@@ -2676,8 +2706,7 @@ x_scroll_run (struct window *w, struct run *run)
       if (sb_width > 0)
         {
           int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
-          int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
-                                * FRAME_COLUMN_WIDTH (f));
+          int bar_area_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
 
           if (bar_area_x + bar_area_width == x)
             {
@@ -3761,7 +3790,7 @@ w32_set_vertical_scroll_bar (struct window *w,
   /* Get window dimensions.  */
   window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
   top  = window_y;
-  width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
+  width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
   height = window_height;
 
   /* Compute the left edge of the scroll bar area.  */
@@ -4216,7 +4245,6 @@ w32_read_socket (struct terminal *terminal,
   struct frame *f;
   struct w32_display_info *dpyinfo = &one_w32_display_info;
   Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
-  static char buf[1];
 
   block_input ();
 
@@ -4702,6 +4730,47 @@ w32_read_socket (struct terminal *terminal,
                   break;
 
                 case SIZE_MAXIMIZED:
+                  {
+                    bool iconified = FRAME_ICONIFIED_P (f);
+
+                    SET_FRAME_VISIBLE (f, 1);
+                    SET_FRAME_ICONIFIED (f, 0);
+
+                    /* wait_reading_process_output will notice this
+                       and update the frame's display structures.  */
+                    SET_FRAME_GARBAGED (f);
+
+                    if (iconified)
+                      {
+                        int x, y;
+
+                        /* Reset top and left positions of the Window
+                           here since Windows sends a WM_MOVE message
+                           BEFORE telling us the Window is minimized
+                           when the Window is iconified, with 3000,3000
+                           as the co-ords. */
+                        x_real_positions (f, &x, &y);
+                        f->left_pos = x;
+                        f->top_pos = y;
+
+                        inev.kind = DEICONIFY_EVENT;
+                        XSETFRAME (inev.frame_or_window, f);
+                      }
+                    else if (! NILP (Vframe_list)
+                             && ! NILP (XCDR (Vframe_list)))
+                      /* Force a redisplay sooner or later
+                         to update the frame titles
+                         in case this is the second frame.  */
+                      record_asynch_buffer_change ();
+                  }
+
+                  if (get_frame_param (f, Qfullscreen) == Qnil)
+                    set_frame_param (f, Qfullscreen, Qmaximized);
+                  else if (get_frame_param (f, Qfullscreen) != Qmaximized)
+                    set_frame_param (f, Qmaximized, Qmaximized);
+
+                  break;
+
                 case SIZE_RESTORED:
                   {
                     bool iconified = FRAME_ICONIFIED_P (f);
@@ -4733,6 +4802,12 @@ w32_read_socket (struct terminal *terminal,
                          in case this is the second frame.  */
                       record_asynch_buffer_change ();
                   }
+
+                  if (get_frame_param (f, Qfullscreen) == Qmaximized)
+                    set_frame_param (f, Qfullscreen, Qnil);
+                  else if (get_frame_param (f, Qmaximized) != Qnil)
+                    set_frame_param (f, Qmaximized, Qnil);
+
                   break;
                 }
             }
@@ -4740,16 +4815,14 @@ w32_read_socket (struct terminal *terminal,
           if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
             {
               RECT rect;
-              int rows;
-              int columns;
-              int width;
-              int height;
+              int rows, columns, width, height, text_width, text_height;
 
               GetClientRect (msg.msg.hwnd, &rect);
 
               height = rect.bottom - rect.top;
               width = rect.right - rect.left;
-
+              text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
+              text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
               rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height);
               columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width);
 
@@ -4759,16 +4832,18 @@ w32_read_socket (struct terminal *terminal,
                  not changed, the font size may have changed, so we need
                  to check the pixel dimensions as well.  */
 
-              if (columns != FRAME_COLS (f)
-                  || rows != FRAME_LINES (f)
-                  || width != FRAME_PIXEL_WIDTH (f)
-                  || height != FRAME_PIXEL_HEIGHT (f))
+              if (width != FRAME_PIXEL_WIDTH (f)
+                  || height != FRAME_PIXEL_HEIGHT (f)
+                  || text_width != FRAME_TEXT_WIDTH (f)
+                  || text_height != FRAME_TEXT_HEIGHT (f))
                 {
-                  change_frame_size (f, rows, columns, 0, 1, 0);
+                  change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
                   SET_FRAME_GARBAGED (f);
                   cancel_mouse_face (f);
-                  FRAME_PIXEL_WIDTH (f) = width;
-                  FRAME_PIXEL_HEIGHT (f) = height;
+                  /* Do we want to set these here ????  */
+/**               FRAME_PIXEL_WIDTH (f) = width; **/
+/**               FRAME_TEXT_WIDTH (f) = text_width; **/
+/**               FRAME_PIXEL_HEIGHT (f) = height; **/
                   f->win_gravity = NorthWestGravity;
                 }
             }
@@ -5425,7 +5500,8 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
          doing it because it's done in Fx_show_tip, and it leads to
          problems because the tip frame has no widget.  */
       if (NILP (tip_frame) || XFRAME (tip_frame) != f)
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+        x_set_window_size (f, 0, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
+                           FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 1);
     }
 
   /* X version sets font of input methods here also.  */
@@ -5563,7 +5639,7 @@ x_check_fullscreen (struct frame *f)
          when setting WM manager hints.  */
       if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
         {
-          change_frame_size (f, height, width, 0, 1, 0);
+          change_frame_size (f, width, height, 0, 1, 0, 0);
           SET_FRAME_GARBAGED (f);
           cancel_mouse_face (f);
 
@@ -5627,20 +5703,28 @@ w32fullscreen_hook (struct frame *f)
    Otherwise we leave the window gravity unchanged.  */
 
 void
-x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
+x_set_window_size (struct frame *f, int change_gravity, int width, int height, bool pixelwise)
 {
   int pixelwidth, pixelheight;
 
   block_input ();
 
-  check_frame_size (f, &rows, &cols);
+  check_frame_size (f, &width, &height, pixelwise);
   f->scroll_bar_actual_width
     = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
 
   compute_fringe_widths (f, 0);
 
-  pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
-  pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+  if (pixelwise)
+    {
+      pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
+      pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
+    }
+  else
+    {
+      pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
+      pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
+    }
 
   f->win_gravity = NorthWestGravity;
   x_wm_set_size_hint (f, (long) 0, 0);
@@ -5691,7 +5775,7 @@ x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
 
      We pass 1 for DELAY since we can't run Lisp code inside of
      a BLOCK_INPUT.  */
-  change_frame_size (f, rows, cols, 0, 1, 0);
+  change_frame_size (f, width, height, 0, 1, 0, 0);
   FRAME_PIXEL_WIDTH (f) = pixelwidth;
   FRAME_PIXEL_HEIGHT (f) = pixelheight;
 
@@ -6072,7 +6156,7 @@ x_wm_set_size_hint (struct frame *f, long flags, bool user_position)
   SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
   SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
   SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
-  SetWindowLong (window, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width);
+  SetWindowLong (window, WND_SCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_WIDTH (f));
 
   leave_crit ();
 }
@@ -6212,6 +6296,7 @@ static struct redisplay_interface w32_redisplay_interface =
   w32_clear_frame_area,
   w32_draw_window_cursor,
   w32_draw_vertical_window_border,
+  w32_draw_window_divider,
   w32_shift_glyphs_for_insert
 };
 
diff --git a/src/w32term.h b/src/w32term.h
index b3c0cf56c7b..89008b7348c 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -26,23 +26,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define BLACK_PIX_DEFAULT(f) PALETTERGB(0,0,0)
 #define WHITE_PIX_DEFAULT(f) PALETTERGB(255,255,255)
 
-#define FONT_WIDTH(f)     ((f)->max_width)
-#define FONT_HEIGHT(f)    ((f)->height)
-#define FONT_BASE(f)      ((f)->ascent)
-#define FONT_DESCENT(f)   ((f)->descent)
-
 #define CP_DEFAULT 1004
 
-#define CHECK_W32_FRAME(f, frame)               \
-  if (NILP (frame))                             \
-    f = SELECTED_FRAME ();                      \
-  else                                          \
-    {                                           \
-      CHECK_LIVE_FRAME (frame, 0);              \
-      f = XFRAME (frame);                       \
-    }                                           \
-  if (! FRAME_W32_P (f))
-
 /* Indicates whether we are in the readsocket call and the message we
    are processing in the current loop */
 
@@ -230,7 +215,7 @@ extern struct w32_display_info *w32_term_init (Lisp_Object,
 extern int w32_defined_color (struct frame *f, const char *color,
                               XColor *color_def, int alloc);
 extern void x_set_window_size (struct frame *f, int change_grav,
-                              int cols, int rows);
+                               int width, int height, bool pixelwise);
 extern int x_display_pixel_height (struct w32_display_info *);
 extern int x_display_pixel_width (struct w32_display_info *);
 extern Lisp_Object x_get_focus_frame (struct frame *);
@@ -349,6 +334,7 @@ struct w32_output
   Cursor hand_cursor;
   Cursor hourglass_cursor;
   Cursor horizontal_drag_cursor;
+  Cursor vertical_drag_cursor;
 
   /* Non-zero means hourglass cursor is currently displayed.  */
   unsigned hourglass_p : 1;
@@ -680,6 +666,7 @@ extern DWORD notifications_size;
 extern void *notifications_desc;
 extern Lisp_Object w32_get_watch_object (void *);
 extern Lisp_Object lispy_file_action (DWORD);
+extern int handle_file_notifications (struct input_event *);
 
 extern void w32_initialize_display_info (Lisp_Object);
 extern void initialize_w32_display (struct terminal *, int *, int *);
diff --git a/src/w32xfns.c b/src/w32xfns.c
index 07f75477863..b49abffa130 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -24,6 +24,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "keyboard.h"
 #include "frame.h"
+#include "window.h"
 #include "charset.h"
 #include "fontset.h"
 #include "blockinput.h"
diff --git a/src/widget.c b/src/widget.c
index d6469d7eec5..89b43fdae76 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -412,7 +412,7 @@ set_frame_size (EmacsFrame ew)
 #if 0 /* This can run Lisp code, and it is dangerous to give
          out the frame to Lisp code before it officially exists.
          This is handled in Fx_create_frame so not needed here.  */
-    change_frame_size (f, h, w, 1, 0, 0);
+    change_frame_size (f, w, h, 1, 0, 0, 0);
 #endif
     char_to_pixel_size (ew, w, h, &pixel_width, &pixel_height);
     ew->core.width = pixel_width;
@@ -467,7 +467,7 @@ update_wm_hints (EmacsFrame ew)
   if (! wmshell) return;
 
 #if 0
-  check_frame_size (ew->emacs_frame.frame, &min_rows, &min_cols);
+  check_frame_size (ew->emacs_frame.frame, &min_cols, &min_rows, 0);
 #endif
 
   pixel_to_char_size (ew, ew->core.width, ew->core.height,
@@ -681,7 +681,7 @@ EmacsFrameResize (Widget widget)
       || ew->core.width != FRAME_PIXEL_WIDTH (f)
       || ew->core.height + x->menubar_height != FRAME_PIXEL_HEIGHT (f))
     {
-      change_frame_size (f, rows, columns, 0, 1, 0);
+      change_frame_size (f, columns, rows, 0, 1, 0, 0);
       update_wm_hints (ew);
       update_various_frame_slots (ew);
 
@@ -735,8 +735,8 @@ EmacsFrameSetValues (Widget cur_widget, Widget req_widget, Widget new_widget, Ar
       new->core.width = pixel_width;
       new->core.height = pixel_height;
 
-      change_frame_size (new->emacs_frame.frame, char_height, char_width,
-                          1, 0, 0);
+      change_frame_size (new->emacs_frame.frame, char_width, char_height,
+                         1, 0, 0, 0);
       needs_a_refresh = True;
     }
 
@@ -798,7 +798,7 @@ EmacsFrameSetCharSize (Widget widget, int columns, int rows)
   EmacsFrame ew = (EmacsFrame) widget;
   struct frame *f = ew->emacs_frame.frame;
 
-  x_set_window_size (f, 0, columns, rows);
+  x_set_window_size (f, 0, columns, rows, 0);
 }
 
 
diff --git a/src/window.c b/src/window.c
index bc0adaf459f..d1f3dd599b1 100644
--- a/src/window.c
+++ b/src/window.c
@@ -51,6 +51,7 @@ static Lisp_Object Qrecord_window_buffer;
 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
 static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
+static Lisp_Object Qwindow_pixel_to_total;
 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
 static Lisp_Object Qsafe, Qabove, Qbelow, Qwindow_size, Qclone_of;
 
@@ -60,7 +61,6 @@ static int get_leaf_windows (struct window *, struct window **, int);
 static void window_scroll (Lisp_Object, EMACS_INT, bool, int);
 static void window_scroll_pixel_based (Lisp_Object, int, bool, int);
 static void window_scroll_line_based (Lisp_Object, int, bool, int);
-static Lisp_Object window_list (void);
 static int add_window_to_list (struct window *, void *);
 static Lisp_Object next_window (Lisp_Object, Lisp_Object,
                                 Lisp_Object, int);
@@ -75,6 +75,7 @@ static int foreach_window_1 (struct window *,
 static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
 static int window_resize_check (struct window *, bool);
 static void window_resize_apply (struct window *, bool);
+static void window_resize_apply_total (struct window *, bool);
 static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
 static void select_window_1 (Lisp_Object, bool);
 
@@ -113,6 +114,9 @@ Lisp_Object minibuf_selected_window;
 /* Hook run at end of temp_output_buffer_show.  */
 static Lisp_Object Qtemp_buffer_show_hook;
 
+/* Incremented for each window created.  */
+static int sequence_number;
+
 /* Nonzero after init_window_once has finished.  */
 static int window_initialized;
 
@@ -482,6 +486,15 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
        record_buffer before returning here.  */
     goto record_and_return;
 
+  if (NILP (norecord))
+    { /* Mark the window for redisplay since the selected-window has
+         a different mode-line.  */
+      wset_redisplay (XWINDOW (selected_window));
+      wset_redisplay (w);
+    }
+  else
+    redisplay_other_windows ();
+
   sf = SELECTED_FRAME ();
   if (XFRAME (WINDOW_FRAME (w)) != sf)
     {
@@ -500,7 +513,6 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 
   select_window_1 (window, inhibit_point_swap);
   bset_last_selected_window (XBUFFER (w->contents), window);
-  windows_or_buffers_changed = 24;
 
  record_and_return:
   /* record_buffer can run QUIT, so make sure it is run only after we have
@@ -669,6 +681,31 @@ selected one.  */)
   return make_number (decode_live_window (window)->use_time);
 }
 
+DEFUN ("window-pixel-width", Fwindow_pixel_width, Swindow_pixel_width, 0, 1, 0,
+       doc: /* Return the pixel width of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.
+
+The return value includes the fringes and margins of WINDOW as well as
+any vertical dividers or scroll bars belonging to WINDOW.  If WINDOW is
+an internal window, its pixel width is the width of the screen areas
+spanned by its children.  */)
+     (Lisp_Object window)
+{
+  return make_number (decode_valid_window (window)->pixel_width);
+}
+
+DEFUN ("window-pixel-height", Fwindow_pixel_height, Swindow_pixel_height, 0, 1, 0,
+       doc: /* Return the pixel height of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.
+
+The return value includes the mode line and header line, if any.  If
+WINDOW is an internal window, its pixel height is the height of the
+screen areas spanned by its children.  */)
+  (Lisp_Object window)
+{
+  return make_number (decode_valid_window (window)->pixel_height);
+}
+
 DEFUN ("window-total-height", Fwindow_total_height, Swindow_total_height, 0, 1, 0,
        doc: /* Return the total height, in lines, of window WINDOW.
 WINDOW must be a valid window and defaults to the selected one.
@@ -726,6 +763,30 @@ WINDOW must be a valid window and defaults to the selected one.  */)
   return decode_valid_window (window)->new_normal;
 }
 
+DEFUN ("window-new-pixel", Fwindow_new_pixel, Swindow_new_pixel, 0, 1, 0,
+       doc: /* Return new pixel size of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.  */)
+  (Lisp_Object window)
+{
+  return decode_valid_window (window)->new_pixel;
+}
+
+DEFUN ("window-pixel-left", Fwindow_pixel_left, Swindow_pixel_left, 0, 1, 0,
+       doc: /* Return left pixel edge of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.  */)
+  (Lisp_Object window)
+{
+  return make_number (decode_valid_window (window)->pixel_left);
+}
+
+DEFUN ("window-pixel-top", Fwindow_pixel_top, Swindow_pixel_top, 0, 1, 0,
+       doc: /* Return top pixel edge of window WINDOW.
+WINDOW must be a valid window and defaults to the selected one.  */)
+  (Lisp_Object window)
+{
+  return make_number (decode_valid_window (window)->pixel_top);
+}
+
 DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
        doc: /* Return left column of window WINDOW.
 This is the distance, in columns, between the left edge of WINDOW and
@@ -754,75 +815,118 @@ WINDOW must be a valid window and defaults to the selected one.  */)
    header line of W.  */
 
 static int
-window_body_lines (struct window *w)
+window_body_height (struct window *w, bool pixelwise)
 {
-  int height = w->total_lines;
-
-  if (!MINI_WINDOW_P (w))
-    {
-      if (WINDOW_WANTS_MODELINE_P (w))
-        --height;
-      if (WINDOW_WANTS_HEADER_LINE_P (w))
-        --height;
-    }
+  int pixels = (w->pixel_height
+                - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
+                - WINDOW_HEADER_LINE_HEIGHT (w)
+                - WINDOW_MODE_LINE_HEIGHT (w));
+  int unit = FRAME_LINE_HEIGHT (WINDOW_XFRAME (w));
 
-  return height;
+  return pixelwise ? pixels : ((pixels + unit - 1) / unit);
 }
 
 /* Return the number of columns of W's body.  Don't count columns
    occupied by the scroll bar or the vertical bar separating W from its
    right sibling.  On window-systems don't count fringes or display
    margins either.  */
-
 int
-window_body_cols (struct window *w)
+window_body_width (struct window *w, bool pixelwise)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
-  int width = w->total_cols;
 
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
-    /* Scroll bars occupy a few columns.  */
-    width -= WINDOW_CONFIG_SCROLL_BAR_COLS (w);
-  else if (!FRAME_WINDOW_P (f)
-           && !WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
-    /* The column of `|' characters separating side-by-side windows
-       occupies one column only.  */
-    width -= 1;
+  int pixels = (w->pixel_width
+                - WINDOW_RIGHT_DIVIDER_WIDTH (w)
+                - (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
+                   ? WINDOW_SCROLL_BAR_AREA_WIDTH (w)
+                   : ((!FRAME_WINDOW_P (f)
+                       && !WINDOW_RIGHTMOST_P (w)
+                       && !WINDOW_RIGHT_DIVIDER_WIDTH (w)
+                       && !WINDOW_FULL_WIDTH_P (w))
+                      /* According to Eli this is either 1 or 0.  */
+                      ? 1 : 0))
+                - WINDOW_MARGINS_WIDTH (w)
+                - (FRAME_WINDOW_P (f)
+                   ? WINDOW_FRINGES_WIDTH (w)
+                   : 0));
+  int unit = FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w));
+
+  return pixelwise ? pixels : ((pixels + unit - 1) / unit);
+}
+
+DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 2, 0,
+       doc: /* Return the height, in lines, of WINDOW's text area.
+WINDOW must be a live window and defaults to the selected one.
 
-  /* Display margins cannot be used for normal text.  */
-  width -= WINDOW_LEFT_MARGIN_COLS (w) + WINDOW_RIGHT_MARGIN_COLS (w);
+Optional argument PIXELWISE non-nil means return the height in pixels.
 
-  if (FRAME_WINDOW_P (f))
-    /* On window-systems, fringes cannot be used for normal text.  */
-    width -= WINDOW_FRINGE_COLS (w);
+The returned height does not include the mode line or header line.  On a
+graphical display, the height is expressed as an integer multiple of the
+default character height if PIXELWISE is nil.
 
-  return width;
+If PIXELWISE is nil and a line at the bottom of the text area is only
+partially visible, that counts as a whole line; to exclude
+partially-visible lines, use `window-text-height'.  */)
+  (Lisp_Object window, Lisp_Object pixelwise)
+{
+  return make_number (window_body_height (decode_live_window (window),
+                                          NILP (pixelwise) ? 0 : 1));
 }
 
-DEFUN ("window-body-height", Fwindow_body_height, Swindow_body_height, 0, 1, 0,
-       doc: /* Return the height, in lines, of WINDOW's text area.
+DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 2, 0,
+       doc: /* Return the width, in columns, of WINDOW's text area.
 WINDOW must be a live window and defaults to the selected one.
 
-The returned height does not include the mode line or header line.
-On a graphical display, the height is expressed as an integer multiple
-of the default character height.  If a line at the bottom of the text
-area is only partially visible, that counts as a whole line; to
-exclude partially-visible lines, use `window-text-height'.  */)
+Optional argument PIXELWISE non-nil means return the width in pixels.
+
+The return value does not include any vertical dividers, fringe or
+marginal areas, or scroll bars.  On a graphical display, the width is
+expressed as an integer multiple of the default character width if
+PIXELWISE is nil.
+
+If PIXELWISE is nil and a column at the right of the text area is only
+partially visible, that counts as a whole column; to exclude
+partially-visible columns, use `window-text-width'.  */)
+  (Lisp_Object window, Lisp_Object pixelwise)
+{
+  return make_number (window_body_width (decode_live_window (window),
+                                         NILP (pixelwise) ? 0 : 1));
+}
+
+DEFUN ("window-mode-line-height", Fwindow_mode_line_height,
+       Swindow_mode_line_height, 0, 1, 0,
+       doc: /* Return the height in pixel of WINDOW's mode-line.
+WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return make_number (window_body_lines (decode_live_window (window)));
+  return (make_number (WINDOW_MODE_LINE_HEIGHT (decode_live_window (window))));
 }
 
-DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
-       doc: /* Return the width, in columns, of WINDOW's text area.
-WINDOW must be a live window and defaults to the selected one.
+DEFUN ("window-header-line-height", Fwindow_header_line_height,
+       Swindow_header_line_height, 0, 1, 0,
+       doc: /* Return the height in pixel of WINDOW's header-line.
+WINDOW must be a live window and defaults to the selected one.  */)
+  (Lisp_Object window)
+{
+  return (make_number (WINDOW_HEADER_LINE_HEIGHT (decode_live_window (window))));
+}
 
-The return value does not include any vertical dividers, fringe or
-marginal areas, or scroll bars.  On a graphical display, the width is
-expressed as an integer multiple of the default character width.  */)
+DEFUN ("window-right-divider-width", Fwindow_right_divider_width,
+       Swindow_right_divider_width, 0, 1, 0,
+       doc: /* Return the width of WINDOW's right divider.
+WINDOW must be a live window and defaults to the selected one.  */)
+  (Lisp_Object window)
+{
+  return (make_number (WINDOW_RIGHT_DIVIDER_WIDTH (decode_live_window (window))));
+}
+
+DEFUN ("window-bottom-divider-width", Fwindow_bottom_divider_width,
+       Swindow_bottom_divider_width, 0, 1, 0,
+       doc: /* Return the width of WINDOW's bottom divider.
+WINDOW must be a live window and defaults to the selected one.  */)
   (Lisp_Object window)
 {
-  return make_number (window_body_cols (decode_live_window (window)));
+  return (make_number (WINDOW_BOTTOM_DIVIDER_WIDTH (decode_live_window (window))));
 }
 
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
@@ -1072,11 +1176,15 @@ display margins, fringes, header line, and/or mode line.  */)
 
 /* Test if the character at column X, row Y is within window W.
    If it is not, return ON_NOTHING;
+   if it is on the window's vertical divider, return
+      ON_RIGHT_DIVIDER;
+   if it is on the window's horizontal divider, return
+      ON_BOTTOM_DIVIDER;
    if it is in the window's text area, return ON_TEXT;
    if it is on the window's modeline, return ON_MODE_LINE;
    if it is on the border between the window and its right sibling,
-      return ON_VERTICAL_BORDER.
-   if it is on a scroll bar, return ON_SCROLL_BAR.
+      return ON_VERTICAL_BORDER;
+   if it is on a scroll bar, return ON_SCROLL_BAR;
    if it is on the window's top line, return ON_HEADER_LINE;
    if it is in left or right fringe of the window,
       return ON_LEFT_FRINGE or ON_RIGHT_FRINGE;
@@ -1104,13 +1212,28 @@ coordinates_in_window (register struct window *w, int x, int y)
   if (y < top_y || y >= bottom_y || x < left_x || x >= right_x)
     return ON_NOTHING;
 
-  /* On the mode line or header line?   */
-  if ((WINDOW_WANTS_MODELINE_P (w)
-       && y >= bottom_y - CURRENT_MODE_LINE_HEIGHT (w)
-       && (part = ON_MODE_LINE))
-      || (WINDOW_WANTS_HEADER_LINE_P (w)
-          && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
-          && (part = ON_HEADER_LINE)))
+  /* On vertical window divider (which prevails horizontal
+     dividers)?  */
+  if (!WINDOW_RIGHTMOST_P (w)
+      && WINDOW_RIGHT_DIVIDER_WIDTH (w)
+      && x >= right_x - WINDOW_RIGHT_DIVIDER_WIDTH (w)
+      && x <= right_x)
+    return ON_RIGHT_DIVIDER;
+  /* On the horizontal window divider?  */
+  else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w)
+           && y >= (bottom_y - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
+           && y <= bottom_y)
+    return ON_BOTTOM_DIVIDER;
+  /* On the mode or header line?   */
+  else if ((WINDOW_WANTS_MODELINE_P (w)
+            && y >= (bottom_y
+                     - CURRENT_MODE_LINE_HEIGHT (w)
+                     - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
+            && y <= bottom_y - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
+            && (part = ON_MODE_LINE))
+           || (WINDOW_WANTS_HEADER_LINE_P (w)
+               && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
+               && (part = ON_HEADER_LINE)))
     {
       /* If it's under/over the scroll bar portion of the mode/header
          line, say it's on the vertical line.  That's to be able to
@@ -1133,7 +1256,7 @@ coordinates_in_window (register struct window *w, int x, int y)
   if (w->pseudo_window_p)
     {
       left_x = 0;
-      right_x = WINDOW_TOTAL_WIDTH (w) - 1;
+      right_x = WINDOW_PIXEL_WIDTH (w) - 1;
     }
   else
     {
@@ -1163,6 +1286,8 @@ coordinates_in_window (register struct window *w, int x, int y)
      terminals, the vertical line's x coordinate is right_x.  */
   else if (!w->pseudo_window_p
            && !WINDOW_RIGHTMOST_P (w)
+           /* Why check ux if we are not the rightmost window?  Also
+              shouldn't a pseudo window always be rightmost?  */
            && x > right_x - ux)
     return ON_VERTICAL_BORDER;
 
@@ -1218,7 +1343,7 @@ window_relative_x_coord (struct window *w, enum window_part part, int x)
     case ON_RIGHT_MARGIN:
       return (x + 1
               - ((w->pseudo_window_p)
-                 ? WINDOW_TOTAL_WIDTH (w)
+                 ? WINDOW_PIXEL_WIDTH (w)
                  : WINDOW_BOX_RIGHT_EDGE_X (w))
               + window_box_width (w, RIGHT_MARGIN_AREA)
               + ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
@@ -1303,6 +1428,12 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
       /* Historically we are supposed to return nil in this case.  */
       return Qnil;
 
+    case ON_RIGHT_DIVIDER:
+      return Qright_divider;
+
+    case ON_BOTTOM_DIVIDER:
+      return Qbottom_divider;
+
     default:
       emacs_abort ();
     }
@@ -1553,7 +1684,7 @@ Return POS.  */)
       set_marker_restricted (w->pointm, pos, w->contents);
       /* We have to make sure that redisplay updates the window to show
          the new value of point.  */
-      windows_or_buffers_changed = 25;
+      wset_redisplay (w);
     }
 
   return pos;
@@ -1574,9 +1705,9 @@ overriding motion of point in order to display at this exact start.  */)
   if (NILP (noforce))
     w->force_start = 1;
   w->update_mode_line = 1;
-  if (w != XWINDOW (selected_window))
-    /* Enforce full redisplay.  FIXME: make it more selective.  */
-    windows_or_buffers_changed = 26;
+  /* Bug#15957.  */
+  w->window_end_valid = 0;
+  wset_redisplay (w);
 
   return pos;
 }
@@ -1995,6 +2126,10 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
 
   if (setflag)
     {
+      n->pixel_left = o->pixel_left;
+      n->pixel_top = o->pixel_top;
+      n->pixel_width = o->pixel_width;
+      n->pixel_height = o->pixel_height;
       n->left_col = o->left_col;
       n->top_line = o->top_line;
       n->total_cols = o->total_cols;
@@ -2075,13 +2210,13 @@ recombine_windows (Lisp_Object window)
               wset_parent (c, parent);
 
               if (horflag)
-                wset_normal_cols (c,
-                                  make_float ((double) c->total_cols
-                                              / (double) p->total_cols));
+                wset_normal_cols
+                  (c, make_float ((double) c->pixel_width
+                                  / (double) p->pixel_width));
               else
-                wset_normal_lines (c,
-                                   make_float ((double) c->total_lines
-                                               / (double) p->total_lines));
+                wset_normal_lines
+                  (c, make_float ((double) c->pixel_height
+                                  / (double) p->pixel_height));
 
               if (NILP (c->next))
                 {
@@ -2137,7 +2272,7 @@ add_window_to_list (struct window *w, void *user_data)
    Vwindow_list is a list, return that list.  Otherwise, build a new
    list, cache it in Vwindow_list, and return that.  */
 
-static Lisp_Object
+Lisp_Object
 window_list (void)
 {
   if (!CONSP (Vwindow_list))
@@ -2712,9 +2847,16 @@ selected frame and no others.  */)
 }
 
 static Lisp_Object
-resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal, Lisp_Object ignore)
+resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal, Lisp_Object ignore, Lisp_Object pixelwise)
 {
-  return call4 (Qwindow_resize_root_window, window, delta, horizontal, ignore);
+  return call5 (Qwindow_resize_root_window, window, delta, horizontal, ignore, pixelwise);
+}
+
+
+static Lisp_Object
+window_pixel_to_total (Lisp_Object frame, Lisp_Object horizontal)
+{
+  return call2(Qwindow_pixel_to_total, frame, horizontal);
 }
 
 
@@ -2778,8 +2920,8 @@ window-start value is reasonable when this function is called.  */)
     {
       startpos = marker_position (w->start);
       startbyte = marker_byte_position (w->start);
-      top = WINDOW_TOP_EDGE_LINE (w)
-        - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w)));
+      top = (WINDOW_TOP_EDGE_LINE (w)
+             - FRAME_TOP_MARGIN (XFRAME (WINDOW_FRAME (w))));
       /* Make sure WINDOW is the frame's selected window.  */
       if (!EQ (window, FRAME_SELECTED_WINDOW (f)))
         {
@@ -2837,7 +2979,7 @@ window-start value is reasonable when this function is called.  */)
     }
   free_window_matrices (r);
 
-  windows_or_buffers_changed = 27;
+  fset_redisplay (f);
   Vwindow_list = Qnil;
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   resize_failed = 0;
@@ -2845,16 +2987,23 @@ window-start value is reasonable when this function is called.  */)
   if (!WINDOW_LEAF_P (w))
     {
       /* Resize child windows vertically.  */
-      XSETINT (delta, r->total_lines - w->total_lines);
+      XSETINT (delta, r->pixel_height - w->pixel_height);
+      w->pixel_top = r->pixel_top;
       w->top_line = r->top_line;
-      resize_root_window (window, delta, Qnil, Qnil);
+      resize_root_window (window, delta, Qnil, Qnil, Qt);
       if (window_resize_check (w, 0))
-        window_resize_apply (w, 0);
+        {
+          window_resize_apply (w, 0);
+          window_pixel_to_total (w->frame, Qnil);
+        }
       else
         {
-          resize_root_window (window, delta, Qnil, Qt);
+          resize_root_window (window, delta, Qnil, Qt, Qt);
           if (window_resize_check (w, 0))
-            window_resize_apply (w, 0);
+            {
+              window_resize_apply (w, 0);
+              window_pixel_to_total (w->frame, Qnil);
+            }
           else
             resize_failed = 1;
         }
@@ -2863,15 +3012,22 @@ window-start value is reasonable when this function is called.  */)
       if (!resize_failed)
         {
           w->left_col = r->left_col;
-          XSETINT (delta, r->total_cols - w->total_cols);
-          resize_root_window (window, delta, Qt, Qnil);
+          w->pixel_left = r->pixel_left;
+          XSETINT (delta, r->pixel_width - w->pixel_width);
+          resize_root_window (window, delta, Qt, Qnil, Qt);
           if (window_resize_check (w, 1))
-            window_resize_apply (w, 1);
+            {
+              window_resize_apply (w, 1);
+              window_pixel_to_total (w->frame, Qt);
+            }
           else
             {
-              resize_root_window (window, delta, Qt, Qt);
+              resize_root_window (window, delta, Qt, Qt, Qt);
               if (window_resize_check (w, 1))
-                window_resize_apply (w, 1);
+                {
+                  window_resize_apply (w, 1);
+                  window_pixel_to_total (w->frame, Qt);
+                }
               else
                 resize_failed = 1;
             }
@@ -2980,27 +3136,46 @@ replace_buffer_in_windows_safely (Lisp_Object buffer)
     }
 }
 
-/* If *ROWS or *COLS are too small a size for FRAME, set them to the
-   minimum allowable size.  */
+/* If *HEIGHT or *WIDTH are too small a size for FRAME, set them to the
+   minimum allowable size.  PIXELWISE means interpret these as pixel
+   sizes.  */
 
 void
-check_frame_size (struct frame *frame, int *rows, int *cols)
+check_frame_size (struct frame *frame, int *width, int *height, bool pixelwise)
 {
   /* For height, we have to see:
      how many windows the frame has at minimum (one or two),
      and whether it has a menu bar or other special stuff at the top.  */
-  int min_height
-    = ((FRAME_MINIBUF_ONLY_P (frame) || ! FRAME_HAS_MINIBUF_P (frame))
-       ? MIN_SAFE_WINDOW_HEIGHT
-       : 2 * MIN_SAFE_WINDOW_HEIGHT);
+  if (pixelwise)
+    {
+      int min_height = MIN_SAFE_WINDOW_HEIGHT * FRAME_LINE_HEIGHT (frame);
+      int min_width = MIN_SAFE_WINDOW_WIDTH * FRAME_COLUMN_WIDTH (frame);
+
+      if (!FRAME_MINIBUF_ONLY_P (frame) && FRAME_HAS_MINIBUF_P (frame))
+        min_height = 2 * min_height;
 
-  if (FRAME_TOP_MARGIN (frame) > 0)
-    min_height += FRAME_TOP_MARGIN (frame);
+      min_height += FRAME_TOP_MARGIN_HEIGHT (frame);
 
-  if (*rows < min_height)
-    *rows = min_height;
-  if (*cols  < MIN_SAFE_WINDOW_WIDTH)
-    *cols = MIN_SAFE_WINDOW_WIDTH;
+      if (*height < min_height)
+        *height = min_height;
+      if (*width < min_width)
+        *width = min_width;
+    }
+  else
+    {
+      int min_height
+        = ((FRAME_MINIBUF_ONLY_P (frame) || ! FRAME_HAS_MINIBUF_P (frame))
+           ? MIN_SAFE_WINDOW_HEIGHT
+           : 2 * MIN_SAFE_WINDOW_HEIGHT);
+
+      if (FRAME_TOP_MARGIN (frame) > 0)
+        min_height += FRAME_TOP_MARGIN (frame);
+
+      if (*height < min_height)
+        *height = min_height;
+      if (*width  < MIN_SAFE_WINDOW_WIDTH)
+        *width = MIN_SAFE_WINDOW_WIDTH;
+    }
 }
 
 /* Adjust the margins of window W if text area is too small.
@@ -3010,31 +3185,37 @@ check_frame_size (struct frame *frame, int *rows, int *cols)
 static int
 adjust_window_margins (struct window *w)
 {
-  int box_cols = (WINDOW_TOTAL_COLS (w)
-                  - WINDOW_FRINGE_COLS (w)
-                  - WINDOW_SCROLL_BAR_COLS (w));
-  int margin_cols = (WINDOW_LEFT_MARGIN_COLS (w)
-                     + WINDOW_RIGHT_MARGIN_COLS (w));
+  int box_width = (WINDOW_PIXEL_WIDTH (w)
+                   - WINDOW_FRINGES_WIDTH (w)
+                   - WINDOW_SCROLL_BAR_AREA_WIDTH (w));
+  int margin_width = WINDOW_MARGINS_WIDTH (w);
 
-  if (box_cols - margin_cols >= MIN_SAFE_WINDOW_WIDTH)
+  if (box_width - margin_width >= MIN_SAFE_WINDOW_PIXEL_WIDTH (w))
     return 1;
 
-  if (margin_cols < 0 || box_cols < MIN_SAFE_WINDOW_WIDTH)
+  if (margin_width < 0 || box_width < MIN_SAFE_WINDOW_PIXEL_WIDTH (w))
     return 0;
-
-  /* Window's text area is too narrow, but reducing the window
-     margins will fix that.  */
-  margin_cols = box_cols - MIN_SAFE_WINDOW_WIDTH;
-  if (WINDOW_RIGHT_MARGIN_COLS (w) > 0)
+  else
+    /* Window's text area is too narrow, but reducing the window
+       margins will fix that.  */
     {
-      if (WINDOW_LEFT_MARGIN_COLS (w) > 0)
-        w->left_margin_cols = w->right_margin_cols = margin_cols / 2;
+      int unit = WINDOW_FRAME_COLUMN_WIDTH (w);
+
+      margin_width = box_width - MIN_SAFE_WINDOW_PIXEL_WIDTH (w);
+
+      if (WINDOW_RIGHT_MARGIN_WIDTH (w) > 0)
+        {
+          if (WINDOW_LEFT_MARGIN_WIDTH (w) > 0)
+            w->left_margin_cols = w->right_margin_cols =
+              margin_width / (2 * unit);
+          else
+            w->right_margin_cols = margin_width / unit;
+        }
       else
-        w->right_margin_cols = margin_cols;
+        w->left_margin_cols = margin_width / unit;
+
+      return 1;
     }
-  else
-    w->left_margin_cols = margin_cols;
-  return 1;
 }
 
 /* The following three routines are needed for running a window's
@@ -3119,11 +3300,23 @@ If FRAME is omitted or nil, it defaults to the selected frame.  */)
   return Qnil;
 }
 
-/* Make WINDOW display BUFFER as its contents.  RUN_HOOKS_P non-zero
-   means it's allowed to run hooks.  See make_frame for a case where
-   it's not allowed.  KEEP_MARGINS_P non-zero means that the current
-   margins, fringes, and scroll-bar settings of the window are not
-   reset from the buffer's local settings.  */
+DEFUN ("run-window-scroll-functions", Frun_window_scroll_functions,
+       Srun_window_scroll_functions, 0, 1, 0,
+       doc: /* Run `window-scroll-functions' for WINDOW.
+If WINDOW is omitted or nil, it defaults to the selected window.  */)
+  (Lisp_Object window)
+{
+  if (! NILP (Vwindow_scroll_functions))
+    run_hook_with_args_2 (Qwindow_scroll_functions, window,
+                          Fmarker_position (decode_live_window (window)->start));
+  return Qnil;
+}
+
+/* Make WINDOW display BUFFER.  RUN_HOOKS_P non-zero means it's allowed
+   to run hooks.  See make_frame for a case where it's not allowed.
+   KEEP_MARGINS_P non-zero means that the current margins, fringes, and
+   scroll-bar settings of the window are not reset from the buffer's
+   local settings.  */
 
 void
 set_window_buffer (Lisp_Object window, Lisp_Object buffer,
@@ -3132,7 +3325,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
   struct window *w = XWINDOW (window);
   struct buffer *b = XBUFFER (buffer);
   ptrdiff_t count = SPECPDL_INDEX ();
-  int samebuf = EQ (buffer, w->contents);
+  bool samebuf = EQ (buffer, w->contents);
 
   wset_buffer (w, buffer);
 
@@ -3171,7 +3364,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
     }
   /* Maybe we could move this into the `if' but it's not obviously safe and
      I doubt it's worth the trouble.  */
-  windows_or_buffers_changed = 28;
+  wset_redisplay (w);
 
   /* We must select BUFFER for running the window-scroll-functions.  */
   /* We can't check ! NILP (Vwindow_scroll_functions) here
@@ -3202,14 +3395,15 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
       if (! NILP (Vwindow_scroll_functions))
         run_hook_with_args_2 (Qwindow_scroll_functions, window,
                               Fmarker_position (w->start));
-      run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
+      if (!samebuf)
+        run_window_configuration_change_hook (XFRAME (WINDOW_FRAME (w)));
     }
 
   unbind_to (count, Qnil);
 }
 
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
-       doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
+       doc: /* Make WINDOW display BUFFER-OR-NAME.
 WINDOW must be a live window and defaults to the selected one.
 BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
 
@@ -3381,6 +3575,8 @@ make_parent_window (Lisp_Object window, bool horflag)
   adjust_window_count (p, 1);
   XSETWINDOW (parent, p);
 
+  p->sequence_number = ++sequence_number;
+
   replace_window (window, parent, 1);
 
   wset_next (o, Qnil);
@@ -3409,6 +3605,7 @@ make_window (void)
   wset_normal_cols (w, make_float (1.0));
   wset_new_total (w, make_number (0));
   wset_new_normal (w, make_number (0));
+  wset_new_pixel (w, make_number (0));
   wset_start (w, Fmake_marker ());
   wset_pointm (w, Fmake_marker ());
   wset_vertical_scroll_bar_type (w, Qt);
@@ -3426,6 +3623,7 @@ make_window (void)
   w->phys_cursor_type = NO_CURSOR;
   w->phys_cursor_width = -1;
 #endif
+  w->sequence_number = ++sequence_number;
   w->scroll_bar_width = -1;
   w->column_number_displayed = -1;
 
@@ -3436,6 +3634,30 @@ make_window (void)
   return window;
 }
 
+DEFUN ("set-window-new-pixel", Fset_window_new_pixel, Sset_window_new_pixel, 2, 3, 0,
+       doc: /* Set new pixel size of WINDOW to SIZE.
+WINDOW must be a valid window and defaults to the selected one.
+Return SIZE.
+
+Optional argument ADD non-nil means add SIZE to the new pixel size of
+WINDOW and return the sum.
+
+Note: This function does not operate on any child windows of WINDOW.  */)
+  (Lisp_Object window, Lisp_Object size, Lisp_Object add)
+{
+  struct window *w = decode_valid_window (window);
+  EMACS_INT size_min = NILP (add) ? 0 : - XINT (w->new_pixel);
+  EMACS_INT size_max = size_min + min (INT_MAX, MOST_POSITIVE_FIXNUM);
+
+  CHECK_RANGED_INTEGER (size, size_min, size_max);
+  if (NILP (add))
+    wset_new_pixel (w, size);
+  else
+    wset_new_pixel (w, make_number (XINT (w->new_pixel) + XINT (size)));
+
+  return w->new_pixel;
+}
+
 DEFUN ("set-window-new-total", Fset_window_new_total, Sset_window_new_total, 2, 3, 0,
        doc: /* Set new total size of WINDOW to SIZE.
 WINDOW must be a valid window and defaults to the selected one.
@@ -3470,8 +3692,8 @@ Note: This function does not operate on any child windows of WINDOW.  */)
   return size;
 }
 
-/* Return 1 if setting w->total_lines (w->total_cols if HORFLAG is
-   non-zero) to w->new_total would result in correct heights (widths)
+/* Return 1 if setting w->pixel_height (w->pixel_width if HORFLAG is
+   non-zero) to w->new_pixel would result in correct heights (widths)
    for window W and recursively all child windows of W.
 
    Note: This function does not check any of `window-fixed-size-p',
@@ -3480,6 +3702,7 @@ Note: This function does not operate on any child windows of WINDOW.  */)
 static int
 window_resize_check (struct window *w, bool horflag)
 {
+  struct frame *f = XFRAME (w->frame);
   struct window *c;
 
   if (WINDOW_VERTICAL_COMBINATION_P (w))
@@ -3491,26 +3714,33 @@ window_resize_check (struct window *w, bool horflag)
         {
           while (c)
             {
-              if ((XINT (c->new_total) != XINT (w->new_total))
+              if (XINT (c->new_pixel) != XINT (w->new_pixel)
                   || !window_resize_check (c, horflag))
                 return 0;
+
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
+
           return 1;
         }
       else
         /* The sum of the heights of the child windows of W must equal
            W's height.  */
         {
-          int sum_of_sizes = 0;
+          int remaining_pixels = XINT (w->new_pixel);
+
           while (c)
             {
               if (!window_resize_check (c, horflag))
                 return 0;
-              sum_of_sizes = sum_of_sizes + XINT (c->new_total);
+
+              remaining_pixels -= XINT (c->new_pixel);
+              if (remaining_pixels < 0)
+                return 0;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
-          return (sum_of_sizes == XINT (w->new_total));
+
+          return remaining_pixels == 0;
         }
     }
   else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
@@ -3521,26 +3751,33 @@ window_resize_check (struct window *w, bool horflag)
         /* The sum of the widths of the child windows of W must equal W's
            width.  */
         {
-          int sum_of_sizes = 0;
+          int remaining_pixels = XINT (w->new_pixel);
+
           while (c)
             {
               if (!window_resize_check (c, horflag))
                 return 0;
-              sum_of_sizes = sum_of_sizes + XINT (c->new_total);
+
+              remaining_pixels -= XINT (c->new_pixel);
+              if (remaining_pixels < 0)
+                return 0;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
-          return (sum_of_sizes == XINT (w->new_total));
+
+          return remaining_pixels == 0;
         }
       else
         /* All child windows of W must have the same height as W.  */
         {
           while (c)
             {
-              if ((XINT (c->new_total) != XINT (w->new_total))
+              if (XINT (c->new_pixel) != XINT (w->new_pixel)
                   || !window_resize_check (c, horflag))
                 return 0;
+
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
+
           return 1;
         }
     }
@@ -3548,12 +3785,15 @@ window_resize_check (struct window *w, bool horflag)
     /* A leaf window.  Make sure it's not too small.  The following
        hardcodes the values of `window-safe-min-width' (2) and
        `window-safe-min-height' (1) which are defined in window.el.  */
-    return XINT (w->new_total) >= (horflag ? 2 : 1);
+    return (XINT (w->new_pixel) >= (horflag
+                                    ? (2 * FRAME_COLUMN_WIDTH (f))
+                                    : FRAME_LINE_HEIGHT (f)));
 }
 
-/* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
-   w->new_total for window W and recursively all child windows of W.
-   Also calculate and assign the new vertical (horizontal) start
+
+/* Set w->pixel_height (w->pixel_height if HORIZONTAL is non-zero) to
+   w->new_pixel for window W and recursively all child windows of W.
+   Also calculate and assign the new vertical (horizontal) pixel start
    positions of each of these windows.
 
    This function does not perform any error checks.  Make sure you have
@@ -3562,25 +3802,30 @@ static void
 window_resize_apply (struct window *w, bool horflag)
 {
   struct window *c;
-  int pos;
+  int edge;
+  int unit = (horflag
+              ? FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w))
+              : FRAME_LINE_HEIGHT (WINDOW_XFRAME (w)));
 
   /* Note: Assigning new_normal requires that the new total size of the
      parent window has been set *before*.  */
   if (horflag)
     {
-      w->total_cols = XFASTINT (w->new_total);
+      w->pixel_width = XFASTINT (w->new_pixel);
+      w->total_cols = w->pixel_width / unit;
       if (NUMBERP (w->new_normal))
         wset_normal_cols (w, w->new_normal);
 
-      pos = w->left_col;
+      edge = w->pixel_left;
     }
   else
     {
-      w->total_lines = XFASTINT (w->new_total);
+      w->pixel_height = XFASTINT (w->new_pixel);
+      w->total_lines = w->pixel_height / unit;
       if (NUMBERP (w->new_normal))
         wset_normal_lines (w, w->new_normal);
 
-      pos = w->top_line;
+      edge = w->pixel_top;
     }
 
   if (WINDOW_VERTICAL_COMBINATION_P (w))
@@ -3590,12 +3835,19 @@ window_resize_apply (struct window *w, bool horflag)
       while (c)
         {
           if (horflag)
-            c->left_col = pos;
+            {
+              c->pixel_left = edge;
+              c->left_col = edge / unit;
+            }
           else
-            c->top_line = pos;
+            {
+              c->pixel_top = edge;
+              c->top_line = edge / unit;
+            }
           window_resize_apply (c, horflag);
           if (!horflag)
-            pos = pos + c->total_lines;
+            edge = edge + c->pixel_height;
+
           c = NILP (c->next) ? 0 : XWINDOW (c->next);
         }
     }
@@ -3606,18 +3858,90 @@ window_resize_apply (struct window *w, bool horflag)
       while (c)
         {
           if (horflag)
-            c->left_col = pos;
+            {
+              c->pixel_left = edge;
+              c->left_col = edge / unit;
+            }
           else
-            c->top_line = pos;
+            {
+              c->pixel_top = edge;
+              c->top_line = edge / unit;
+            }
+
           window_resize_apply (c, horflag);
           if (horflag)
-            pos = pos + c->total_cols;
+            edge = edge + c->pixel_width;
+
           c = NILP (c->next) ? 0 : XWINDOW (c->next);
         }
     }
+  else
+    /* Bug#15957.  */
+    w->window_end_valid = 0;
 }
 
 
+/* Set w->total_lines (w->total_cols if HORIZONTAL is non-zero) to
+   w->new_total for window W and recursively all child windows of W.
+   Also calculate and assign the new vertical (horizontal) start
+   positions of each of these windows.  */
+static void
+window_resize_apply_total (struct window *w, bool horflag)
+{
+  struct window *c;
+  int edge;
+
+  /* Note: Assigning new_normal requires that the new total size of the
+     parent window has been set *before*.  */
+  if (horflag)
+    {
+      w->total_cols = XFASTINT (w->new_total);
+      edge = w->left_col;
+    }
+  else
+    {
+      w->total_lines = XFASTINT (w->new_total);
+      edge = w->top_line;
+    }
+
+  if (WINDOW_VERTICAL_COMBINATION_P (w))
+    /* W is a vertical combination.  */
+    {
+      c = XWINDOW (w->contents);
+      while (c)
+        {
+          if (horflag)
+            c->left_col = edge;
+          else
+            c->top_line = edge;
+
+          window_resize_apply_total (c, horflag);
+          if (!horflag)
+            edge = edge + c->total_lines;
+
+          c = NILP (c->next) ? 0 : XWINDOW (c->next);
+        }
+    }
+  else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
+    /* W is a horizontal combination.  */
+    {
+      c = XWINDOW (w->contents);
+      while (c)
+        {
+          if (horflag)
+            c->left_col = edge;
+          else
+            c->top_line = edge;
+
+          window_resize_apply_total (c, horflag);
+          if (horflag)
+            edge = edge + c->total_cols;
+
+          c = NILP (c->next) ? 0 : XWINDOW (c->next);
+        }
+    }
+}
+
 DEFUN ("window-resize-apply", Fwindow_resize_apply, Swindow_resize_apply, 0, 2, 0,
        doc: /* Apply requested size values for window-tree of FRAME.
 If FRAME is omitted or nil, it defaults to the selected frame.
@@ -3639,20 +3963,44 @@ be applied on the Elisp level.  */)
   bool horflag = !NILP (horizontal);
 
   if (!window_resize_check (r, horflag)
-      || (XINT (r->new_total)
-          != (horflag ? r->total_cols : r->total_lines)))
+      || (XINT (r->new_pixel)
+          != (horflag ? r->pixel_width : r->pixel_height)))
     return Qnil;
 
   block_input ();
   window_resize_apply (r, horflag);
 
-  windows_or_buffers_changed = 30;
+  fset_redisplay (f);
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
   adjust_frame_glyphs (f);
   unblock_input ();
 
-  run_window_configuration_change_hook (f);
+  return Qt;
+}
+
+
+DEFUN ("window-resize-apply-total", Fwindow_resize_apply_total, Swindow_resize_apply_total, 0, 2, 0,
+       doc: /* Apply requested total size values for window-tree of FRAME.
+If FRAME is omitted or nil, it defaults to the selected frame.
+
+This function does not assign pixel or normal size values.  You should
+have run `window-resize-apply' before running this.
+
+Optional argument HORIZONTAL omitted or nil means apply requested
+height values.  HORIZONTAL non-nil means apply requested width
+values.  */)
+     (Lisp_Object frame, Lisp_Object horizontal)
+{
+  struct frame *f = decode_live_frame (frame);
+  struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
+
+  block_input ();
+  /* Necessary when deleting the top-/or leftmost window.  */
+  r->left_col = 0;
+  r->top_line = FRAME_TOP_MARGIN (f);
+  window_resize_apply_total (r, !NILP (horizontal));
+  unblock_input ();
 
   return Qt;
 }
@@ -3660,59 +4008,107 @@ be applied on the Elisp level.  */)
 
 /* Resize frame F's windows when number of lines of F is set to SIZE.
    HORFLAG 1 means resize windows when number of columns of F is set to
-   SIZE.
+   SIZE.  PIXELWISE 1 means to interpret SIZE as pixels.
 
    This function can delete all windows but the selected one in order to
    satisfy the request.  The result will be meaningful if and only if
    F's windows have meaningful sizes when you call this.  */
 void
-resize_frame_windows (struct frame *f, int size, bool horflag)
+resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
 {
   Lisp_Object root = f->root_window;
   struct window *r = XWINDOW (root);
   Lisp_Object mini = f->minibuffer_window;
   struct window *m;
+  /* old_size is the old size of the frame's root window.  */
+  int old_size = horflag ? r->total_cols : r->total_lines;
+  int old_pixel_size = horflag ? r->pixel_width : r->pixel_height;
   /* new_size is the new size of the frame's root window.  */
-  int new_size = (horflag
-                  ? size
-                  : (size
-                     - FRAME_TOP_MARGIN (f)
-                     - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
-                        ? 1 : 0)));
+  int new_size, new_pixel_size;
+
+  if (pixelwise)
+    {
+      new_pixel_size
+        = (horflag
+           ? size
+           : (size
+              - FRAME_TOP_MARGIN_HEIGHT (f)
+              - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
+                 ? FRAME_LINE_HEIGHT (f) : 0)));
+      new_size = new_pixel_size / (horflag
+                                   ? FRAME_COLUMN_WIDTH (f)
+                                   : FRAME_LINE_HEIGHT (f));
+    }
+  else
+    {
+      new_size= (horflag
+                 ? size
+                 : (size
+                    - FRAME_TOP_MARGIN (f)
+                    - ((FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
+                       ? 1 : 0)));
+      new_pixel_size = new_size * (horflag
+                                   ? FRAME_COLUMN_WIDTH (f)
+                                   : FRAME_LINE_HEIGHT (f));
+    }
 
   r->top_line = FRAME_TOP_MARGIN (f);
-  if (WINDOW_LEAF_P (r))
+  r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
+
+  if (new_pixel_size == old_pixel_size)
+    return;
+  else if (WINDOW_LEAF_P (r))
     /* For a leaf root window just set the size.  */
     if (horflag)
-      r->total_cols = new_size;
+      {
+        r->total_cols = new_size;
+        r->pixel_width = new_pixel_size;
+      }
     else
-      r->total_lines = new_size;
+      {
+        r->total_lines = new_size;
+        r->pixel_height = new_pixel_size;
+      }
   else
     {
-      /* old_size is the old size of the frame's root window.  */
-      int old_size = horflag ? r->total_cols : r->total_lines;
       Lisp_Object delta;
 
-      XSETINT (delta, new_size - old_size);
+      if (pixelwise)
+        XSETINT (delta, new_pixel_size - old_pixel_size);
+      else
+        XSETINT (delta, new_size - old_size);
+
       /* Try a "normal" resize first.  */
-      resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil);
+      resize_root_window (root, delta, horflag ? Qt : Qnil, Qnil,
+                          pixelwise ? Qt : Qnil);
       if (window_resize_check (r, horflag)
-          && new_size == XINT (r->new_total))
-        window_resize_apply (r, horflag);
+          && new_pixel_size == XINT (r->new_pixel))
+        {
+          window_resize_apply (r, horflag);
+          window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
+        }
       else
         {
           /* Try with "reasonable" minimum sizes next.  */
-          resize_root_window (root, delta, horflag ? Qt : Qnil, Qt);
+          resize_root_window (root, delta, horflag ? Qt : Qnil, Qt,
+                              pixelwise ? Qt : Qnil);
           if (window_resize_check (r, horflag)
-              && new_size == XINT (r->new_total))
-            window_resize_apply (r, horflag);
+              && new_pixel_size == XINT (r->new_pixel))
+            {
+              window_resize_apply (r, horflag);
+              window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
+            }
           else
             {
               /* Finally, try with "safe" minimum sizes.  */
-              resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe);
+              resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe,
+                                  pixelwise ? Qt : Qnil);
               if (window_resize_check (r, horflag)
-                  && new_size == XINT (r->new_total))
-                window_resize_apply (r, horflag);
+                  && new_pixel_size == XINT (r->new_pixel))
+                {
+                  window_resize_apply (r, horflag);
+                  window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
+                }
               else
                 {
                   /* We lost.  Delete all windows but the frame's
@@ -3720,9 +4116,15 @@ resize_frame_windows (struct frame *f, int size, bool horflag)
                   root = f->selected_window;
                   Fdelete_other_windows_internal (root, Qnil);
                   if (horflag)
-                    XWINDOW (root)->total_cols = new_size;
+                    {
+                      XWINDOW (root)->total_cols = new_size;
+                      XWINDOW (root)->pixel_width = new_pixel_size;
+                    }
                   else
-                    XWINDOW (root)->total_lines = new_size;
+                    {
+                      XWINDOW (root)->total_lines = new_size;
+                      XWINDOW (root)->pixel_height = new_pixel_size;
+                    }
                 }
             }
         }
@@ -3732,42 +4134,47 @@ resize_frame_windows (struct frame *f, int size, bool horflag)
     {
       m = XWINDOW (mini);
       if (horflag)
-        m->total_cols = size;
+        {
+          m->total_cols = size;
+          m->pixel_width = new_pixel_size;
+        }
       else
         {
           /* Are we sure we always want 1 line here?  */
           m->total_lines = 1;
+          m->pixel_height = FRAME_LINE_HEIGHT (f);
           m->top_line = r->top_line + r->total_lines;
+          m->pixel_top = r->pixel_top + r->pixel_height;
         }
     }
 
-  windows_or_buffers_changed = 31;
+  fset_redisplay (f);
 }
 
 
 DEFUN ("split-window-internal", Fsplit_window_internal, Ssplit_window_internal, 4, 4, 0,
        doc: /* Split window OLD.
-Second argument TOTAL-SIZE specifies the number of lines or columns of the
+Second argument PIXEL-SIZE specifies the number of pixels of the
 new window.  In any case TOTAL-SIZE must be a positive integer.
 
 Third argument SIDE nil (or `below') specifies that the new window shall
 be located below WINDOW.  SIDE `above' means the new window shall be
-located above WINDOW.  In both cases TOTAL-SIZE specifies the number of
-lines of the new window including space reserved for the mode and/or
+located above WINDOW.  In both cases PIXEL-SIZE specifies the pixel
+height of the new window including space reserved for the mode and/or
 header line.
 
 SIDE t (or `right') specifies that the new window shall be located on
 the right side of WINDOW.  SIDE `left' means the new window shall be
-located on the left of WINDOW.  In both cases TOTAL-SIZE specifies the
-number of columns of the new window including space reserved for fringes
-and the scrollbar or a divider column.
+located on the left of WINDOW.  In both cases PIXEL-SIZE specifies the
+width of the new window including space reserved for fringes and the
+scrollbar or a divider column.
 
 Fourth argument NORMAL-SIZE specifies the normal size of the new window
 according to the SIDE argument.
 
-The new total and normal sizes of all involved windows must have been
+The new pixel and normal sizes of all involved windows must have been
 set correctly.  See the code of `split-window' for how this is done.  */)
-  (Lisp_Object old, Lisp_Object total_size, Lisp_Object side, Lisp_Object normal_size)
+  (Lisp_Object old, Lisp_Object pixel_size, Lisp_Object side, Lisp_Object normal_size)
 {
   /* OLD (*o) is the window we have to split.  (*p) is either OLD's
      parent window or an internal window we have to install as OLD's new
@@ -3776,19 +4183,24 @@ set correctly.  See the code of `split-window' for how this is done.  */)
      NEW (*n) is the new window created with some parameters taken from
      REFERENCE (*r).  */
   register Lisp_Object new, frame, reference;
-  register struct window *o, *p, *n, *r;
+  register struct window *o, *p, *n, *r, *c;
   struct frame *f;
   bool horflag
     /* HORFLAG is 1 when we split side-by-side, 0 otherwise.  */
     = EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
-  int combination_limit = 0;
+  int combination_limit = 0, sum = 0;
+  int total_size;
 
   CHECK_WINDOW (old);
   o = XWINDOW (old);
   frame = WINDOW_FRAME (o);
   f = XFRAME (frame);
 
-  CHECK_NUMBER (total_size);
+  CHECK_NUMBER (pixel_size);
+  total_size
+    = XINT (pixel_size) / (horflag
+                           ? FRAME_COLUMN_WIDTH (f)
+                           : FRAME_LINE_HEIGHT (f));
 
   /* Set combination_limit to 1 if we have to make a new parent window.
      We do that if either `window-combination-limit' is t, or OLD has no
@@ -3812,7 +4224,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   /* The following bugs are caught by `split-window'.  */
   if (MINI_WINDOW_P (o))
     error ("Attempt to split minibuffer window");
-  else if (XINT (total_size) < (horflag ? 2 : 1))
+  else if (total_size < (horflag ? 2 : 1))
     error ("Size of new window too small (after split)");
   else if (!combination_limit && !NILP (Vwindow_combination_resize))
     /* `window-combination-resize' non-nil means try to resize OLD's siblings
@@ -3820,26 +4232,25 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     {
       p = XWINDOW (o->parent);
       /* Temporarily pretend we split the parent window.  */
-      wset_new_total
-        (p, make_number ((horflag ? p->total_cols : p->total_lines)
-                         - XINT (total_size)));
+      wset_new_pixel
+        (p, make_number ((horflag ? p->pixel_width : p->pixel_height)
+                         - XINT (pixel_size)));
       if (!window_resize_check (p, horflag))
         error ("Window sizes don't fit");
       else
         /* Undo the temporary pretension.  */
-        wset_new_total (p, make_number
-                        (horflag ? p->total_cols : p->total_lines));
+        wset_new_pixel (p, make_number (horflag ? p->pixel_width : p->pixel_height));
     }
   else
     {
       if (!window_resize_check (o, horflag))
         error ("Resizing old window failed");
-      else if (XINT (total_size) + XINT (o->new_total)
-               != (horflag ? o->total_cols : o->total_lines))
+      else if (XINT (pixel_size) + XINT (o->new_pixel)
+               != (horflag ? o->pixel_width : o->pixel_height))
         error ("Sum of sizes of old and new window don't fit");
     }
 
-  /* This is our point of no return. */
+  /* This is our point of no return.  */
   if (combination_limit)
     {
       /* Save the old value of o->normal_cols/lines.  It gets corrupted
@@ -3855,14 +4266,16 @@ set correctly.  See the code of `split-window' for how this is done.  */)
            that its children get merged into another window.  */
         wset_combination_limit (p, Qt);
       /* These get applied below.  */
-      wset_new_total (p, make_number
-                      (horflag ? o->total_cols : o->total_lines));
+      wset_new_pixel
+        (p, make_number (horflag ? o->pixel_width : o->pixel_height));
+      wset_new_total
+        (p, make_number (horflag ? o->total_cols : o->total_lines));
       wset_new_normal (p, new_normal);
     }
   else
     p = XWINDOW (o->parent);
 
-  windows_or_buffers_changed = 32;
+  fset_redisplay (f);
   FRAME_WINDOW_SIZES_CHANGED (f) = 1;
   new = make_window ();
   n = XWINDOW (new);
@@ -3903,18 +4316,33 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   /* Directly assign orthogonal coordinates and sizes.  */
   if (horflag)
     {
+      n->pixel_top = o->pixel_top;
       n->top_line = o->top_line;
+      n->pixel_height = o->pixel_height;
       n->total_lines = o->total_lines;
     }
   else
     {
+      n->pixel_left = o->pixel_left;
       n->left_col = o->left_col;
+      n->pixel_width = o->pixel_width;
       n->total_cols = o->total_cols;
     }
 
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */
-  wset_new_total (n, total_size);
+  wset_new_pixel (n, pixel_size);
+  c = XWINDOW (p->contents);
+  while (c)
+    {
+      if (c != n)
+        sum = sum + XINT (c->new_total);
+      c = NILP (c->next) ? 0 : XWINDOW (c->next);
+    }
+  wset_new_total (n, make_number ((horflag
+                                   ? p->total_cols
+                                   : p->total_lines)
+                                  - sum));
   wset_new_normal (n, normal_size);
 
   block_input ();
@@ -3993,15 +4421,14 @@ Signal an error when WINDOW is the only window on its frame.  */)
     }
 
   if (window_resize_check (r, horflag)
-      && (XINT (r->new_total)
-          == (horflag ? r->total_cols : r->total_lines)))
+      && (XINT (r->new_pixel)
+          == (horflag ? r->pixel_width : r->pixel_height)))
     /* We can delete WINDOW now.  */
     {
 
       /* Block input.  */
       block_input ();
       window_resize_apply (p, horflag);
-
       /* If this window is referred to by the dpyinfo's mouse
          highlight, invalidate that slot to be safe (Bug#9904).  */
       if (!FRAME_INITIAL_P (f))
@@ -4012,7 +4439,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
             hlinfo->mouse_face_window = Qnil;
         }
 
-      windows_or_buffers_changed = 33;
+      fset_redisplay (f);
       Vwindow_list = Qnil;
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
@@ -4112,54 +4539,76 @@ Signal an error when WINDOW is the only window on its frame.  */)
 /* Grow mini-window W by DELTA lines, DELTA >= 0, or as much as we
    can.  */
 void
-grow_mini_window (struct window *w, int delta)
+grow_mini_window (struct window *w, int delta, bool pixelwise)
 {
   struct frame *f = XFRAME (w->frame);
   struct window *r;
-  Lisp_Object root, value;
+  Lisp_Object root, height;
+  int line_height, pixel_height;
 
   eassert (MINI_WINDOW_P (w));
   eassert (delta >= 0);
 
-  root = FRAME_ROOT_WINDOW (f);
-  r = XWINDOW (root);
-  value = call2 (Qwindow_resize_root_window_vertically,
-                 root, make_number (- delta));
-  if (INTEGERP (value) && window_resize_check (r, 0))
+  if (delta > 0)
     {
-      block_input ();
-      window_resize_apply (r, 0);
+      root = FRAME_ROOT_WINDOW (f);
+      r = XWINDOW (root);
+      height = call3 (Qwindow_resize_root_window_vertically,
+                      root, make_number (- delta), pixelwise ? Qt : Qnil);
+      if (INTEGERP (height) && window_resize_check (r, 0))
+        {
+          block_input ();
+          window_resize_apply (r, 0);
 
-      /* Grow the mini-window.  */
-      w->top_line = r->top_line + r->total_lines;
-      w->total_lines -= XINT (value);
-      /* Enforce full redisplay.  FIXME: make it more selective.  */
-      windows_or_buffers_changed = 34;
-      adjust_frame_glyphs (f);
-      unblock_input ();
+          if (pixelwise)
+            {
+              pixel_height = min (-XINT (height), INT_MAX - w->pixel_height);
+              line_height = pixel_height / FRAME_LINE_HEIGHT (f);
+            }
+          else
+            {
+              line_height = min (-XINT (height),
+                                 ((INT_MAX - w->pixel_height)
+                                  / FRAME_LINE_HEIGHT (f)));
+              pixel_height = line_height * FRAME_LINE_HEIGHT (f);
+            }
+
+          /* Grow the mini-window.  */
+          w->pixel_top = r->pixel_top + r->pixel_height;
+          w->top_line = r->top_line + r->total_lines;
+          w->pixel_height += pixel_height;
+          w->total_lines += line_height;
+
+          /* Enforce full redisplay of the frame.  */
+          /* FIXME: Shouldn't window--resize-root-window-vertically do it?  */
+          fset_redisplay (f);
+          adjust_frame_glyphs (f);
+          unblock_input ();
+        }
     }
 }
 
-
-/* Shrink mini-window W.  */
+/* Shrink mini-window W to one line.  */
 void
-shrink_mini_window (struct window *w)
+shrink_mini_window (struct window *w, bool pixelwise)
 {
   struct frame *f = XFRAME (w->frame);
   struct window *r;
-  Lisp_Object root, value;
-  EMACS_INT size;
+  Lisp_Object root, delta;
+  EMACS_INT height, unit;
 
   eassert (MINI_WINDOW_P (w));
 
-  size = w->total_lines;
-  if (size > 1)
+  height = pixelwise ? w->pixel_height : w->total_lines;
+  unit = pixelwise ? FRAME_LINE_HEIGHT (f) : 1;
+  if (height > unit)
     {
       root = FRAME_ROOT_WINDOW (f);
       r = XWINDOW (root);
-      value = call2 (Qwindow_resize_root_window_vertically,
-                     root, make_number (size - 1));
-      if (INTEGERP (value) && window_resize_check (r, 0))
+      delta = call3 (Qwindow_resize_root_window_vertically,
+                     root, make_number (height - unit),
+                     pixelwise ? Qt : Qnil);
+      if (INTEGERP (delta) && window_resize_check (r, 0))
         {
           block_input ();
           window_resize_apply (r, 0);
@@ -4167,8 +4616,11 @@ shrink_mini_window (struct window *w)
           /* Shrink the mini-window.  */
           w->top_line = r->top_line + r->total_lines;
           w->total_lines = 1;
-          /* Enforce full redisplay.  FIXME: make it more selective.  */
-          windows_or_buffers_changed = 35;
+          w->pixel_top = r->pixel_top + r->pixel_height;
+          w->pixel_height = FRAME_LINE_HEIGHT (f);
+          /* Enforce full redisplay of the frame.  */
+          /* FIXME: Shouldn't window--resize-root-window-vertically do it?  */
+          fset_redisplay (f);
           adjust_frame_glyphs (f);
           unblock_input ();
         }
@@ -4197,26 +4649,27 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
     error ("Cannot resize a minibuffer-only frame");
 
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
-  height = r->total_lines + w->total_lines;
+  height = r->pixel_height + w->pixel_height;
   if (window_resize_check (r, 0)
-      && XINT (w->new_total) > 0
-      && height == XINT (r->new_total) + XINT (w->new_total))
+      && XINT (w->new_pixel) > 0
+      && height == XINT (r->new_pixel) + XINT (w->new_pixel))
     {
       block_input ();
       window_resize_apply (r, 0);
 
       w->total_lines = XFASTINT (w->new_total);
       w->top_line = r->top_line + r->total_lines;
+      w->pixel_height = XFASTINT (w->new_pixel);
+      w->pixel_top = r->pixel_top + r->pixel_height;
 
-      windows_or_buffers_changed = 36;
+      fset_redisplay (f);
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
       adjust_frame_glyphs (f);
       unblock_input ();
-
-      run_window_configuration_change_hook (f);
       return Qt;
     }
-  else error ("Failed to resize minibuffer window");
+  else
+    error ("Failed to resize minibuffer window");
 }
 
 /* Mark window cursors off for all windows in the window tree rooted
@@ -4279,6 +4732,8 @@ window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
   immediate_quit = 1;
   n = clip_to_bounds (INT_MIN, n, INT_MAX);
 
+  wset_redisplay (XWINDOW (window));
+
   /* If we must, use the pixel-based version which is much slower than
      the line-based one but can handle varying line heights.  */
   if (FRAME_WINDOW_P (XFRAME (XWINDOW (window)->frame)))
@@ -4286,6 +4741,8 @@ window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
   else
     window_scroll_line_based (window, n, whole, noerror);
 
+  /* Bug#15957.  */
+  XWINDOW (window)->window_end_valid = 0;
   immediate_quit = 0;
 }
 
@@ -4828,9 +5285,6 @@ scroll_command (Lisp_Object n, int direction)
     {
       record_unwind_protect (save_excursion_restore, save_excursion_save ());
       Fset_buffer (XWINDOW (selected_window)->contents);
-
-      /* Make redisplay consider other windows than just selected_window.  */
-      windows_or_buffers_changed = 37;
     }
 
   if (NILP (n))
@@ -4940,7 +5394,6 @@ specifies the window to scroll.  This takes precedence over
 
   /* Don't screw up if window_scroll gets an error.  */
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
-  windows_or_buffers_changed = 38;
 
   Fset_buffer (w->contents);
   SET_PT_BOTH (marker_position (w->pointm), marker_byte_position (w->pointm));
@@ -4976,7 +5429,7 @@ by this function.  This happens in an interactive call.  */)
 {
   struct window *w = XWINDOW (selected_window);
   EMACS_INT requested_arg = (NILP (arg)
-                             ? window_body_cols (w) - 2
+                             ? window_body_width (w, 0) - 2
                              : XINT (Fprefix_numeric_value (arg)));
   Lisp_Object result = set_window_hscroll (w, w->hscroll + requested_arg);
 
@@ -4999,7 +5452,7 @@ by this function.  This happens in an interactive call.  */)
 {
   struct window *w = XWINDOW (selected_window);
   EMACS_INT requested_arg = (NILP (arg)
-                             ? window_body_cols (w) - 2
+                             ? window_body_width (w, 0) - 2
                              : XINT (Fprefix_numeric_value (arg)));
   Lisp_Object result = set_window_hscroll (w, w->hscroll - requested_arg);
 
@@ -5273,22 +5726,36 @@ and redisplay normally--don't erase and redraw the frame.  */)
   return Qnil;
 }
 
-DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
+DEFUN ("window-text-width", Fwindow_text_width, Swindow_text_width,
        0, 1, 0,
-       doc: /* Return the height in lines of the text display area of WINDOW.
+       doc: /* Return the width in columns of the text display area of WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 
-The returned height does not include the mode line, any header line,
-nor any partial-height lines at the bottom of the text area.  */)
+The returned width does not include dividers, scrollbars, margins,
+fringes, nor any partial-width columns at the right of the text
+area.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_live_window (window);
-  int pixel_height = window_box_height (w);
-  int line_height = pixel_height / FRAME_LINE_HEIGHT (XFRAME (w->frame));
-  return make_number (line_height);
+
+  return make_number (window_box_width (w, TEXT_AREA)
+                      / FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w)));
 }
 
+DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
+       0, 1, 0,
+       doc: /* Return the height in lines of the text display area of WINDOW.
+WINDOW must be a live window and defaults to the selected one.
+
+The returned height does not include dividers, the mode line, any header
+line, nor any partial-height lines at the bottom of the text area.  */)
+  (Lisp_Object window)
+{
+  struct window *w = decode_live_window (window);
 
+  return make_number (window_box_height (w)
+                      / FRAME_LINE_HEIGHT (WINDOW_XFRAME (w)));
+}
 
 DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
        1, 1, "P",
@@ -5381,9 +5848,15 @@ struct save_window_data
 
     /* All fields above are traced by the GC.
        From `frame-cols' down, the fields are ignored by the GC.  */
-
-    int frame_cols, frame_lines, frame_menu_bar_lines;
-    int frame_tool_bar_lines;
+    /* We should be able to do without the following two.  */
+    int frame_cols, frame_lines;
+    /* These two should get eventually replaced by their pixel
+       counterparts.  */
+    int frame_menu_bar_lines, frame_tool_bar_lines;
+    int frame_text_width, frame_text_height;
+    /* These are currently unused.  We need them as soon as we convert
+       to pixels.  */
+    int frame_menu_bar_height, frame_tool_bar_height;
   };
 
 /* This is saved as a Lisp_Vector  */
@@ -5392,6 +5865,7 @@ struct saved_window
   struct vectorlike_header header;
 
   Lisp_Object window, buffer, start, pointm, mark;
+  Lisp_Object pixel_left, pixel_top, pixel_height, pixel_width;
   Lisp_Object left_col, top_line, total_cols, total_lines;
   Lisp_Object normal_cols, normal_lines;
   Lisp_Object hscroll, min_hscroll;
@@ -5512,8 +5986,12 @@ the return value is nil.  Otherwise the value is t.  */)
          made, we change the frame to the size specified in the
          configuration, restore the configuration, and then resize it
          back.  We keep track of the prevailing height in these variables.  */
-      int previous_frame_lines = FRAME_LINES (f);
-      int previous_frame_cols =  FRAME_COLS  (f);
+      int previous_frame_text_height = FRAME_TEXT_HEIGHT (f);
+      int previous_frame_text_width =  FRAME_TEXT_WIDTH  (f);
+      /* int previous_frame_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f); */
+      /* int previous_frame_tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f); */
+      /* int previous_frame_lines = FRAME_LINES (f); */
+      /* int previous_frame_cols =  FRAME_COLS  (f); */
       int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
       int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
 
@@ -5536,13 +6014,12 @@ the return value is nil.  Otherwise the value is t.  */)
          if it runs during this.  */
       block_input ();
 
-      if (data->frame_lines != previous_frame_lines
-          || data->frame_cols != previous_frame_cols)
-        change_frame_size (f, data->frame_lines,
-                           data->frame_cols, 0, 0, 0);
-#ifdef HAVE_MENUS
-      if (data->frame_menu_bar_lines
-          != previous_frame_menu_bar_lines)
+      if (data->frame_text_width != previous_frame_text_width
+          || data->frame_text_height != previous_frame_text_height)
+        change_frame_size (f, data->frame_text_width,
+                           data->frame_text_height, 0, 0, 0, 1);
+
+      if (data->frame_menu_bar_lines != previous_frame_menu_bar_lines)
         {
 #ifdef HAVE_WINDOW_SYSTEM
           if (FRAME_WINDOW_P (f))
@@ -5553,10 +6030,8 @@ the return value is nil.  Otherwise the value is t.  */)
             set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
                                 make_number (0));
         }
-#endif
 #ifdef HAVE_WINDOW_SYSTEM
-      if (data->frame_tool_bar_lines
-          != previous_frame_tool_bar_lines)
+      if (data->frame_tool_bar_lines != previous_frame_tool_bar_lines)
         x_set_tool_bar_lines (f, make_number (data->frame_tool_bar_lines),
                               make_number (0));
 #endif
@@ -5575,7 +6050,7 @@ the return value is nil.  Otherwise the value is t.  */)
                            BUF_PT_BYTE (XBUFFER (w->contents)));
         }
 
-      windows_or_buffers_changed = 39;
+      fset_redisplay (f);
       FRAME_WINDOW_SIZES_CHANGED (f) = 1;
 
       /* Problem: Freeing all matrices and later allocating them again
@@ -5628,6 +6103,10 @@ the return value is nil.  Otherwise the value is t.  */)
           /* If we squirreled away the buffer, restore it now.  */
           if (BUFFERP (w->combination_limit))
             wset_buffer (w, w->combination_limit);
+          w->pixel_left = XFASTINT (p->pixel_left);
+          w->pixel_top = XFASTINT (p->pixel_top);
+          w->pixel_width = XFASTINT (p->pixel_width);
+          w->pixel_height = XFASTINT (p->pixel_height);
           w->left_col = XFASTINT (p->left_col);
           w->top_line = XFASTINT (p->top_line);
           w->total_cols = XFASTINT (p->total_cols);
@@ -5728,25 +6207,17 @@ the return value is nil.  Otherwise the value is t.  */)
                                make_number (old_point),
                                XWINDOW (data->current_window)->contents);
 
-      /* In the following call to `select-window', prevent "swapping out
-         point" in the old selected window using the buffer that has
-         been restored into it.  We already swapped out that point from
-         that window's old buffer.  */
-      select_window (data->current_window, Qnil, 1);
-      BVAR (XBUFFER (XWINDOW (selected_window)->contents), last_selected_window)
-        = selected_window;
-
       if (NILP (data->focus_frame)
           || (FRAMEP (data->focus_frame)
               && FRAME_LIVE_P (XFRAME (data->focus_frame))))
         Fredirect_frame_focus (frame, data->focus_frame);
 
-      /* Set the screen height to the value it had before this function.  */
-      if (previous_frame_lines != FRAME_LINES (f)
-          || previous_frame_cols != FRAME_COLS (f))
-        change_frame_size (f, previous_frame_lines, previous_frame_cols,
-                           0, 0, 0);
-#ifdef HAVE_MENUS
+      /* Set the frame size to the value it had before this function.  */
+      if (previous_frame_text_width != FRAME_TEXT_WIDTH (f)
+          || previous_frame_text_height != FRAME_TEXT_HEIGHT (f))
+        change_frame_size (f, previous_frame_text_width,
+                           previous_frame_text_height, 0, 0, 0, 1);
+
       if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
         {
 #ifdef HAVE_WINDOW_SYSTEM
@@ -5759,7 +6230,6 @@ the return value is nil.  Otherwise the value is t.  */)
             set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
                                 make_number (0));
         }
-#endif
 #ifdef HAVE_WINDOW_SYSTEM
       if (previous_frame_tool_bar_lines != FRAME_TOOL_BAR_LINES (f))
         x_set_tool_bar_lines (f, make_number (previous_frame_tool_bar_lines),
@@ -5786,6 +6256,20 @@ the return value is nil.  Otherwise the value is t.  */)
             delete_deletable_window (window);
         }
 
+      /* In the following call to `select-window', prevent "swapping out
+         point" in the old selected window using the buffer that has
+         been restored into it.  We already swapped out that point from
+         that window's old buffer.  */
+      /* This `select_window' calls record_buffer which calls Fdelq which
+         invokes QUIT, so we do it here at the end rather than earlier,
+         to minimize the risk of interrupting the Fset_window_configuration
+         in an inconsistent state (e.g. before frame-focus redirection is
+         canceled).  */
+      select_window (data->current_window, Qnil, 1);
+      BVAR (XBUFFER (XWINDOW (selected_window)->contents),
+            last_selected_window)
+        = selected_window;
+
       /* Fselect_window will have made f the selected frame, so we
          reselect the proper frame here.  Fhandle_switch_frame will change the
          selected window too, but that doesn't make the call to
@@ -5938,6 +6422,10 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
       wset_temslot (w, make_number (i)); i++;
       p->window = window;
       p->buffer = (WINDOW_LEAF_P (w) ? w->contents : Qnil);
+      p->pixel_left = make_number (w->pixel_left);
+      p->pixel_top = make_number (w->pixel_top);
+      p->pixel_width = make_number (w->pixel_width);
+      p->pixel_height = make_number (w->pixel_height);
       p->left_col = make_number (w->left_col);
       p->top_line = make_number (w->top_line);
       p->total_cols = make_number (w->total_cols);
@@ -6077,6 +6565,10 @@ saved by this function.  */)
   data->frame_lines = FRAME_LINES (f);
   data->frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
   data->frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
+  data->frame_text_width = FRAME_TEXT_WIDTH (f);
+  data->frame_text_height = FRAME_TEXT_HEIGHT (f);
+  data->frame_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
+  data->frame_tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
   data->selected_frame = selected_frame;
   data->current_window = FRAME_SELECTED_WINDOW (f);
   XSETBUFFER (data->current_buffer, current_buffer);
@@ -6103,7 +6595,7 @@ apply_window_adjustment (struct window *w)
   adjust_window_margins (w);
   clear_glyph_matrix (w->current_matrix);
   w->window_end_valid = 0;
-  windows_or_buffers_changed = 40;
+  wset_redisplay (w);
   adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
 }
 
@@ -6163,8 +6655,10 @@ as nil.  */)
   (Lisp_Object window)
 {
   struct window *w = decode_live_window (window);
-  return Fcons (w->left_margin_cols ? make_number (w->left_margin_cols) : Qnil,
-                w->right_margin_cols ? make_number (w->right_margin_cols) : Qnil);
+  return Fcons (w->left_margin_cols
+                ? make_number (w->left_margin_cols) : Qnil,
+                w->right_margin_cols
+                ? make_number (w->right_margin_cols) : Qnil);
 }
 
 
@@ -6274,15 +6768,14 @@ DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
        doc: /* Set width and type of scroll bars of window WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 
-Second parameter WIDTH specifies the pixel width for the scroll bar;
-this is automatically adjusted to a multiple of the frame column width.
+Second parameter WIDTH specifies the pixel width for the scroll bar.
 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
 bar: left, right, or nil.
 If WIDTH is nil, use the frame's scroll-bar width.
 If VERTICAL-TYPE is t, use the frame's scroll-bar type.
 Fourth parameter HORIZONTAL-TYPE is currently unused.
 
-Return t if scroll bars was actually changed and nil otherwise.  */)
+Return t if scroll bars were actually changed and nil otherwise.  */)
   (Lisp_Object window, Lisp_Object width,
    Lisp_Object vertical_type, Lisp_Object horizontal_type)
 {
@@ -6477,6 +6970,10 @@ compare_window_configurations (Lisp_Object configuration1,
           != EQ (d2->current_window, sw2->window)
           /* Windows' buffers must match.  */
           || !EQ (sw1->buffer, sw2->buffer)
+          || !EQ (sw1->pixel_left, sw2->pixel_left)
+          || !EQ (sw1->pixel_top, sw2->pixel_top)
+          || !EQ (sw1->pixel_height, sw2->pixel_height)
+          || !EQ (sw1->pixel_width, sw2->pixel_width)
           || !EQ (sw1->left_col, sw2->left_col)
           || !EQ (sw1->top_line, sw2->top_line)
           || !EQ (sw1->total_cols, sw2->total_cols)
@@ -6555,6 +7052,7 @@ syms_of_window (void)
   DEFSYM (Qdelete_window, "delete-window");
   DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
   DEFSYM (Qwindow_resize_root_window_vertically, "window--resize-root-window-vertically");
+  DEFSYM (Qwindow_pixel_to_total, "window--pixel-to-total");
   DEFSYM (Qsafe, "safe");
   DEFSYM (Qdisplay_buffer, "display-buffer");
   DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
@@ -6713,6 +7211,18 @@ Parameters not saved by `current-window-configuration' or
 respectively are not installed by `window-state-put'.  */);
   Vwindow_persistent_parameters = list1 (Fcons (Qclone_of, Qt));
 
+  DEFVAR_BOOL ("window-resize-pixelwise", window_resize_pixelwise,
+               doc: /*  Non-nil means resizing windows works pixelwise.
+Functions currently affected by this option are `split-window',
+`maximize-window', `minimize-window', `fit-window-to-buffer' and
+`fit-frame-to-buffer' and all functions symmetrically resizing a
+parent window.
+
+Note that when a frame's pixel size is not a multiple of the
+frame's character size, at least one window may get resized
+pixelwise even if this option is nil.  */);
+  window_resize_pixelwise = 0;
+
   defsubr (&Sselected_window);
   defsubr (&Sminibuffer_window);
   defsubr (&Swindow_minibuffer_p);
@@ -6735,16 +7245,23 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Swindow_combination_limit);
   defsubr (&Sset_window_combination_limit);
   defsubr (&Swindow_use_time);
-  defsubr (&Swindow_top_line);
-  defsubr (&Swindow_left_column);
-  defsubr (&Swindow_total_height);
+  defsubr (&Swindow_pixel_width);
+  defsubr (&Swindow_pixel_height);
   defsubr (&Swindow_total_width);
+  defsubr (&Swindow_total_height);
   defsubr (&Swindow_normal_size);
+  defsubr (&Swindow_new_pixel);
   defsubr (&Swindow_new_total);
   defsubr (&Swindow_new_normal);
+  defsubr (&Swindow_pixel_left);
+  defsubr (&Swindow_pixel_top);
+  defsubr (&Swindow_left_column);
+  defsubr (&Swindow_top_line);
+  defsubr (&Sset_window_new_pixel);
   defsubr (&Sset_window_new_total);
   defsubr (&Sset_window_new_normal);
   defsubr (&Swindow_resize_apply);
+  defsubr (&Swindow_resize_apply_total);
   defsubr (&Swindow_body_height);
   defsubr (&Swindow_body_width);
   defsubr (&Swindow_hscroll);
@@ -6754,6 +7271,10 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Swindow_edges);
   defsubr (&Swindow_pixel_edges);
   defsubr (&Swindow_absolute_pixel_edges);
+  defsubr (&Swindow_mode_line_height);
+  defsubr (&Swindow_header_line_height);
+  defsubr (&Swindow_right_divider_width);
+  defsubr (&Swindow_bottom_divider_width);
   defsubr (&Swindow_inside_edges);
   defsubr (&Swindow_inside_pixel_edges);
   defsubr (&Swindow_inside_absolute_pixel_edges);
@@ -6776,6 +7297,7 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Sresize_mini_window_internal);
   defsubr (&Sset_window_buffer);
   defsubr (&Srun_window_configuration_change_hook);
+  defsubr (&Srun_window_scroll_functions);
   defsubr (&Sselect_window);
   defsubr (&Sforce_window_update);
   defsubr (&Ssplit_window_internal);
@@ -6787,6 +7309,7 @@ respectively are not installed by `window-state-put'.  */);
   defsubr (&Sscroll_other_window);
   defsubr (&Sminibuffer_selected_window);
   defsubr (&Srecenter);
+  defsubr (&Swindow_text_width);
   defsubr (&Swindow_text_height);
   defsubr (&Smove_to_window_line);
   defsubr (&Swindow_configuration_p);
diff --git a/src/window.h b/src/window.h
index f619b82e8a3..b91161f4d32 100644
--- a/src/window.h
+++ b/src/window.h
@@ -111,6 +111,7 @@ struct window
        to something beyond an integer, so C int can't be used here.  */
     Lisp_Object new_total;
     Lisp_Object new_normal;
+    Lisp_Object new_pixel;
 
     /* May be buffer, window, or nil.  */
     Lisp_Object contents;
@@ -180,14 +181,26 @@ struct window
     /* Number saying how recently window was selected.  */
     int use_time;
 
+    /* Unique number of window assigned when it was created.  */
+    int sequence_number;
+
+    /* The upper left corner pixel coordinates of this window, as
+       integers relative to upper left corner of frame = 0, 0.  */
+    int pixel_left;
+    int pixel_top;
+
     /* The upper left corner coordinates of this window,
        relative to upper left corner of frame = 0, 0.  */
     int left_col;
     int top_line;
 
+    /* The pixel size of the window.  */
+    int pixel_width;
+    int pixel_height;
+
     /* The size of the window.  */
-    int total_lines;
     int total_cols;
+    int total_lines;
 
     /* Number of columns display within the window is scrolled to the left.  */
     ptrdiff_t hscroll;
@@ -337,6 +350,9 @@ struct window
        the frame image that window_end_pos did not get onto the frame.  */
     unsigned window_end_valid : 1;
 
+    /* True if it needs to be redisplayed.  */
+    unsigned redisplay : 1;
+
     /* Amount by which lines of this window are scrolled in
        y-direction (smooth scrolling).  */
     int vscroll;
@@ -344,7 +360,7 @@ struct window
     /* Z_BYTE - buffer position of the last glyph in the current matrix of W.
        Should be nonnegative, and only valid if window_end_valid is nonzero.  */
     ptrdiff_t window_end_bytepos;
-};
+  };
 
 /* Most code should use these functions to set Lisp fields in struct
    window.  */
@@ -353,31 +369,43 @@ wset_frame (struct window *w, Lisp_Object val)
 {
   w->frame = val;
 }
+
 INLINE void
 wset_next (struct window *w, Lisp_Object val)
 {
   w->next = val;
 }
+
 INLINE void
 wset_prev (struct window *w, Lisp_Object val)
 {
   w->prev = val;
 }
+
 INLINE void
 wset_redisplay_end_trigger (struct window *w, Lisp_Object val)
 {
   w->redisplay_end_trigger = val;
 }
+
+INLINE void
+wset_new_pixel (struct window *w, Lisp_Object val)
+{
+  w->new_pixel = val;
+}
+
 INLINE void
 wset_vertical_scroll_bar (struct window *w, Lisp_Object val)
 {
   w->vertical_scroll_bar = val;
 }
+
 INLINE void
 wset_prev_buffers (struct window *w, Lisp_Object val)
 {
   w->prev_buffers = val;
 }
+
 INLINE void
 wset_next_buffers (struct window *w, Lisp_Object val)
 {
@@ -443,38 +471,44 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_FRAME_LINE_HEIGHT(W) \
   (FRAME_LINE_HEIGHT (WINDOW_XFRAME ((W))))
 
-/* Return the width of window W in canonical column units.
+/* Return the pixel width of window W.
    This includes scroll bars and fringes.  */
+#define WINDOW_PIXEL_WIDTH(W) (W)->pixel_width
+
+/* Return the pixel height of window W.
+   This includes header and mode lines, if any.  */
+#define WINDOW_PIXEL_HEIGHT(W) (W)->pixel_height
 
+/* Return the width of window W in canonical column units.
+   This includes scroll bars and fringes.
+   This value is adjusted such that the sum of the widths of all child
+   windows equals the width of their parent window.  */
 #define WINDOW_TOTAL_COLS(W) (W)->total_cols
 
 /* Return the height of window W in canonical line units.
-   This includes header and mode lines, if any.  */
-
+   This includes header and mode lines, if any.
+   This value is adjusted such that the sum of the heights of all child
+   windows equals the height of their parent window.  */
 #define WINDOW_TOTAL_LINES(W) (W)->total_lines
 
-/* Return the total pixel width of window W.  */
-
-#define WINDOW_TOTAL_WIDTH(W) \
-  (WINDOW_TOTAL_COLS (W) * WINDOW_FRAME_COLUMN_WIDTH (W))
-
-/* Return the total pixel height of window W.  */
-
-#define WINDOW_TOTAL_HEIGHT(W) \
-  (WINDOW_TOTAL_LINES (W) * WINDOW_FRAME_LINE_HEIGHT (W))
-
-/* For HORFLAG non-zero the total number of columns of window W.  Otherwise
-   the total number of lines of W.  */
-
-#define WINDOW_TOTAL_SIZE(w, horflag) \
-  (horflag ? WINDOW_TOTAL_COLS (w) : WINDOW_TOTAL_LINES (w))
-
 /* The smallest acceptable dimensions for a window.  Anything smaller
    might crash Emacs.  */
+#define MIN_SAFE_WINDOW_WIDTH (2)
+
+#define MIN_SAFE_WINDOW_PIXEL_WIDTH(W) \
+  (2 * WINDOW_FRAME_COLUMN_WIDTH (W))
 
-#define MIN_SAFE_WINDOW_WIDTH  (2)
 #define MIN_SAFE_WINDOW_HEIGHT (1)
 
+#define MIN_SAFE_WINDOW_PIXEL_HEIGHT(W) \
+  (WINDOW_FRAME_LINE_HEIGHT (W))
+
+/* Width of right divider of window W.  */
+#define WINDOW_RIGHT_DIVIDER_WIDTH(W)                           \
+  ((WINDOW_RIGHTMOST_P (W) || MINI_WINDOW_P (W))                \
+   ? 0                                                          \
+   : FRAME_RIGHT_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
+
 /* Return the canonical frame column at which window W starts.
    This includes a left-hand scroll bar, if any.  */
 
@@ -497,20 +531,37 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_BOTTOM_EDGE_LINE(W) \
   (WINDOW_TOP_EDGE_LINE (W) + WINDOW_TOTAL_LINES (W))
 
+/* Return the left pixel edge at which window W starts.
+   This includes a left-hand scroll bar, if any.  */
+#define WINDOW_LEFT_PIXEL_EDGE(W) (W)->pixel_left
+
+/* Return the right pixel edge before which window W ends.
+   This includes a right-hand scroll bar, if any.  */
+#define WINDOW_RIGHT_PIXEL_EDGE(W) \
+  (WINDOW_LEFT_PIXEL_EDGE (W) + WINDOW_PIXEL_WIDTH (W))
+
+/* Return the top pixel edge at which window W starts.
+   This includes a header line, if any.  */
+#define WINDOW_TOP_PIXEL_EDGE(W) (W)->pixel_top
+
+/* Return the bottom pixel edge before which window W ends.
+   This includes a mode line, if any.  */
+#define WINDOW_BOTTOM_PIXEL_EDGE(W) \
+  (WINDOW_TOP_PIXEL_EDGE (W) + WINDOW_PIXEL_HEIGHT (W))
 
 /* Return the frame x-position at which window W starts.
    This includes a left-hand scroll bar, if any.  */
 
 #define WINDOW_LEFT_EDGE_X(W) \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
-   + WINDOW_LEFT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W))
+   + WINDOW_LEFT_PIXEL_EDGE (W))
 
 /* Return the frame x- position before which window W ends.
    This includes a right-hand scroll bar, if any.  */
 
 #define WINDOW_RIGHT_EDGE_X(W) \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
-   + WINDOW_RIGHT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W))
+   + WINDOW_RIGHT_PIXEL_EDGE (W))
 
 /* 1 if W is a menu bar window.  */
 
@@ -533,37 +584,45 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #endif
 
 /* Return the frame y-position at which window W starts.
-   This includes a header line, if any.  */
+   This includes a header line, if any.
 
+   PXW: With a menu or tool bar this is not symmetric to the _X values
+   since it _does_ include the internal border width.  */
 #define WINDOW_TOP_EDGE_Y(W) \
   (((WINDOW_MENU_BAR_P (W) || WINDOW_TOOL_BAR_P (W)) \
     ? 0 : FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W))) \
-   + WINDOW_TOP_EDGE_LINE (W) * WINDOW_FRAME_LINE_HEIGHT (W))
+   + WINDOW_TOP_PIXEL_EDGE (W))
 
 /* Return the frame y-position before which window W ends.
    This includes a mode line, if any.  */
-
-#define WINDOW_BOTTOM_EDGE_Y(W) \
-  (((WINDOW_MENU_BAR_P (W) || WINDOW_TOOL_BAR_P (W)) \
+#define WINDOW_BOTTOM_EDGE_Y(W)                            \
+  (((WINDOW_MENU_BAR_P (W) || WINDOW_TOOL_BAR_P (W))       \
     ? 0 : FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W))) \
-   + WINDOW_BOTTOM_EDGE_LINE (W) * WINDOW_FRAME_LINE_HEIGHT (W))
-
+   + WINDOW_BOTTOM_PIXEL_EDGE (W))
 
 /* 1 if window W takes up the full width of its frame.  */
-
-#define WINDOW_FULL_WIDTH_P(W) \
-  (WINDOW_TOTAL_COLS (W) == FRAME_TOTAL_COLS (WINDOW_XFRAME (W)))
+#define WINDOW_FULL_WIDTH_P(W)                                  \
+  (WINDOW_PIXEL_WIDTH (W)                                       \
+   == (WINDOW_PIXEL_WIDTH                                       \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
 
 /* 1 if window W's has no other windows to its left in its frame.  */
 
 #define WINDOW_LEFTMOST_P(W) \
-  (WINDOW_LEFT_EDGE_COL (W) == 0)
+  (WINDOW_LEFT_PIXEL_EDGE (W) == 0)
 
 /* 1 if window W's has no other windows to its right in its frame.  */
-
-#define WINDOW_RIGHTMOST_P(W) \
-  (WINDOW_RIGHT_EDGE_COL (W) == FRAME_TOTAL_COLS (WINDOW_XFRAME (W)))
-
+#define WINDOW_RIGHTMOST_P(W)                                   \
+  (WINDOW_RIGHT_PIXEL_EDGE (W)                                  \
+   == (WINDOW_RIGHT_PIXEL_EDGE                                  \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
+
+/* 1 if window W's has no other windows below it in its frame
+   (the minibuffer window is not counted in this respect).  */
+#define WINDOW_BOTTOMMOST_P(W)                                  \
+  (WINDOW_BOTTOM_PIXEL_EDGE (W)                                 \
+   == (WINDOW_BOTTOM_PIXEL_EDGE                                 \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
 
 /* Return the frame column at which the text (or left fringe) in
    window W starts.  This is different from the `LEFT_EDGE' because it
@@ -573,6 +632,13 @@ wset_next_buffers (struct window *w, Lisp_Object val)
   (WINDOW_LEFT_EDGE_COL (W) \
    + WINDOW_LEFT_SCROLL_BAR_COLS (W))
 
+/* Return the pixel value where the text (or left fringe) in
+   window W starts.  This is different from the `LEFT_EDGE' because it
+   does not include a left-hand scroll bar if any.  */
+#define WINDOW_BOX_LEFT_PIXEL_EDGE(W)           \
+  (WINDOW_LEFT_PIXEL_EDGE (W)                   \
+   + WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (W))
+
 /* Return the window column before which the text in window W ends.
    This is different from WINDOW_RIGHT_EDGE_COL because it does not
    include a scroll bar or window-separating line on the right edge.  */
@@ -581,59 +647,72 @@ wset_next_buffers (struct window *w, Lisp_Object val)
   (WINDOW_RIGHT_EDGE_COL (W) \
    - WINDOW_RIGHT_SCROLL_BAR_COLS (W))
 
+/* Return the pixel value before which the text in window W ends.  This
+   is different from the `RIGHT_EDGE' because it does not include a
+   right-hand scroll bar or window-separating line on the right
+   edge.  */
+#define WINDOW_BOX_RIGHT_PIXEL_EDGE(W)          \
+  (WINDOW_RIGHT_PIXEL_EDGE (W)                  \
+   - WINDOW_RIGHT_DIVIDER_WIDTH (W)             \
+   - WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (W))
 
 /* Return the frame position at which the text (or left fringe) in
    window W starts.  This is different from the `LEFT_EDGE' because it
    does not include a left-hand scroll bar if any.  */
-
-#define WINDOW_BOX_LEFT_EDGE_X(W) \
+#define WINDOW_BOX_LEFT_EDGE_X(W)                  \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
-   + WINDOW_BOX_LEFT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W))
+   + WINDOW_BOX_LEFT_PIXEL_EDGE (W))
 
 /* Return the window column before which the text in window W ends.
    This is different from WINDOW_RIGHT_EDGE_COL because it does not
    include a scroll bar or window-separating line on the right edge.  */
-
-#define WINDOW_BOX_RIGHT_EDGE_X(W) \
+#define WINDOW_BOX_RIGHT_EDGE_X(W)                 \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
-   + WINDOW_BOX_RIGHT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W))
-
-
-/* Width of left margin area in columns.  */
+   + WINDOW_BOX_RIGHT_PIXEL_EDGE (W))
 
+/* Widths of marginal areas in columns.  */
 #define WINDOW_LEFT_MARGIN_COLS(W) (W->left_margin_cols)
 
-/* Width of right marginal area in columns.  */
-
 #define WINDOW_RIGHT_MARGIN_COLS(W) (W->right_margin_cols)
 
-/* Width of left margin area in pixels.  */
+#define WINDOW_MARGINS_COLS(W)                  \
+  (WINDOW_LEFT_MARGIN_COLS (W)                  \
+   + WINDOW_RIGHT_MARGIN_COLS (W))
 
+/* Widths of marginal areas in pixels.  */
 #define WINDOW_LEFT_MARGIN_WIDTH(W)                     \
   (W->left_margin_cols * WINDOW_FRAME_COLUMN_WIDTH (W))
 
-/* Width of right marginal area in pixels.  */
-
-#define WINDOW_RIGHT_MARGIN_WIDTH(W)                    \
+#define WINDOW_RIGHT_MARGIN_WIDTH(W)                            \
   (W->right_margin_cols * WINDOW_FRAME_COLUMN_WIDTH (W))
 
-/* Total width of fringes reserved for drawing truncation bitmaps,
-   continuation bitmaps and alike.  The width is in canonical char
-   units of the frame.  This must currently be the case because window
-   sizes aren't pixel values.  If it weren't the case, we wouldn't be
-   able to split windows horizontally nicely.  */
+#define WINDOW_MARGINS_WIDTH(W)                 \
+  (WINDOW_LEFT_MARGIN_WIDTH (W)                 \
+   + WINDOW_RIGHT_MARGIN_WIDTH (W))
 
+/* Pixel-widths of fringes.  */
+#define WINDOW_LEFT_FRINGE_WIDTH(W)                     \
+  (W->left_fringe_width >= 0                            \
+   ? W->left_fringe_width                               \
+   : FRAME_LEFT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
+
+#define WINDOW_RIGHT_FRINGE_WIDTH(W)                    \
+  (W->right_fringe_width >= 0                           \
+   ? W->right_fringe_width                              \
+   : FRAME_RIGHT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
+
+#define WINDOW_FRINGES_WIDTH(W)         \
+  (WINDOW_LEFT_FRINGE_WIDTH (W) + WINDOW_RIGHT_FRINGE_WIDTH (W))
+
+/* Widths of fringes in columns.  */
 #define WINDOW_FRINGE_COLS(W)                   \
   ((W->left_fringe_width >= 0                   \
     && W->right_fringe_width >= 0)              \
-   ? ((W->left_fringe_width                     \
-       + W->right_fringe_width                  \
+   ? ((WINDOW_FRINGES_WIDTH (W)                 \
        + WINDOW_FRAME_COLUMN_WIDTH (W) - 1)     \
       / WINDOW_FRAME_COLUMN_WIDTH (W))          \
    : FRAME_FRINGE_COLS (WINDOW_XFRAME (W)))
 
-/* Column-width of the left and right fringe.  */
-
 #define WINDOW_LEFT_FRINGE_COLS(W)              \
   ((WINDOW_LEFT_FRINGE_WIDTH ((W))              \
     + WINDOW_FRAME_COLUMN_WIDTH (W) - 1)        \
@@ -644,29 +723,12 @@ wset_next_buffers (struct window *w, Lisp_Object val)
     + WINDOW_FRAME_COLUMN_WIDTH (W) - 1)        \
    / WINDOW_FRAME_COLUMN_WIDTH (W))
 
-/* Pixel-width of the left and right fringe.  */
-
-#define WINDOW_LEFT_FRINGE_WIDTH(W)                     \
-  (W->left_fringe_width >= 0 ? W->left_fringe_width     \
-   : FRAME_LEFT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
-
-#define WINDOW_RIGHT_FRINGE_WIDTH(W)                    \
-  (W->right_fringe_width >= 0 ? W->right_fringe_width   \
-   : FRAME_RIGHT_FRINGE_WIDTH (WINDOW_XFRAME (W)))
-
-/* Total width of fringes in pixels.  */
-
-#define WINDOW_TOTAL_FRINGE_WIDTH(W)            \
-  (WINDOW_LEFT_FRINGE_WIDTH (W) + WINDOW_RIGHT_FRINGE_WIDTH (W))
-
 /* Are fringes outside display margins in window W.  */
-
 #define WINDOW_HAS_FRINGES_OUTSIDE_MARGINS(W)   \
   ((W)->fringes_outside_margins)
 
 /* Say whether scroll bars are currently enabled for window W,
    and which side they are on.  */
-
 #define WINDOW_VERTICAL_SCROLL_BAR_TYPE(w)              \
   (EQ (w->vertical_scroll_bar_type, Qt)                 \
    ? FRAME_VERTICAL_SCROLL_BAR_TYPE (WINDOW_XFRAME (w)) \
@@ -694,15 +756,14 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* Width that a scroll bar in window W should have, if there is one.
    Measured in pixels.  If scroll bars are turned off, this is still
    nonzero.  */
-
 #define WINDOW_CONFIG_SCROLL_BAR_WIDTH(w)               \
-  (w->scroll_bar_width >= 0 ? w->scroll_bar_width       \
+  (w->scroll_bar_width >= 0                             \
+   ? w->scroll_bar_width                                \
    : FRAME_CONFIG_SCROLL_BAR_WIDTH (WINDOW_XFRAME (w)))
 
 /* Width that a scroll bar in window W should have, if there is one.
    Measured in columns (characters).  If scroll bars are turned off,
    this is still nonzero.  */
-
 #define WINDOW_CONFIG_SCROLL_BAR_COLS(w)                \
   (w->scroll_bar_width >= 0                             \
    ? ((w->scroll_bar_width                              \
@@ -710,65 +771,64 @@ wset_next_buffers (struct window *w, Lisp_Object val)
       / WINDOW_FRAME_COLUMN_WIDTH (w))                  \
    : FRAME_CONFIG_SCROLL_BAR_COLS (WINDOW_XFRAME (w)))
 
-/* Width of a scroll bar in window W, measured in columns (characters),
-   but only if scroll bars are on the left.  If scroll bars are on
-   the right in this frame, or there are no scroll bars, value is 0.  */
-
+/* Width of left scroll bar in window W, measured in columns
+   (characters).  If scroll bars are on the right in this frame, or
+   there are no scroll bars, value is 0.  */
 #define WINDOW_LEFT_SCROLL_BAR_COLS(w)         \
   (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)  \
    ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w))       \
    : 0)
 
-/* Width of a left scroll bar area in window W , measured in pixels.  */
-
-#define WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH(w)                             \
-  (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)                            \
-   ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \
-   : 0)
-
-/* Width of a scroll bar in window W, measured in columns (characters),
-   but only if scroll bars are on the right.  If scroll bars are on
-   the left in this frame, or there are no scroll bars, value is 0.  */
-
+/* Width of right scroll bar in window W, measured in columns
+   (characters).  If scroll bars are on the left in this frame, or there
+   are no scroll bars, value is 0.  */
 #define WINDOW_RIGHT_SCROLL_BAR_COLS(w)         \
   (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)  \
    ? WINDOW_CONFIG_SCROLL_BAR_COLS (w)          \
    : 0)
 
-/* Width of a left scroll bar area in window W , measured in pixels.  */
-
-#define WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH(w)                            \
-  (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)                           \
-   ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \
-   : 0)
-
-
-/* Actual width of a scroll bar in window W, measured in columns.  */
-
+/* Width of a scroll bar in window W, measured in columns.  */
 #define WINDOW_SCROLL_BAR_COLS(w)              \
   (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)          \
    ? WINDOW_CONFIG_SCROLL_BAR_COLS (w)         \
    : 0)
 
-/* Width of a left scroll bar area in window W , measured in pixels.  */
+/* Width of a left scroll bar area in window W, measured in pixels.  */
+#define WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH(w)                            \
+  (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)                           \
+   ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)                                 \
+   : 0)
 
-#define WINDOW_SCROLL_BAR_AREA_WIDTH(w)                                  \
-  (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)                                    \
-   ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \
+/* Width of a right scroll bar area in window W, measured in pixels.  */
+#define WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH(w)                           \
+  (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)                          \
+   ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)                                 \
    : 0)
 
+/* Width of scroll bar area in window W, measured in pixels.  */
+#define WINDOW_SCROLL_BAR_AREA_WIDTH(w)                                 \
+  (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)                                   \
+   ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)                                 \
+   : 0)
 
 /* Return the frame position where the scroll bar of window W starts.  */
-
 #define WINDOW_SCROLL_BAR_AREA_X(W)             \
   (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (W)  \
    ? WINDOW_BOX_RIGHT_EDGE_X (W)                \
    : WINDOW_LEFT_EDGE_X (W))
 
+/* Width of bottom divider of window W.  */
+#define WINDOW_BOTTOM_DIVIDER_WIDTH(W)                                  \
+  (((WINDOW_BOTTOMMOST_P (W)                                            \
+     && NILP ((XWINDOW (FRAME_ROOT_WINDOW                               \
+                        (WINDOW_XFRAME (W))))->next))                   \
+    || EQ ((W)->prev, FRAME_ROOT_WINDOW (WINDOW_XFRAME (W)))            \
+    || (W)->pseudo_window_p)                                            \
+   ? 0                                                                  \
+   : FRAME_BOTTOM_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
 
 /* Height in pixels, and in lines, of the mode line.
    May be zero if W doesn't have a mode line.  */
-
 #define WINDOW_MODE_LINE_HEIGHT(W)      \
   (WINDOW_WANTS_MODELINE_P ((W))        \
    ? CURRENT_MODE_LINE_HEIGHT (W)       \
@@ -779,7 +839,6 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 
 /* Height in pixels, and in lines, of the header line.
    Zero if W doesn't have a header line.  */
-
 #define WINDOW_HEADER_LINE_HEIGHT(W)    \
   (WINDOW_WANTS_HEADER_LINE_P ((W))     \
    ? CURRENT_HEADER_LINE_HEIGHT (W)     \
@@ -788,43 +847,38 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_HEADER_LINE_LINES(W)     \
   (!! WINDOW_WANTS_HEADER_LINE_P ((W)))
 
-/* Pixel height of window W without mode line.  */
-
+/* Pixel height of window W without mode line and bottom divider.  */
 #define WINDOW_BOX_HEIGHT_NO_MODE_LINE(W)       \
-  (WINDOW_TOTAL_HEIGHT ((W))                    \
+  (WINDOW_PIXEL_HEIGHT ((W))                    \
+   - WINDOW_BOTTOM_DIVIDER_WIDTH (W)            \
    - WINDOW_MODE_LINE_HEIGHT ((W)))
 
-/* Pixel height of window W without mode and header line.  */
-
+/* Pixel height of window W without mode and header line and bottom
+   divider.  */
 #define WINDOW_BOX_TEXT_HEIGHT(W)       \
-  (WINDOW_TOTAL_HEIGHT ((W))            \
+  (WINDOW_PIXEL_HEIGHT ((W))            \
+   - WINDOW_BOTTOM_DIVIDER_WIDTH (W)    \
    - WINDOW_MODE_LINE_HEIGHT ((W))      \
    - WINDOW_HEADER_LINE_HEIGHT ((W)))
 
-
 /* Convert window W relative pixel X to frame pixel coordinates.  */
-
 #define WINDOW_TO_FRAME_PIXEL_X(W, X)   \
   ((X) + WINDOW_BOX_LEFT_EDGE_X ((W)))
 
 /* Convert window W relative pixel Y to frame pixel coordinates.  */
-
 #define WINDOW_TO_FRAME_PIXEL_Y(W, Y)   \
   ((Y) + WINDOW_TOP_EDGE_Y ((W)))
 
 /* Convert frame relative pixel X to window relative pixel X.  */
-
 #define FRAME_TO_WINDOW_PIXEL_X(W, X)   \
   ((X) - WINDOW_BOX_LEFT_EDGE_X ((W)))
 
 /* Convert frame relative pixel Y to window relative pixel Y.  */
-
 #define FRAME_TO_WINDOW_PIXEL_Y(W, Y)   \
   ((Y) - WINDOW_TOP_EDGE_Y ((W)))
 
 /* Convert a text area relative x-position in window W to frame X
    pixel coordinates.  */
-
 #define WINDOW_TEXT_TO_FRAME_PIXEL_X(W, X)      \
   (window_box_left ((W), TEXT_AREA) + (X))
 
@@ -870,18 +924,17 @@ extern Lisp_Object minibuf_selected_window;
 extern Lisp_Object make_window (void);
 extern Lisp_Object window_from_coordinates (struct frame *, int, int,
                                             enum window_part *, bool);
-extern void resize_frame_windows (struct frame *, int, bool);
+extern void resize_frame_windows (struct frame *, int, bool, bool);
 extern void restore_window_configuration (Lisp_Object);
 extern void delete_all_child_windows (Lisp_Object);
-extern void grow_mini_window (struct window *, int);
-extern void shrink_mini_window (struct window *);
+extern void grow_mini_window (struct window *, int, bool);
+extern void shrink_mini_window (struct window *, bool);
 extern int window_relative_x_coord (struct window *, enum window_part, int);
 
 void run_window_configuration_change_hook (struct frame *f);
 
-/* Make WINDOW display BUFFER as its contents.  RUN_HOOKS_P non-zero
-   means it's allowed to run hooks.  See make_frame for a case where
-   it's not allowed.  */
+/* Make WINDOW display BUFFER.  RUN_HOOKS_P non-zero means it's allowed
+   to run hooks.  See make_frame for a case where it's not allowed.  */
 
 void set_window_buffer (Lisp_Object window, Lisp_Object buffer,
                         bool run_hooks_p, bool keep_margins_p);
@@ -900,19 +953,36 @@ extern EMACS_INT command_loop_level;
 
 extern EMACS_INT minibuf_level;
 
-/* true if we should redraw the mode lines on the next redisplay.  */
+/* Non-zero if we should redraw the mode lines on the next redisplay.
+   Usually set to a unique small integer so we can track the main causes of
+   full redisplays in `redisplay--mode-lines-cause'.  */
 
 extern int update_mode_lines;
 
 /* Nonzero if window sizes or contents have changed since last
-   redisplay that finished.  */
+   redisplay that finished.  Usually set to a unique small integer so
+   we can track the main causes of full redisplays in
+   `redisplay--all-windows-cause'.  */
 
 extern int windows_or_buffers_changed;
 
+/* The main redisplay routine usually only redisplays the selected-window,
+   so when something's changed elsewhere, we call one of the functions below
+   to indicate which other windows might also need to be redisplayed.  */
+
+extern void wset_redisplay (struct window *w);
+extern void fset_redisplay (struct frame *f);
+extern void bset_redisplay (struct buffer *b);
+extern void bset_update_mode_line (struct buffer *b);
+/* Call this to tell redisplay to look for other windows than selected-window
+   that need to be redisplayed.  Calling one of the *set_redisplay functions
+   above already does it, so it's only needed in unusual cases.  */
+extern void redisplay_other_windows (void);
+
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
-extern void check_frame_size (struct frame *frame, int *rows, int *cols);
+extern void check_frame_size (struct frame *frame, int *width, int *height, bool pixelwise);
 
 /* Return a pointer to the glyph W's physical cursor is on.  Value is
    null if W's current matrix is invalid, so that no meaningful glyph
@@ -942,12 +1012,13 @@ struct glyph *get_phys_cursor_glyph (struct window *w);
 extern Lisp_Object Qwindow_live_p;
 extern Lisp_Object Vwindow_list;
 
+extern Lisp_Object window_list (void);
 extern struct window *decode_live_window (Lisp_Object);
 extern struct window *decode_any_window (Lisp_Object);
 extern bool compare_window_configurations (Lisp_Object, Lisp_Object, bool);
 extern void mark_window_cursors_off (struct window *);
 extern int window_internal_height (struct window *);
-extern int window_body_cols (struct window *w);
+extern int window_body_width (struct window *w, bool);
 extern void temp_output_buffer_show (Lisp_Object);
 extern void replace_buffer_in_windows (Lisp_Object);
 extern void replace_buffer_in_windows_safely (Lisp_Object);
diff --git a/src/xdisp.c b/src/xdisp.c
index 47855a1de3c..530eae3cb9e 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -502,12 +502,20 @@ static Lisp_Object Vmessage_stack;
 
 static bool message_enable_multibyte;
 
-/* Nonzero if we should redraw the mode lines on the next redisplay.  */
+/* Nonzero if we should redraw the mode lines on the next redisplay.
+   If it has value REDISPLAY_SOME, then only redisplay the mode lines where
+   the `redisplay' bit has been set.  Otherwise, redisplay all mode lines
+   (the number used is then only used to track down the cause for this
+   full-redisplay).  */
 
 int update_mode_lines;
 
-/* Nonzero if window sizes or contents have changed since last
-   redisplay that finished.  */
+/* Nonzero if window sizes or contents other than selected-window have changed
+   since last redisplay that finished.
+   If it has value REDISPLAY_SOME, then only redisplay the windows where
+   the `redisplay' bit has been set.  Otherwise, redisplay all windows
+   (the number used is then only used to track down the cause for this
+   full-redisplay).  */
 
 int windows_or_buffers_changed;
 
@@ -562,7 +570,7 @@ static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
 
 /* Ascent and height of the last line processed by move_it_to.  */
 
-static int last_height;
+static int last_max_ascent, last_height;
 
 /* Non-zero if there's a help-echo in the echo area.  */
 
@@ -599,6 +607,56 @@ bool help_echo_showing_p;
     CACHE = NULL;                               \
   } while (0)
 
+/* Functions to mark elements as needing redisplay.  */
+enum { REDISPLAY_SOME = 2};     /* Arbitrary choice.  */
+
+void
+redisplay_other_windows (void)
+{
+  if (!windows_or_buffers_changed)
+    windows_or_buffers_changed = REDISPLAY_SOME;
+}
+
+void
+wset_redisplay (struct window *w)
+{
+  /* Beware: selected_window can be nil during early stages.  */
+  if (!EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
+    redisplay_other_windows ();
+  w->redisplay = true;
+}
+
+void
+fset_redisplay (struct frame *f)
+{
+  redisplay_other_windows ();
+  f->redisplay = true;
+}
+
+void
+bset_redisplay (struct buffer *b)
+{
+  int count = buffer_window_count (b);
+  if (count > 0)
+    {
+      /* ... it's visible in other window than selected,  */
+      if (count > 1 || b != XBUFFER (XWINDOW (selected_window)->contents))
+        redisplay_other_windows ();
+      /* Even if we don't set windows_or_buffers_changed, do set `redisplay'
+         so that if we later set windows_or_buffers_changed, this buffer will
+         not be omitted.  */
+      b->text->redisplay = true;
+    }
+}
+
+void
+bset_update_mode_line (struct buffer *b)
+{
+  if (!update_mode_lines)
+    update_mode_lines = REDISPLAY_SOME;
+  b->text->redisplay = true;
+}
+
 #ifdef GLYPH_DEBUG
 
 /* Non-zero means print traces of redisplay if compiled with
@@ -779,7 +837,7 @@ static int single_display_spec_string_p (Lisp_Object, Lisp_Object);
 static int display_prop_string_p (Lisp_Object, Lisp_Object);
 static int row_for_charpos_p (struct glyph_row *, ptrdiff_t);
 static int cursor_row_p (struct glyph_row *);
-static int redisplay_mode_lines (Lisp_Object, int);
+static int redisplay_mode_lines (Lisp_Object, bool);
 static char *decode_mode_spec_coding (Lisp_Object, char *, int);
 
 static Lisp_Object get_it_property (struct it *it, Lisp_Object prop);
@@ -833,7 +891,7 @@ static void sync_frame_with_window_matrix_rows (struct window *);
 static void redisplay_internal (void);
 static int echo_area_display (int);
 static void redisplay_windows (Lisp_Object);
-static void redisplay_window (Lisp_Object, int);
+static void redisplay_window (Lisp_Object, bool);
 static Lisp_Object redisplay_window_error (Lisp_Object);
 static Lisp_Object redisplay_window_0 (Lisp_Object);
 static Lisp_Object redisplay_window_1 (Lisp_Object);
@@ -914,6 +972,7 @@ static int in_ellipses_for_invisible_text_p (struct display_pos *,
 static void x_consider_frame_title (Lisp_Object);
 static void update_tool_bar (struct frame *, int);
 static int redisplay_tool_bar (struct frame *);
+static void x_draw_bottom_divider (struct window *w);
 static void notice_overwritten_cursor (struct window *,
                                        enum glyph_row_area,
                                        int, int, int, int);
@@ -942,10 +1001,13 @@ static int coords_in_mouse_face_p (struct window *, int, int);
 int
 window_text_bottom_y (struct window *w)
 {
-  int height = WINDOW_TOTAL_HEIGHT (w);
+  int height = WINDOW_PIXEL_HEIGHT (w);
+
+  height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 
   if (WINDOW_WANTS_MODELINE_P (w))
     height -= CURRENT_MODE_LINE_HEIGHT (w);
+
   return height;
 }
 
@@ -956,32 +1018,23 @@ window_text_bottom_y (struct window *w)
 int
 window_box_width (struct window *w, enum glyph_row_area area)
 {
-  int cols = w->total_cols;
-  int pixels = 0;
+  int pixels = w->pixel_width;
 
   if (!w->pseudo_window_p)
     {
-      cols -= WINDOW_SCROLL_BAR_COLS (w);
+      pixels -= WINDOW_SCROLL_BAR_AREA_WIDTH (w);
+      pixels -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
 
       if (area == TEXT_AREA)
-        {
-          cols -= max (0, w->left_margin_cols);
-          cols -= max (0, w->right_margin_cols);
-          pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
-        }
+        pixels -= (WINDOW_MARGINS_WIDTH (w)
+                   + WINDOW_FRINGES_WIDTH (w));
       else if (area == LEFT_MARGIN_AREA)
-        {
-          cols = max (0, w->left_margin_cols);
-          pixels = 0;
-        }
+        pixels = WINDOW_LEFT_MARGIN_WIDTH (w);
       else if (area == RIGHT_MARGIN_AREA)
-        {
-          cols = max (0, w->right_margin_cols);
-          pixels = 0;
-        }
+        pixels = WINDOW_RIGHT_MARGIN_WIDTH (w);
     }
 
-  return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
+  return pixels;
 }
 
 
@@ -992,10 +1045,12 @@ int
 window_box_height (struct window *w)
 {
   struct frame *f = XFRAME (w->frame);
-  int height = WINDOW_TOTAL_HEIGHT (w);
+  int height = WINDOW_PIXEL_HEIGHT (w);
 
   eassert (height >= 0);
 
+  height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
+
   /* Note: the code below that determines the mode-line/header-line
      height is essentially the same as that contained in the macro
      CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
@@ -1373,7 +1428,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
       if (top_y < window_top_y)
         visible_p = bottom_y > window_top_y;
       else if (top_y < it.last_visible_y)
-        visible_p = 1;
+        visible_p = true;
       if (bottom_y >= it.last_visible_y
           && it.bidi_p && it.bidi_it.scan_dir == -1
           && IT_CHARPOS (it) < charpos)
@@ -1611,7 +1666,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
       if (charpos < IT_CHARPOS (it)
           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
         {
-          visible_p = 1;
+          visible_p = true;
           RESTORE_IT (&it2, &it2, it2data);
           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
           *x = it2.current_x;
@@ -1854,6 +1909,7 @@ pixel_to_glyph_coords (struct frame *f, register int pix_x, register int pix_y,
                            FRAME_COLUMN_WIDTH (f) - 1,
                            FRAME_LINE_HEIGHT (f) - 1);
 
+      /* PXW: Should we clip pixels before converting to columns/lines?  */
       if (!noclip)
         {
           if (pix_x < 0)
@@ -1994,7 +2050,10 @@ get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int
     {
       /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
       r.x = WINDOW_LEFT_EDGE_X (s->w);
-      r.width = WINDOW_TOTAL_WIDTH (s->w);
+      if (s->row->mode_line_p)
+        r.width = WINDOW_PIXEL_WIDTH (s->w) - WINDOW_RIGHT_DIVIDER_WIDTH (s->w);
+      else
+        r.width = WINDOW_PIXEL_WIDTH (s->w);
 
       /* Unless displaying a mode or menu bar line, which are always
          fully visible, clip to the visible part of the row.  */
@@ -2262,9 +2321,14 @@ remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
   /* Try to determine frame pixel position and size of the glyph under
      frame pixel coordinates X/Y on frame F.  */
 
-  if (!f->glyphs_initialized_p
-      || (window = window_from_coordinates (f, gx, gy, &part, 0),
-          NILP (window)))
+  if (window_resize_pixelwise)
+    {
+      width = height = 1;
+      goto virtual_glyph;
+    }
+  else if (!f->glyphs_initialized_p
+           || (window = window_from_coordinates (f, gx, gy, &part, 0),
+               NILP (window)))
     {
       width = FRAME_SMALLEST_CHAR_WIDTH (f);
       height = FRAME_SMALLEST_FONT_HEIGHT (f);
@@ -2751,6 +2815,7 @@ init_iterator (struct it *it, struct window *w,
           && ((!NILP (Vtruncate_partial_width_windows)
                && !INTEGERP (Vtruncate_partial_width_windows))
               || (INTEGERP (Vtruncate_partial_width_windows)
+                  /* PXW: Shall we do something about this?  */
                   && (WINDOW_TOTAL_COLS (it->w)
                       < XINT (Vtruncate_partial_width_windows))))))
     it->line_wrap = TRUNCATE;
@@ -2810,12 +2875,12 @@ init_iterator (struct it *it, struct window *w,
     {
       /* Mode lines, menu bar in terminal frames.  */
       it->first_visible_x = 0;
-      it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
+      it->last_visible_x = WINDOW_PIXEL_WIDTH (w);
     }
   else
     {
-      it->first_visible_x =
-        window_hscroll_limited (it->w, it->f) * FRAME_COLUMN_WIDTH (it->f);
+      it->first_visible_x
+        = window_hscroll_limited (it->w, it->f) * FRAME_COLUMN_WIDTH (it->f);
       it->last_visible_x = (it->first_visible_x
                             + window_box_width (w, TEXT_AREA));
 
@@ -2857,7 +2922,7 @@ init_iterator (struct it *it, struct window *w,
          with a left box line.  */
       face = FACE_FROM_ID (it->f, remapped_base_face_id);
       if (face->box != FACE_NO_BOX)
-        it->start_of_box_run_p = 1;
+        it->start_of_box_run_p = true;
     }
 
   /* If a buffer position was specified, set the iterator there,
@@ -3285,7 +3350,7 @@ handle_stop (struct it *it)
                 pop_it (it);
               else
                 {
-                  it->ignore_overlay_strings_at_pos_p = 1;
+                  it->ignore_overlay_strings_at_pos_p = true;
                   it->string_from_display_prop_p = 0;
                   it->from_disp_prop_p = 0;
                   handle_overlay_change_p = 0;
@@ -4150,13 +4215,13 @@ handle_invisible_prop (struct it *it)
                   prop = Fget_text_property (end_charpos, Qinvisible, it->string);
                   invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
                   if (invis_p == 2)
-                    display_ellipsis_p = 1;
+                    display_ellipsis_p = true;
                 }
             }
           while (invis_p && endpos < len);
 
           if (display_ellipsis_p)
-            it->ellipsis_p = 1;
+            it->ellipsis_p = true;
 
           if (endpos < len)
             {
@@ -4268,9 +4333,9 @@ handle_invisible_prop (struct it *it)
                 tem = next_stop;
 
               /* If there are adjacent invisible texts, don't lose the
-                 second one's ellipsis. */
+                 second one's ellipsis.  */
               if (invis_p == 2)
-                display_ellipsis_p = 1;
+                display_ellipsis_p = true;
             }
           while (invis_p);
 
@@ -4278,10 +4343,10 @@ handle_invisible_prop (struct it *it)
           if (it->bidi_p)
             {
               ptrdiff_t bpos = CHAR_TO_BYTE (newpos);
-              int on_newline =
-                bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n';
-              int after_newline =
-                newpos <= BEGV || FETCH_BYTE (bpos - 1) == '\n';
+              int on_newline
+                = bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n';
+              int after_newline
+                = newpos <= BEGV || FETCH_BYTE (bpos - 1) == '\n';
 
               /* If the invisible text ends on a newline or on a
                  character after a newline, we can avoid the costly,
@@ -4388,7 +4453,7 @@ handle_invisible_prop (struct it *it)
                   it->position.charpos = newpos - 1;
                   it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
                 }
-              it->ellipsis_p = 1;
+              it->ellipsis_p = true;
               /* Let the ellipsis display before
                  considering any properties of the following char.
                  Fixes jasonr@gnu.org 01 Oct 07 bug.  */
@@ -4433,7 +4498,7 @@ setup_for_ellipsis (struct it *it, int len)
     it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
 
   it->method = GET_FROM_DISPLAY_VECTOR;
-  it->ellipsis_p = 1;
+  it->ellipsis_p = true;
 }
 
 
@@ -4902,7 +4967,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
           it->method = GET_FROM_IMAGE;
           it->from_overlay = Qnil;
           it->face_id = face_id;
-          it->from_disp_prop_p = 1;
+          it->from_disp_prop_p = true;
 
           /* Say that we haven't consumed the characters with
              `display' property yet.  The call to pop_it in
@@ -4984,7 +5049,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          when we are finished with the glyph property value.  */
       push_it (it, position);
       it->from_overlay = overlay;
-      it->from_disp_prop_p = 1;
+      it->from_disp_prop_p = true;
 
       if (NILP (location))
         it->area = TEXT_AREA;
@@ -5004,7 +5069,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
           it->stop_charpos = 0;
           it->prev_stop = 0;
           it->base_level_stop = 0;
-          it->string_from_display_prop_p = 1;
+          it->string_from_display_prop_p = true;
           /* Say that we haven't consumed the characters with
              `display' property yet.  The call to pop_it in
              set_iterator_to_next will clean this up.  */
@@ -5370,7 +5435,7 @@ next_overlay_string (struct it *it)
          processed the overlay strings there already, so that
          next_element_from_buffer doesn't try it again.  */
       if (NILP (it->string) && IT_CHARPOS (*it) >= it->end_charpos)
-        it->overlay_strings_at_end_processed_p = 1;
+        it->overlay_strings_at_end_processed_p = true;
     }
   else
     {
@@ -6053,7 +6118,7 @@ forward_to_next_line_start (struct it *it, int *skipped_p,
               if (bidi_it_prev)
                 *bidi_it_prev = bprev;
             }
-          *skipped_p = newline_found_p = 1;
+          *skipped_p = newline_found_p = true;
         }
       else
         {
@@ -6743,9 +6808,9 @@ get_next_display_element (struct it *it)
           if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
             {
               if (c == 0xA0)
-                nonascii_space_p = 1;
+                nonascii_space_p = true;
               else if (c == 0xAD || c == 0x2010 || c == 0x2011)
-                nonascii_hyphen_p = 1;
+                nonascii_hyphen_p = true;
             }
 
           /* Translate control characters into `\003' or `^C' form.
@@ -7204,12 +7269,12 @@ set_iterator_to_next (struct it *it, int reseat_p)
               if (it->method == GET_FROM_STRING
                   && it->current.overlay_string_index >= 0
                   && it->n_overlay_strings > 0)
-                it->ignore_overlay_strings_at_pos_p = 1;
+                it->ignore_overlay_strings_at_pos_p = true;
               it->len = it->dpvec_char_len;
               set_iterator_to_next (it, reseat_p);
             }
 
-          /* Maybe recheck faces after display vector */
+          /* Maybe recheck faces after display vector.  */
           if (recheck_faces)
             it->stop_charpos = IT_CHARPOS (*it);
         }
@@ -7234,7 +7299,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
       else
         {
           /* Not an overlay string.  There could be padding, so test
-             against it->end_charpos . */
+             against it->end_charpos.  */
           if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
             goto consider_string_end;
         }
@@ -7746,7 +7811,7 @@ next_element_from_string (struct it *it)
 static int
 next_element_from_c_string (struct it *it)
 {
-  int success_p = 1;
+  bool success_p = true;
 
   eassert (it->s);
   eassert (!it->bidi_p || it->s == it->bidi_it.string.s);
@@ -7805,7 +7870,7 @@ next_element_from_ellipsis (struct it *it)
       it->method = GET_FROM_BUFFER;
       it->object = it->w->contents;
       reseat_at_next_visible_line_start (it, 1);
-      it->face_before_selective_p = 1;
+      it->face_before_selective_p = true;
     }
 
   return GET_NEXT_DISPLAY_ELEMENT (it);
@@ -7874,7 +7939,7 @@ compute_stop_pos_backwards (struct it *it)
     it->prev_stop = it->stop_charpos;
   else
     it->prev_stop = BEGV;
-  it->bidi_p = 1;
+  it->bidi_p = true;
   it->current = save_current;
   it->position = save_position;
   it->stop_charpos = save_stop_pos;
@@ -7920,7 +7985,7 @@ handle_stop_backwards (struct it *it, ptrdiff_t charpos)
     }
   while (charpos <= where_we_are);
 
-  it->bidi_p = 1;
+  it->bidi_p = true;
   it->current = save_current;
   it->position = save_position;
   next_stop = it->stop_charpos;
@@ -7937,7 +8002,7 @@ handle_stop_backwards (struct it *it, ptrdiff_t charpos)
 static int
 next_element_from_buffer (struct it *it)
 {
-  int success_p = 1;
+  bool success_p = true;
 
   eassert (IT_CHARPOS (*it) >= BEGV);
   eassert (NILP (it->string) && !it->s);
@@ -7967,7 +8032,7 @@ next_element_from_buffer (struct it *it)
             overlay_strings_follow_p = 0;
           else
             {
-              it->overlay_strings_at_end_processed_p = 1;
+              it->overlay_strings_at_end_processed_p = true;
               overlay_strings_follow_p = get_overlay_strings (it, 0);
             }
 
@@ -8787,13 +8852,17 @@ move_it_in_display_line (struct it *it,
 
    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
    screen line, this function will set IT to the next position that is
-   displayed to the right of TO_CHARPOS on the screen.  */
+   displayed to the right of TO_CHARPOS on the screen.
 
-void
+   Return the maximum pixel length of any line scanned but never more
+   than it.last_visible_x.  */
+
+int
 move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op)
 {
   enum move_it_result skip, skip2 = MOVE_X_REACHED;
   int line_height, line_start_x = 0, reached = 0;
+  int max_current_x = 0;
   void *backup_data = NULL;
 
   for (;;)
@@ -8924,6 +8993,9 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
               if (to_y >= it->current_y
                   && to_y < it->current_y + line_height)
                 {
+                  if (to_y > it->current_y)
+                    max_current_x = max (it->current_x, max_current_x);
+
                   /* When word-wrap is on, TO_X may lie past the end
                      of a wrapped line.  Then it->current is the
                      character on the next line, so backtrack to the
@@ -8936,12 +9008,16 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
                       skip = move_it_in_display_line_to
                         (it, -1, prev_x, MOVE_TO_X);
                     }
+
                   reached = 6;
                 }
             }
 
           if (reached)
-            break;
+            {
+              max_current_x = max (it->current_x, max_current_x);
+              break;
+            }
         }
       else if (BUFFERP (it->object)
                && (it->method == GET_FROM_BUFFER
@@ -8961,15 +9037,18 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
       switch (skip)
         {
         case MOVE_POS_MATCH_OR_ZV:
+          max_current_x = max (it->current_x, max_current_x);
           reached = 8;
           goto out;
 
         case MOVE_NEWLINE_OR_CR:
+          max_current_x = max (it->current_x, max_current_x);
           set_iterator_to_next (it, 1);
           it->continuation_lines_width = 0;
           break;
 
         case MOVE_LINE_TRUNCATED:
+          max_current_x = it->last_visible_x;
           it->continuation_lines_width = 0;
           reseat_at_next_visible_line_start (it, 0);
           if ((op & MOVE_TO_POS) != 0
@@ -8981,6 +9060,7 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
           break;
 
         case MOVE_LINE_CONTINUED:
+          max_current_x = it->last_visible_x;
           /* For continued lines ending in a tab, some of the glyphs
              associated with the tab are displayed on the current
              line.  Since it->current_x does not include these glyphs,
@@ -9016,6 +9096,7 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
       it->current_y += it->max_ascent + it->max_descent;
       ++it->vpos;
       last_height = it->max_ascent + it->max_descent;
+      last_max_ascent = it->max_ascent;
       it->max_ascent = it->max_descent = 0;
     }
 
@@ -9042,12 +9123,15 @@ move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos
       it->current_y += it->max_ascent + it->max_descent;
       ++it->vpos;
       last_height = it->max_ascent + it->max_descent;
+      last_max_ascent = it->max_ascent;
     }
 
   if (backup_data)
     bidi_unshelve_cache (backup_data, 1);
 
   TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
+
+  return max_current_x;
 }
 
 
@@ -9395,6 +9479,145 @@ in_display_vector_p (struct it *it)
           && it->dpvec + it->current.dpvec_index != it->dpend);
 }
 
+DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 6, 0,
+       doc: /* Return the size of the text of WINDOW's buffer in pixels.
+WINDOW must be a live window and defaults to the selected one.  The
+return value is a cons of the maximum pixel-width of any text line and
+the maximum pixel-height of all text lines.
+
+The optional argument FROM, if non-nil, specifies the first text
+position and defaults to the minimum accessible position of the buffer.
+If FROM is t, use the minimum accessible position that is not a newline
+character.  TO, if non-nil, specifies the last text position and
+defaults to the maximum accessible position of the buffer.  If TO is t,
+use the maximum accessible position that is not a newline character.
+
+The optional argument X_LIMIT, if non-nil, specifies the maximum text
+width that can be returned.  X_LIMIT nil or omitted, means to use the
+pixel-width of WINDOW's body; use this if you do not intend to change
+the width of WINDOW.  Use the maximum width WINDOW may assume if you
+intend to change WINDOW's width.
+
+The optional argument Y_LIMIT, if non-nil, specifies the maximum text
+height that can be returned.  Text lines whose y-coordinate is beyond
+Y_LIMIT are ignored.  Since calculating the text height of a large
+buffer can take some time, it makes sense to specify this argument if
+the size of the buffer is unknown.
+
+Optional argument MODE_AND_HEADER_LINE nil or omitted means do not
+include the height of the mode- or header-line of WINDOW in the return
+value.  If it is either the symbol `mode-line' or `header-line', include
+only the height of that line, if present, in the return value.  If t,
+include the height of any of these lines in the return value.  */)
+  (Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit, Lisp_Object y_limit,
+   Lisp_Object mode_and_header_line)
+{
+  struct window *w = decode_live_window (window);
+  Lisp_Object buf;
+  struct buffer *b;
+  struct it it;
+  struct buffer *old_buffer = NULL;
+  ptrdiff_t start, end, pos;
+  struct text_pos startp;
+  void *itdata = NULL;
+  int c, max_y = -1, x = 0, y = 0;
+
+  buf = w->contents;
+  CHECK_BUFFER (buf);
+  b = XBUFFER (buf);
+
+  if (b != current_buffer)
+    {
+      old_buffer = current_buffer;
+      set_buffer_internal (b);
+    }
+
+  if (NILP (from))
+    start = BEGV;
+  else if (EQ (from, Qt))
+    {
+      start = pos = BEGV;
+      while ((pos++ < ZV) && (c = FETCH_CHAR (pos))
+             && (c == ' ' || c == '\t' || c == '\n' || c == '\r'))
+        start = pos;
+      while ((pos-- > BEGV) && (c = FETCH_CHAR (pos)) && (c == ' ' || c == '\t'))
+        start = pos;
+    }
+  else
+    {
+      CHECK_NUMBER_COERCE_MARKER (from);
+      start = min (max (XINT (from), BEGV), ZV);
+    }
+
+  if (NILP (to))
+    end = ZV;
+  else if (EQ (to, Qt))
+    {
+      end = pos = ZV;
+      while ((pos-- > BEGV) && (c = FETCH_CHAR (pos))
+             && (c == ' ' || c == '\t' || c == '\n' || c == '\r'))
+        end = pos;
+      while ((pos++ < ZV) && (c = FETCH_CHAR (pos)) && (c == ' ' || c == '\t'))
+        end = pos;
+    }
+  else
+    {
+      CHECK_NUMBER_COERCE_MARKER (to);
+      end = max (start, min (XINT (to), ZV));
+    }
+
+  if (!NILP (y_limit))
+    {
+      CHECK_NUMBER (y_limit);
+      max_y = min (XINT (y_limit), INT_MAX);
+    }
+
+  itdata = bidi_shelve_cache ();
+  SET_TEXT_POS (startp, start, CHAR_TO_BYTE (start));
+  start_display (&it, w, startp);
+
+  /**   move_it_vertically_backward (&it, 0); **/
+  if (NILP (x_limit))
+    x = move_it_to (&it, end, -1, max_y, -1, MOVE_TO_POS | MOVE_TO_Y);
+  else
+    {
+      CHECK_NUMBER (x_limit);
+      it.last_visible_x = min (XINT (x_limit), INFINITY);
+      /* Actually, we never want move_it_to stop at to_x.  But to make
+         sure that move_it_in_display_line_to always moves far enough,
+         we set it to INT_MAX and specify MOVE_TO_X.  */
+      x = move_it_to (&it, end, INT_MAX, max_y, -1,
+                      MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
+    }
+
+  if (start == end)
+    y = it.current_y;
+  else
+    {
+      /* Count last line.  */
+      last_height = 0;
+      y = line_bottom_y (&it); /* - y; */
+    }
+
+  if (!EQ (mode_and_header_line, Qheader_line)
+      && !EQ (mode_and_header_line, Qt))
+    /* Do not count the header-line which was counted automatically by
+       start_display.  */
+    y = y - WINDOW_HEADER_LINE_HEIGHT (w);
+
+  if (EQ (mode_and_header_line, Qmode_line)
+      || EQ (mode_and_header_line, Qt))
+    /* Do count the mode-line which is not included automatically by
+       start_display.  */
+    y = y + WINDOW_MODE_LINE_HEIGHT (w);
+
+  bidi_unshelve_cache (itdata, 0);
+
+  if (old_buffer)
+    set_buffer_internal (old_buffer);
+
+  return Fcons (make_number (x), make_number (y));
+}
 
 /***********************************************************************
                                Messages
@@ -9468,7 +9691,6 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
       ptrdiff_t point_at_end = 0;
       ptrdiff_t zv_at_end = 0;
       Lisp_Object old_deactivate_mark;
-      bool shown;
       struct gcpro gcpro1;
 
       old_deactivate_mark = Vdeactivate_mark;
@@ -9482,8 +9704,8 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
 
         Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
 
-        if (newbuffer &&
-            !NILP (Ffboundp (intern ("messages-buffer-mode"))))
+        if (newbuffer
+            && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
           call0 (intern ("messages-buffer-mode"));
       }
 
@@ -9625,18 +9847,17 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
       unchain_marker (XMARKER (oldbegv));
       unchain_marker (XMARKER (oldzv));
 
-      shown = buffer_window_count (current_buffer) > 0;
-      set_buffer_internal (oldbuf);
       /* We called insert_1_both above with its 5th argument (PREPARE)
          zero, which prevents insert_1_both from calling
          prepare_to_modify_buffer, which in turns prevents us from
          incrementing windows_or_buffers_changed even if *Messages* is
-         shown in some window.  So we must manually incrementing
+         shown in some window.  So we must manually set
          windows_or_buffers_changed here to make up for that.  */
-      if (shown)
-        windows_or_buffers_changed = 41;
-      else
         windows_or_buffers_changed = old_windows_or_buffers_changed;
+      bset_redisplay (current_buffer);
+
+      set_buffer_internal (oldbuf);
+
       message_log_need_newline = !nlflag;
       Vdeactivate_mark = old_deactivate_mark;
     }
@@ -9692,7 +9913,7 @@ message3 (Lisp_Object m)
   struct gcpro gcpro1;
 
   GCPRO1 (m);
-  clear_message (1,1);
+  clear_message (true, true);
   cancel_echoing ();
 
   /* First flush out any partial line written with print.  */
@@ -9762,7 +9983,7 @@ message3_nolog (Lisp_Object m)
           echo_message_buffer = Qnil;
         }
       else
-        clear_message (1, 1);
+        clear_message (true, true);
 
       do_pending_window_change (0);
       echo_area_display (1);
@@ -10035,7 +10256,7 @@ with_echo_area_buffer (struct window *w, int which,
   else
     {
       this_one = 0, the_other = 1;
-      clear_buffer_p = 1;
+      clear_buffer_p = true;
 
       /* We need a fresh one in case the current echo buffer equals
          the one containing the last displayed echo area message.  */
@@ -10052,7 +10273,7 @@ with_echo_area_buffer (struct window *w, int which,
         = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
            ? echo_buffer[the_other]
            : echo_buffer[this_one]);
-      clear_buffer_p = 1;
+      clear_buffer_p = true;
     }
 
   buffer = echo_area_buffer[this_one];
@@ -10325,15 +10546,8 @@ resize_echo_area_exactly (void)
       && WINDOWP (echo_area_window))
     {
       struct window *w = XWINDOW (echo_area_window);
-      int resized_p;
-      Lisp_Object resize_exactly;
-
-      if (minibuf_level == 0)
-        resize_exactly = Qt;
-      else
-        resize_exactly = Qnil;
-
-      resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
+      Lisp_Object resize_exactly = (minibuf_level == 0 ? Qt : Qnil);
+      int resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
                                          (intptr_t) w, resize_exactly);
       if (resized_p)
         {
@@ -10400,11 +10614,10 @@ resize_mini_window (struct window *w, int exact_p)
   if (!FRAME_MINIBUF_ONLY_P (f))
     {
       struct it it;
-      struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
-      int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
-      int height;
-      EMACS_INT max_height;
+      int total_height = (WINDOW_PIXEL_HEIGHT (XWINDOW (FRAME_ROOT_WINDOW (f)))
+                          + WINDOW_PIXEL_HEIGHT (w));
       int unit = FRAME_LINE_HEIGHT (f);
+      int height, max_height;
       struct text_pos start;
       struct buffer *old_current_buffer = NULL;
 
@@ -10418,18 +10631,18 @@ resize_mini_window (struct window *w, int exact_p)
 
       /* Compute the max. number of lines specified by the user.  */
       if (FLOATP (Vmax_mini_window_height))
-        max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
+        max_height = XFLOATINT (Vmax_mini_window_height) * total_height;
       else if (INTEGERP (Vmax_mini_window_height))
-        max_height = XINT (Vmax_mini_window_height);
+        max_height = XINT (Vmax_mini_window_height) * unit;
       else
         max_height = total_height / 4;
 
       /* Correct that max. height if it's bogus.  */
-      max_height = clip_to_bounds (1, max_height, total_height);
+      max_height = clip_to_bounds (unit, max_height, total_height);
 
       /* Find out the height of the text in the window.  */
       if (it.line_wrap == TRUNCATE)
-        height = 1;
+        height = unit;
       else
         {
           last_height = 0;
@@ -10439,7 +10652,6 @@ resize_mini_window (struct window *w, int exact_p)
           else
             height = it.current_y + it.max_ascent + it.max_descent;
           height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
-          height = (height + unit - 1) / unit;
         }
 
       /* Compute a suitable window start.  */
@@ -10447,7 +10659,7 @@ resize_mini_window (struct window *w, int exact_p)
         {
           height = max_height;
           init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
-          move_it_vertically_backward (&it, (height - 1) * unit);
+          move_it_vertically_backward (&it, height);
           start = it.current.pos;
         }
       else
@@ -10458,49 +10670,49 @@ resize_mini_window (struct window *w, int exact_p)
         {
           /* Let it grow only, until we display an empty message, in which
              case the window shrinks again.  */
-          if (height > WINDOW_TOTAL_LINES (w))
+          if (height > WINDOW_PIXEL_HEIGHT (w))
             {
-              int old_height = WINDOW_TOTAL_LINES (w);
+              int old_height = WINDOW_PIXEL_HEIGHT (w);
 
               FRAME_WINDOWS_FROZEN (f) = 1;
-              grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
-              window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
+              grow_mini_window (w, height - WINDOW_PIXEL_HEIGHT (w), 1);
+              window_height_changed_p = WINDOW_PIXEL_HEIGHT (w) != old_height;
             }
-          else if (height < WINDOW_TOTAL_LINES (w)
+          else if (height < WINDOW_PIXEL_HEIGHT (w)
                    && (exact_p || BEGV == ZV))
             {
-              int old_height = WINDOW_TOTAL_LINES (w);
+              int old_height = WINDOW_PIXEL_HEIGHT (w);
 
               FRAME_WINDOWS_FROZEN (f) = 0;
-              shrink_mini_window (w);
-              window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
+              shrink_mini_window (w, 1);
+              window_height_changed_p = WINDOW_PIXEL_HEIGHT (w) != old_height;
             }
         }
       else
         {
           /* Always resize to exact size needed.  */
-          if (height > WINDOW_TOTAL_LINES (w))
+          if (height > WINDOW_PIXEL_HEIGHT (w))
             {
-              int old_height = WINDOW_TOTAL_LINES (w);
+              int old_height = WINDOW_PIXEL_HEIGHT (w);
 
               FRAME_WINDOWS_FROZEN (f) = 1;
-              grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
-              window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
+              grow_mini_window (w, height - WINDOW_PIXEL_HEIGHT (w), 1);
+              window_height_changed_p = WINDOW_PIXEL_HEIGHT (w) != old_height;
             }
-          else if (height < WINDOW_TOTAL_LINES (w))
+          else if (height < WINDOW_PIXEL_HEIGHT (w))
             {
-              int old_height = WINDOW_TOTAL_LINES (w);
+              int old_height = WINDOW_PIXEL_HEIGHT (w);
 
               FRAME_WINDOWS_FROZEN (f) = 0;
-              shrink_mini_window (w);
+              shrink_mini_window (w, 1);
 
               if (height)
                 {
                   FRAME_WINDOWS_FROZEN (f) = 1;
-                  grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
+                  grow_mini_window (w, height - WINDOW_PIXEL_HEIGHT (w), 1);
                 }
 
-              window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
+              window_height_changed_p = WINDOW_PIXEL_HEIGHT (w) != old_height;
             }
         }
 
@@ -10685,12 +10897,12 @@ set_message_1 (ptrdiff_t a1, Lisp_Object string)
    last displayed.  */
 
 void
-clear_message (int current_p, int last_displayed_p)
+clear_message (bool current_p, bool last_displayed_p)
 {
   if (current_p)
     {
       echo_area_buffer[0] = Qnil;
-      message_cleared_p = 1;
+      message_cleared_p = true;
     }
 
   if (last_displayed_p)
@@ -10714,7 +10926,6 @@ clear_garbaged_frames (void)
   if (frame_garbaged)
     {
       Lisp_Object tail, frame;
-      int changed_count = 0;
 
       FOR_EACH_FRAME (tail, frame)
         {
@@ -10726,15 +10937,13 @@ clear_garbaged_frames (void)
                 redraw_frame (f);
               else
                 clear_current_matrices (f);
-              changed_count++;
-              f->garbaged = 0;
-              f->resized_p = 0;
+              fset_redisplay (f);
+              f->garbaged = false;
+              f->resized_p = false;
             }
         }
 
-      frame_garbaged = 0;
-      if (changed_count)
-        windows_or_buffers_changed = 43;
+      frame_garbaged = false;
     }
 }
 
@@ -10775,7 +10984,7 @@ echo_area_display (int update_frame_p)
     {
       echo_area_window = mini_window;
       window_height_changed_p = display_echo_area (w);
-      w->must_be_updated_p = 1;
+      w->must_be_updated_p = true;
 
       /* Update the display, unless called from redisplay_internal.
          Also don't update the screen during redisplay itself.  The
@@ -10791,7 +11000,7 @@ echo_area_display (int update_frame_p)
              been called, so that mode lines above the echo area are
              garbaged.  This looks odd, so we prevent it here.  */
           if (!display_completed)
-            n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), 0);
+            n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
 
           if (window_height_changed_p
               /* Don't do this if Emacs is shutting down.  Redisplay
@@ -10822,11 +11031,11 @@ echo_area_display (int update_frame_p)
              redisplay displays the minibuffer, so that the cursor will
              be replaced with what the minibuffer wants.  */
           if (cursor_in_echo_area)
-            windows_or_buffers_changed = 45;
+            wset_redisplay (XWINDOW (mini_window));
         }
     }
   else if (!EQ (mini_window, selected_window))
-    windows_or_buffers_changed = 46;
+    wset_redisplay (XWINDOW (mini_window));
 
   /* Last displayed message is now the current message.  */
   echo_area_buffer[1] = echo_area_buffer[0];
@@ -10842,16 +11051,6 @@ echo_area_display (int update_frame_p)
   return window_height_changed_p;
 }
 
-/* Nonzero if the current window's buffer is shown in more than one
-   window and was modified since last redisplay.  */
-
-static int
-buffer_shared_and_changed (void)
-{
-  return (buffer_window_count (current_buffer) > 1
-          && UNCHANGED_MODIFIED < MODIFF);
-}
-
 /* Nonzero if W's buffer was changed but not saved.  */
 
 static int
@@ -11164,6 +11363,12 @@ x_consider_frame_title (Lisp_Object frame)
                               Menu Bars
  ***********************************************************************/
 
+/* Non-zero if we will not redisplay all visible windows.  */
+#define REDISPLAY_SOME_P()                              \
+  ((windows_or_buffers_changed == 0                     \
+    || windows_or_buffers_changed == REDISPLAY_SOME)    \
+   && (update_mode_lines == 0                           \
+       || update_mode_lines == REDISPLAY_SOME))
 
 /* Prepare for redisplay by updating menu-bar item lists when
    appropriate.  This can call eval.  */
@@ -11171,9 +11376,9 @@ x_consider_frame_title (Lisp_Object frame)
 static void
 prepare_menu_bars (void)
 {
-  int all_windows;
+  bool all_windows = windows_or_buffers_changed || update_mode_lines;
+  bool some_windows = REDISPLAY_SOME_P ();
   struct gcpro gcpro1, gcpro2;
-  struct frame *f;
   Lisp_Object tooltip_frame;
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -11182,17 +11387,45 @@ prepare_menu_bars (void)
   tooltip_frame = Qnil;
 #endif
 
+  if (FUNCTIONP (Vpre_redisplay_function))
+    {
+      Lisp_Object windows = all_windows ? Qt : Qnil;
+      if (all_windows && some_windows)
+        {
+          Lisp_Object ws = window_list ();
+          for (windows = Qnil; CONSP (ws); ws = XCDR (ws))
+            {
+              Lisp_Object this = XCAR (ws);
+              struct window *w = XWINDOW (this);
+              if (w->redisplay
+                  || XFRAME (w->frame)->redisplay
+                  || XBUFFER (w->contents)->text->redisplay)
+                {
+                  windows = Fcons (this, windows);
+                }
+            }
+        }
+      safe_call1 (Vpre_redisplay_function, windows);
+    }
+
   /* Update all frame titles based on their buffer names, etc.  We do
      this before the menu bars so that the buffer-menu will show the
      up-to-date frame titles.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (windows_or_buffers_changed || update_mode_lines)
+  if (all_windows)
     {
       Lisp_Object tail, frame;
 
       FOR_EACH_FRAME (tail, frame)
         {
-          f = XFRAME (frame);
+          struct frame *f = XFRAME (frame);
+          struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
+          if (some_windows
+              && !f->redisplay
+              && !w->redisplay
+              && !XBUFFER (w->contents)->text->redisplay)
+            continue;
+
           if (!EQ (frame, tooltip_frame)
               && (FRAME_ICONIFIED_P (f)
                   || FRAME_VISIBLE_P (f) == 1
@@ -11213,12 +11446,6 @@ prepare_menu_bars (void)
 
   /* Update the menu bar item lists, if appropriate.  This has to be
      done before any actual redisplay or generation of display lines.  */
-  all_windows = (update_mode_lines
-                 || buffer_shared_and_changed ()
-                 || windows_or_buffers_changed);
-
-  if (FUNCTIONP (Vpre_redisplay_function))
-    safe_call1 (Vpre_redisplay_function, all_windows ? Qt : Qnil);
 
   if (all_windows)
     {
@@ -11232,12 +11459,19 @@ prepare_menu_bars (void)
 
       FOR_EACH_FRAME (tail, frame)
         {
-          f = XFRAME (frame);
+          struct frame *f = XFRAME (frame);
+          struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 
           /* Ignore tooltip frame.  */
           if (EQ (frame, tooltip_frame))
             continue;
 
+          if (some_windows
+              && !f->redisplay
+              && !w->redisplay
+              && !XBUFFER (w->contents)->text->redisplay)
+            continue;
+
           /* If a window on this frame changed size, report that to
              the user and clear the size-change flag.  */
           if (FRAME_WINDOW_SIZES_CHANGED (f))
@@ -11432,8 +11666,8 @@ update_tool_bar (struct frame *f, int save_match_data)
 #if defined (USE_GTK) || defined (HAVE_NS)
   int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
 #else
-  int do_update = WINDOWP (f->tool_bar_window)
-    && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
+  int do_update = (WINDOWP (f->tool_bar_window)
+                   && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tool_bar_window)) > 0);
 #endif
 
   if (do_update)
@@ -11815,7 +12049,8 @@ display_tool_bar_line (struct it *it, int height)
 }
 
 
-/* Max tool-bar height.  */
+/* Max tool-bar height.  Basically, this is what makes all other windows
+   disappear when the frame gets too small.  Rethink this!  */
 
 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
   ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
@@ -11825,11 +12060,11 @@ display_tool_bar_line (struct it *it, int height)
    returned in *N_ROWS if non-NULL.  */
 
 static int
-tool_bar_lines_needed (struct frame *f, int *n_rows)
+tool_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 {
   struct window *w = XWINDOW (f->tool_bar_window);
   struct it it;
-  /* tool_bar_lines_needed is called from redisplay_tool_bar after building
+  /* tool_bar_height is called from redisplay_tool_bar after building
      the desired matrix, so use (unused) mode-line row as temporary row to
      avoid destroying the first tool-bar row.  */
   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
@@ -11838,6 +12073,7 @@ tool_bar_lines_needed (struct frame *f, int *n_rows)
      F->desired_tool_bar_string in the tool-bar window of frame F.  */
   init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
   it.first_visible_x = 0;
+  /* PXW: Use FRAME_PIXEL_WIDTH (f) here?  */
   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
   reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
   it.paragraph_embedding = L2R;
@@ -11854,39 +12090,44 @@ tool_bar_lines_needed (struct frame *f, int *n_rows)
   if (n_rows)
     *n_rows = it.vpos > 0 ? it.vpos : -1;
 
-  return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
+  if (pixelwise)
+    return it.current_y;
+  else
+    return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 }
 
 #endif /* !USE_GTK && !HAVE_NS */
 
 #if defined USE_GTK || defined HAVE_NS
+EXFUN (Ftool_bar_height, 2) ATTRIBUTE_CONST;
 EXFUN (Ftool_bar_lines_needed, 1) ATTRIBUTE_CONST;
 #endif
 
-DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
-       0, 1, 0,
+DEFUN ("tool-bar-height", Ftool_bar_height, Stool_bar_height,
+       0, 2, 0,
        doc: /* Return the number of lines occupied by the tool bar of FRAME.
-If FRAME is nil or omitted, use the selected frame.  */)
-  (Lisp_Object frame)
+If FRAME is nil or omitted, use the selected frame.  Optional argument
+PIXELWISE non-nil means return the height of the tool bar inpixels.  */)
+  (Lisp_Object frame, Lisp_Object pixelwise)
 {
-  int nlines = 0;
+  int height = 0;
+
 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
   struct frame *f = decode_any_frame (frame);
-  struct window *w;
 
   if (WINDOWP (f->tool_bar_window)
-      && (w = XWINDOW (f->tool_bar_window),
-          WINDOW_TOTAL_LINES (w) > 0))
+      && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tool_bar_window)) > 0)
     {
       update_tool_bar (f, 1);
       if (f->n_tool_bar_items)
         {
           build_desired_tool_bar_string (f);
-          nlines = tool_bar_lines_needed (f, NULL);
+          height = tool_bar_height (f, NULL, NILP (pixelwise) ? 0 : 1);
         }
     }
 #endif
-  return make_number (nlines);
+
+  return make_number (height);
 }
 
 
@@ -11914,13 +12155,13 @@ redisplay_tool_bar (struct frame *f)
      can turn off tool-bars by specifying tool-bar-lines zero.  */
   if (!WINDOWP (f->tool_bar_window)
       || (w = XWINDOW (f->tool_bar_window),
-          WINDOW_TOTAL_LINES (w) == 0))
+          WINDOW_PIXEL_HEIGHT (w) == 0))
     return 0;
 
   /* Set up an iterator for the tool-bar window.  */
   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
   it.first_visible_x = 0;
-  it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
+  it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
   row = it.glyph_row;
 
   /* Build a string that represents the contents of the tool-bar.  */
@@ -11937,24 +12178,22 @@ redisplay_tool_bar (struct frame *f)
 
   if (f->n_tool_bar_rows == 0)
     {
-      int nlines;
+      int new_height = tool_bar_height (f, &f->n_tool_bar_rows, 1);
 
-      if ((nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows),
-           nlines != WINDOW_TOTAL_LINES (w)))
+      if (new_height != WINDOW_PIXEL_HEIGHT (w))
         {
           Lisp_Object frame;
-          int old_height = WINDOW_TOTAL_LINES (w);
+          int new_lines = ((new_height + FRAME_LINE_HEIGHT (f) - 1)
+                           / FRAME_LINE_HEIGHT (f));
 
           XSETFRAME (frame, f);
           Fmodify_frame_parameters (frame,
                                     list1 (Fcons (Qtool_bar_lines,
-                                                  make_number (nlines))));
-          if (WINDOW_TOTAL_LINES (w) != old_height)
-            {
-              clear_glyph_matrix (w->desired_matrix);
-              f->fonts_changed = 1;
-              return 1;
-            }
+                                                  make_number (new_lines))));
+          /* Always do that now.  */
+          clear_glyph_matrix (w->desired_matrix);
+          f->fonts_changed = 1;
+          return 1;
         }
     }
 
@@ -12003,6 +12242,7 @@ redisplay_tool_bar (struct frame *f)
 
   if (!NILP (Vauto_resize_tool_bars))
     {
+      /* Do we really allow the toolbar to occupy the whole frame?  */
       int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f);
       int change_height_p = 0;
 
@@ -12033,29 +12273,29 @@ redisplay_tool_bar (struct frame *f)
       if (change_height_p)
         {
           Lisp_Object frame;
-          int old_height = WINDOW_TOTAL_LINES (w);
           int nrows;
-          int nlines = tool_bar_lines_needed (f, &nrows);
+          int new_height = tool_bar_height (f, &nrows, 1);
 
           change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
                               && !f->minimize_tool_bar_window_p)
-                             ? (nlines > old_height)
-                             : (nlines != old_height));
+                             ? (new_height > WINDOW_PIXEL_HEIGHT (w))
+                             : (new_height != WINDOW_PIXEL_HEIGHT (w)));
           f->minimize_tool_bar_window_p = 0;
 
           if (change_height_p)
             {
+              int new_lines = ((new_height + FRAME_LINE_HEIGHT (f) - 1)
+                               / FRAME_LINE_HEIGHT (f));
+
               XSETFRAME (frame, f);
               Fmodify_frame_parameters (frame,
                                         list1 (Fcons (Qtool_bar_lines,
-                                                      make_number (nlines))));
-              if (WINDOW_TOTAL_LINES (w) != old_height)
-                {
-                  clear_glyph_matrix (w->desired_matrix);
-                  f->n_tool_bar_rows = nrows;
-                  f->fonts_changed = 1;
-                  return 1;
-                }
+                                                      make_number (new_lines))));
+              /* Always do that now.  */
+              clear_glyph_matrix (w->desired_matrix);
+              f->n_tool_bar_rows = nrows;
+              f->fonts_changed = 1;
+              return 1;
             }
         }
     }
@@ -12384,7 +12624,7 @@ hscroll_window_tree (Lisp_Object window)
               /* For left-to-right rows, hscroll when cursor is either
                  (i) inside the right hscroll margin, or (ii) if it is
                  inside the left margin and the window is already
-                 hscrolled. */
+                 hscrolled.  */
               && ((!row_r2l_p
                    && ((w->hscroll
                         && w->cursor.x <= h_margin)
@@ -12401,7 +12641,7 @@ hscroll_window_tree (Lisp_Object window)
                       && ((cursor_row->enabled_p
                            /* FIXME: It is confusing to set the
                               truncated_on_right_p flag when R2L rows
-                              are actually truncated on the left. */
+                              are actually truncated on the left.  */
                            && cursor_row->truncated_on_right_p
                            && w->cursor.x <= h_margin)
                           || (w->hscroll
@@ -12860,6 +13100,28 @@ reconsider_clip_changes (struct window *w)
     }
 }
 
+static void
+propagate_buffer_redisplay (void)
+{ /* Resetting b->text->redisplay is problematic!
+     We can't just reset it in the case that some window that displays
+     it has not been redisplayed; and such a window can stay
+     unredisplayed for a long time if it's currently invisible.
+     But we do want to reset it at the end of redisplay otherwise
+     its displayed windows will keep being redisplayed over and over
+     again.
+     So we copy all b->text->redisplay flags up to their windows here,
+     such that mark_window_display_accurate can safely reset
+     b->text->redisplay.  */
+  Lisp_Object ws = window_list ();
+  for (; CONSP (ws); ws = XCDR (ws))
+    {
+      struct window *thisw = XWINDOW (XCAR (ws));
+      struct buffer *thisb = XBUFFER (thisw->contents);
+      if (thisb->text->redisplay)
+        thisw->redisplay = true;
+    }
+}
+
 #define STOP_POLLING                                    \
 do { if (! polling_stopped_here) stop_polling ();       \
        polling_stopped_here = 1; } while (0)
@@ -12956,7 +13218,6 @@ redisplay_internal (void)
       /* Since frames on a single ASCII terminal share the same
          display area, displaying a different frame means redisplay
          the whole thing.  */
-      windows_or_buffers_changed = 48;
       SET_FRAME_GARBAGED (sf);
 #ifndef DOS_NT
       set_tty_color_mode (FRAME_TTY (sf), sf);
@@ -13005,9 +13266,6 @@ redisplay_internal (void)
   if (NILP (Vmemory_full))
     prepare_menu_bars ();
 
-  if (windows_or_buffers_changed && !update_mode_lines)
-    update_mode_lines = 32;
-
   reconsider_clip_changes (w);
 
   /* In most cases selected window displays current buffer.  */
@@ -13016,27 +13274,12 @@ redisplay_internal (void)
     {
       /* Detect case that we need to write or remove a star in the mode line.  */
       if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
-        {
           w->update_mode_line = 1;
-          if (buffer_shared_and_changed ())
-            update_mode_lines = 33;
-        }
 
       if (mode_line_update_needed (w))
         w->update_mode_line = 1;
     }
 
-  consider_all_windows_p = (update_mode_lines
-                            || buffer_shared_and_changed ());
-
-  /* If specs for an arrow have changed, do thorough redisplay
-     to ensure we remove any arrow that should no longer exist.  */
-  if (overlay_arrows_changed_p ())
-    {
-      consider_all_windows_p = true;
-      windows_or_buffers_changed = 49;
-    }
-
   /* Normally the message* functions will have already displayed and
      updated the echo area, but the frame may have been trashed, or
      the update may have been preempted, so display the echo area
@@ -13066,8 +13309,6 @@ redisplay_internal (void)
 
       if (window_height_changed_p)
         {
-          consider_all_windows_p = true;
-          update_mode_lines = 34;
           windows_or_buffers_changed = 50;
 
           /* If window configuration was changed, frames may have been
@@ -13083,13 +13324,6 @@ redisplay_internal (void)
       /* Resized active mini-window to fit the size of what it is
          showing if its contents might have changed.  */
       must_finish = 1;
-      /* FIXME: this causes all frames to be updated, which seems unnecessary
-         since only the current frame needs to be considered.  This function
-         needs to be rewritten with two variables, consider_all_windows and
-         consider_all_frames.  */
-      consider_all_windows_p = true;
-      windows_or_buffers_changed = 51;
-      update_mode_lines = 35;
 
       /* If window configuration was changed, frames may have been
          marked garbaged.  Clear them or we will experience
@@ -13097,23 +13331,29 @@ redisplay_internal (void)
       clear_garbaged_frames ();
     }
 
-  if (VECTORP (Vredisplay__all_windows_cause)
-      && windows_or_buffers_changed >= 0
-      && windows_or_buffers_changed < ASIZE (Vredisplay__all_windows_cause)
-      && INTEGERP (AREF (Vredisplay__all_windows_cause,
-                         windows_or_buffers_changed)))
-    ASET (Vredisplay__all_windows_cause, windows_or_buffers_changed,
-          make_number (1 + XINT (AREF (Vredisplay__all_windows_cause,
-                                       windows_or_buffers_changed))));
-
-  if (VECTORP (Vredisplay__mode_lines_cause)
-      && update_mode_lines >= 0
-      && update_mode_lines < ASIZE (Vredisplay__mode_lines_cause)
-      && INTEGERP (AREF (Vredisplay__mode_lines_cause,
-                         update_mode_lines)))
-    ASET (Vredisplay__mode_lines_cause, update_mode_lines,
-          make_number (1 + XINT (AREF (Vredisplay__mode_lines_cause,
-                                       update_mode_lines))));
+  if (windows_or_buffers_changed && !update_mode_lines)
+    /* Code that sets windows_or_buffers_changed doesn't distinguish whether
+       only the windows's contents needs to be refreshed, or whether the
+       mode-lines also need a refresh.  */
+    update_mode_lines = (windows_or_buffers_changed == REDISPLAY_SOME
+                         ? REDISPLAY_SOME : 32);
+
+  /* If specs for an arrow have changed, do thorough redisplay
+     to ensure we remove any arrow that should no longer exist.  */
+  if (overlay_arrows_changed_p ())
+    /* Apparently, this is the only case where we update other windows,
+       without updating other mode-lines.  */
+    windows_or_buffers_changed = 49;
+
+  consider_all_windows_p = (update_mode_lines
+                            || windows_or_buffers_changed);
+
+#define AINC(a,i) \
+  if (VECTORP (a) && i >= 0 && i < ASIZE (a) && INTEGERP (AREF (a, i))) \
+    ASET (a, i, make_number (1 + XINT (AREF (a, i))))
+
+  AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
+  AINC (Vredisplay__mode_lines_cause, update_mode_lines);
 
   /* Optimize the case that only the line containing the cursor in the
      selected window has changed.  Variables starting with this_ are
@@ -13254,6 +13494,8 @@ redisplay_internal (void)
                PT == w->last_point
                /* Make sure the cursor was last displayed
                   in this window.  Otherwise we have to reposition it.  */
+
+               /* PXW: Must be converted to pixels, probably.  */
                && 0 <= w->cursor.vpos
                && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
         {
@@ -13330,6 +13572,8 @@ redisplay_internal (void)
       FOR_EACH_FRAME (tail, frame)
         XFRAME (frame)->updated_p = 0;
 
+      propagate_buffer_redisplay ();
+
       FOR_EACH_FRAME (tail, frame)
         {
           struct frame *f = XFRAME (frame);
@@ -13344,13 +13588,20 @@ redisplay_internal (void)
 
           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
             {
+              bool gcscrollbars
+                /* Only GC scrollbars when we redisplay the whole frame.  */
+                = f->redisplay || !REDISPLAY_SOME_P ();
               /* Mark all the scroll bars to be removed; we'll redeem
                  the ones we want when we redisplay their windows.  */
-              if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
+              if (gcscrollbars && FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
                 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
 
               if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
                 redisplay_windows (FRAME_ROOT_WINDOW (f));
+              /* Remember that the invisible frames need to be redisplayed next
+                 time they're visible.  */
+              else if (!REDISPLAY_SOME_P ())
+                f->redisplay = true;
 
               /* The X error handler may have deleted that frame.  */
               if (!FRAME_LIVE_P (f))
@@ -13358,7 +13609,7 @@ redisplay_internal (void)
 
               /* Any scroll bars which redisplay_windows should have
                  nuked should now go away.  */
-              if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
+              if (gcscrollbars && FRAME_TERMINAL (f)->judge_scroll_bars_hook)
                 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
 
               if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
@@ -13381,19 +13632,11 @@ redisplay_internal (void)
 
                   /* Prevent various kinds of signals during display
                      update.  stdio is not robust about handling
-                     signals, which can cause an apparent I/O
-                     error.  */
+                     signals, which can cause an apparent I/O error.  */
                   if (interrupt_input)
                     unrequest_sigio ();
                   STOP_POLLING;
 
-                  /* Mark windows on frame F to update.  If we decide to
-                     update all frames but windows_or_buffers_changed is
-                     zero, we assume that only the windows that shows
-                     current buffer should be really updated.  */
-                  set_window_update_flags
-                    (XWINDOW (f->root_window),
-                     (windows_or_buffers_changed ? NULL : current_buffer), 1);
                   pending |= update_frame (f, 0, 0);
                   f->cursor_type_changed = 0;
                   f->updated_p = 1;
@@ -13413,6 +13656,7 @@ redisplay_internal (void)
               struct frame *f = XFRAME (frame);
               if (f->updated_p)
                 {
+                  f->redisplay = false;
                   mark_window_display_accurate (f->root_window, 1);
                   if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
                     FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
@@ -13455,7 +13699,7 @@ redisplay_internal (void)
           if (hscroll_windows (selected_window))
             goto retry;
 
-          XWINDOW (selected_window)->must_be_updated_p = 1;
+          XWINDOW (selected_window)->must_be_updated_p = true;
           pending = update_frame (sf, 0, 0);
           sf->cursor_type_changed = 0;
         }
@@ -13470,7 +13714,7 @@ redisplay_internal (void)
 
       if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
         {
-          XWINDOW (mini_window)->must_be_updated_p = 1;
+          XWINDOW (mini_window)->must_be_updated_p = true;
           pending |= update_frame (mini_frame, 0, 0);
           mini_frame->cursor_type_changed = 0;
           if (!pending && hscroll_windows (mini_window))
@@ -13502,6 +13746,11 @@ redisplay_internal (void)
         {
           /* This has already been done above if
              consider_all_windows_p is set.  */
+          if (XBUFFER (w->contents)->text->redisplay
+              && buffer_window_count (XBUFFER (w->contents)) > 1)
+            /* This can happen if b->text->redisplay was set during
+               jit-lock.  */
+            propagate_buffer_redisplay ();
           mark_window_display_accurate_1 (w, 1);
 
           /* Say overlay arrows are up to date.  */
@@ -13535,12 +13784,7 @@ redisplay_internal (void)
 
       FOR_EACH_FRAME (tail, frame)
         {
-          int this_is_visible = 0;
-
           if (XFRAME (frame)->visible)
-            this_is_visible = 1;
-
-          if (this_is_visible)
             new_count++;
         }
 
@@ -13578,6 +13822,9 @@ redisplay_internal (void)
 #endif /* HAVE_WINDOW_SYSTEM */
 
  end_of_redisplay:
+  if (interrupt_input && interrupts_deferred)
+    request_sigio ();
+
   unbind_to (count, Qnil);
   RESUME_POLLING;
 }
@@ -13639,8 +13886,13 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
 
   if (accurate_p)
     {
-      b->clip_changed = 0;
-      b->prevent_redisplay_optimizations_p = 0;
+      b->clip_changed = false;
+      b->prevent_redisplay_optimizations_p = false;
+      eassert (buffer_window_count (b) > 0);
+      /* Resetting b->text->redisplay is problematic!
+         In order to make it safer to do it here, redisplay_internal must
+         have copied all b->text->redisplay to their respective windows.  */
+      b->text->redisplay = false;
 
       BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
       BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
@@ -13659,9 +13911,11 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
       else
         w->last_point = marker_position (w->pointm);
 
-      w->window_end_valid = 1;
-      w->update_mode_line = 0;
+      w->window_end_valid = true;
+      w->update_mode_line = false;
     }
+
+  w->redisplay = !accurate_p;
 }
 
 
@@ -13764,7 +14018,7 @@ static Lisp_Object
 redisplay_window_0 (Lisp_Object window)
 {
   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
-    redisplay_window (window, 0);
+    redisplay_window (window, false);
   return Qnil;
 }
 
@@ -13772,7 +14026,7 @@ static Lisp_Object
 redisplay_window_1 (Lisp_Object window)
 {
   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
-    redisplay_window (window, 1);
+    redisplay_window (window, true);
   return Qnil;
 }
 
@@ -14314,9 +14568,9 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
      occlude point.  Only set w->cursor if we found a better
      approximation to the cursor position than we have from previously
      examined candidate rows belonging to the same continued line.  */
-  if (/* we already have a candidate row */
+  if (/* We already have a candidate row.  */
       w->cursor.vpos >= 0
-      /* that candidate is not the row we are processing */
+      /* That candidate is not the row we are processing.  */
       && MATRIX_ROW (matrix, w->cursor.vpos) != row
       /* Make sure cursor.vpos specifies a row whose start and end
          charpos occlude point, and it is valid candidate for being a
@@ -14327,30 +14581,30 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
       && pt_old <= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
       && cursor_row_p (MATRIX_ROW (matrix, w->cursor.vpos)))
     {
-      struct glyph *g1 =
-        MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
+      struct glyph *g1
+        = MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
 
       /* Don't consider glyphs that are outside TEXT_AREA.  */
       if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
         return 0;
       /* Keep the candidate whose buffer position is the closest to
          point or has the `cursor' property.  */
-      if (/* previous candidate is a glyph in TEXT_AREA of that row */
+      if (/* Previous candidate is a glyph in TEXT_AREA of that row.  */
           w->cursor.hpos >= 0
           && w->cursor.hpos < MATRIX_ROW_USED (matrix, w->cursor.vpos)
           && ((BUFFERP (g1->object)
-               && (g1->charpos == pt_old /* an exact match always wins */
+               && (g1->charpos == pt_old /* An exact match always wins.  */
                    || (BUFFERP (glyph->object)
                        && eabs (g1->charpos - pt_old)
                        < eabs (glyph->charpos - pt_old))))
-              /* previous candidate is a glyph from a string that has
-                 a non-nil `cursor' property */
+              /* Previous candidate is a glyph from a string that has
+                 a non-nil `cursor' property.  */
               || (STRINGP (g1->object)
                   && (!NILP (Fget_char_property (make_number (g1->charpos),
                                                 Qcursor, g1->object))
-                      /* previous candidate is from the same display
+                      /* Previous candidate is from the same display
                          string as this one, and the display string
-                         came from a text property */
+                         came from a text property.  */
                       || (EQ (g1->object, glyph->object)
                           && string_from_text_prop)
                       /* this candidate is from newline and its
@@ -14793,7 +15047,7 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
       if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1, 0)
           /* It's possible that the cursor is on the first line of the
              buffer, which is partially obscured due to a vscroll
-             (Bug#7537).  In that case, avoid looping forever . */
+             (Bug#7537).  In that case, avoid looping forever. */
           && extra_scroll_margin_lines < w->desired_matrix->nrows - 1)
         {
           clear_glyph_matrix (w->desired_matrix);
@@ -14848,6 +15102,7 @@ compute_window_start_on_continuation_line (struct window *w)
       /* If the line start is "too far" away from the window start,
          say it takes too much time to compute a new window start.  */
       if (CHARPOS (start_pos) - IT_CHARPOS (it)
+          /* PXW: Do we need upper bounds here?  */
           < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
         {
           int min_distance, distance;
@@ -15298,7 +15553,7 @@ set_vertical_scroll_bar (struct window *w)
    changed on window's frame.  In that case, redisplay_internal will retry.  */
 
 static void
-redisplay_window (Lisp_Object window, int just_this_one_p)
+redisplay_window (Lisp_Object window, bool just_this_one_p)
 {
   struct window *w = XWINDOW (window);
   struct frame *f = XFRAME (w->frame);
@@ -15309,11 +15564,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   int tem;
   struct it it;
   /* Record it now because it's overwritten.  */
-  int current_matrix_up_to_date_p = 0;
-  int used_current_matrix_p = 0;
+  bool current_matrix_up_to_date_p = false;
+  bool used_current_matrix_p = false;
   /* This is less strict than current_matrix_up_to_date_p.
      It indicates that the buffer contents and narrowing are unchanged.  */
-  int buffer_unchanged_p = 0;
+  bool buffer_unchanged_p = false;
   int temp_scroll_step = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
   int rc;
@@ -15329,6 +15584,13 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   *w->desired_matrix->method = 0;
 #endif
 
+  if (!just_this_one_p
+      && REDISPLAY_SOME_P ()
+      && !w->redisplay
+      && !f->redisplay
+      && !buffer->text->redisplay)
+    return;
+
   /* Make sure that both W's markers are valid.  */
   eassert (XMARKER (w->start)->buffer == buffer);
   eassert (XMARKER (w->pointm)->buffer == buffer);
@@ -15343,6 +15605,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
                       || buffer->clip_changed
                       || buffer->prevent_redisplay_optimizations_p);
 
+  if (!just_this_one_p)
+    /* If `just_this_one_p' is set, we apparently set must_be_updated_p more
+       cleverly elsewhere.  */
+    w->must_be_updated_p = true;
+
   if (MINI_WINDOW_P (w))
     {
       if (w == XWINDOW (echo_area_window)
@@ -15423,10 +15690,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
       if (XMARKER (w->start)->buffer == current_buffer)
         compute_window_start_on_continuation_line (w);
 
-      w->window_end_valid = 0;
+      w->window_end_valid = false;
       /* If so, we also can't rely on current matrix
          and should not fool try_cursor_movement below.  */
-      current_matrix_up_to_date_p = 0;
+      current_matrix_up_to_date_p = false;
     }
 
   /* Some sanity checks.  */
@@ -16044,7 +16311,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
   SET_TEXT_POS_FROM_MARKER (startp, w->start);
   w->start_at_line_beg = (CHARPOS (startp) == BEGV
-                            || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
+                          || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
 
   /* Display the mode line, if we must.  */
   if ((update_mode_line
@@ -16064,6 +16331,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
       && (WINDOW_WANTS_MODELINE_P (w)
           || WINDOW_WANTS_HEADER_LINE_P (w)))
     {
+
       display_mode_lines (w);
 
       /* If mode line height has changed, arrange for a thorough
@@ -16129,7 +16397,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
             redisplay_tool_bar (f);
 #else
           if (WINDOWP (f->tool_bar_window)
-              && (FRAME_TOOL_BAR_LINES (f) > 0
+              && (FRAME_TOOL_BAR_HEIGHT (f) > 0
                   || !NILP (Vauto_resize_tool_bars))
               && redisplay_tool_bar (f))
             ignore_mouse_drag_p = 1;
@@ -16147,10 +16415,18 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
       update_begin (f);
       block_input ();
       if (draw_window_fringes (w, 1))
-        x_draw_vertical_border (w);
+        {
+          if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+            x_draw_right_divider (w);
+          else
+            x_draw_vertical_border (w);
+        }
       unblock_input ();
       update_end (f);
     }
+
+  if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
+    x_draw_bottom_divider (w);
 #endif /* HAVE_WINDOW_SYSTEM */
 
   /* We go to this label, with fonts_changed set, if it is
@@ -16184,7 +16460,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
   set_buffer_internal_1 (old);
   /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
-     shorter.  This can be caused by log truncation in *Messages*. */
+     shorter.  This can be caused by log truncation in *Messages*.  */
   if (CHARPOS (lpoint) <= ZV)
     TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 
@@ -20453,6 +20729,7 @@ display_menu_bar (struct window *w)
   eassert (!FRAME_WINDOW_P (f));
   init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
   it.first_visible_x = 0;
+  /* PXW: Use FRAME_PIXEL_WIDTH (f) here?  */
   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
 #elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
   if (FRAME_WINDOW_P (f))
@@ -20464,6 +20741,7 @@ display_menu_bar (struct window *w)
       init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
                      MENU_FACE_ID);
       it.first_visible_x = 0;
+      /* PXW: Use FRAME_PIXEL_WIDTH (f) here?  */
       it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
     }
   else
@@ -20519,7 +20797,6 @@ display_menu_bar (struct window *w)
   compute_line_metrics (&it);
 }
 
-#ifdef HAVE_MENUS
 /* Deep copy of a glyph row, including the glyphs.  */
 static void
 deep_copy_glyph_row (struct glyph_row *to, struct glyph_row *from)
@@ -20641,7 +20918,6 @@ display_tty_menu_item (const char *item_text, int width, int face_id,
   row->full_width_p = saved_width;
   row->reversed_p = saved_reversed;
 }
-#endif  /* HAVE_MENUS */
 
 /***********************************************************************
                               Mode Line
@@ -20653,7 +20929,7 @@ display_tty_menu_item (const char *item_text, int width, int face_id,
    the number of windows whose mode lines were redisplayed.  */
 
 static int
-redisplay_mode_lines (Lisp_Object window, int force)
+redisplay_mode_lines (Lisp_Object window, bool force)
 {
   int nwindows = 0;
 
@@ -20687,10 +20963,7 @@ redisplay_mode_lines (Lisp_Object window, int force)
           /* Display mode lines.  */
           clear_glyph_matrix (w->desired_matrix);
           if (display_mode_lines (w))
-            {
-              ++nwindows;
-              w->must_be_updated_p = 1;
-            }
+            ++nwindows;
 
           /* Restore old settings.  */
           set_buffer_internal_1 (old);
@@ -20746,6 +21019,8 @@ display_mode_lines (struct window *w)
   XFRAME (new_frame)->selected_window = old_frame_selected_window;
   selected_frame = old_selected_frame;
   selected_window = old_selected_window;
+  if (n > 0)
+    w->must_be_updated_p = true;
   return n;
 }
 
@@ -23841,7 +24116,8 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
       /* X is relative to the left edge of W, without scroll bars
          or fringes.  */
       area_left = WINDOW_LEFT_EDGE_X (w);
-      last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
+      last_x = (WINDOW_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w)
+                - (row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
     }
   else
     {
@@ -25879,7 +26155,8 @@ x_clear_end_of_line (struct window *w, struct glyph_row *updated_row,
   f = XFRAME (w->frame);
 
   if (updated_row->full_width_p)
-    max_x = WINDOW_TOTAL_WIDTH (w);
+    max_x = (WINDOW_PIXEL_WIDTH (w)
+             - (updated_row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
   else
     max_x = window_box_width (w, updated_area);
   max_y = window_text_bottom_y (w);
@@ -26796,7 +27073,10 @@ clear_mouse_face (Mouse_HLInfo *hlinfo)
       cleared = 1;
     }
 
-  reset_mouse_highlight (hlinfo);
+  hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
+  hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
+  hlinfo->mouse_face_window = Qnil;
+  hlinfo->mouse_face_overlay = Qnil;
   return cleared;
 }
 
@@ -27720,6 +28000,8 @@ define_frame_cursor1 (struct frame *f, Cursor cursor, Lisp_Object pointer)
         cursor = FRAME_X_OUTPUT (f)->text_cursor;
       else if (EQ (pointer, intern ("hdrag")))
         cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
+      else if (EQ (pointer, intern ("nhdrag")))
+        cursor = FRAME_X_OUTPUT (f)->vertical_drag_cursor;
 #ifdef HAVE_X_WINDOWS
       else if (EQ (pointer, intern ("vdrag")))
         cursor = FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
@@ -28133,6 +28415,16 @@ note_mouse_highlight (struct frame *f, int x, int y)
       cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
       help_echo_string = build_string ("drag-mouse-1: resize");
     }
+  else if (part == ON_RIGHT_DIVIDER)
+    {
+      cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
+      help_echo_string = build_string ("drag-mouse-1: resize");
+    }
+  else if (part == ON_BOTTOM_DIVIDER)
+    {
+      cursor = FRAME_X_OUTPUT (f)->vertical_drag_cursor;
+      help_echo_string = build_string ("drag-mouse-1: resize");
+    }
   else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
            || part == ON_SCROLL_BAR)
     cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
@@ -28773,7 +29065,7 @@ x_draw_vertical_border (struct window *w)
      do it for frames with vertical scroll bars because either the
      right scroll bar of a window, or the left scroll bar of its
      neighbor will suffice as a border.  */
-  if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
+  if (FRAME_HAS_VERTICAL_SCROLL_BARS (f) || FRAME_RIGHT_DIVIDER_WIDTH (f))
     return;
 
   /* Note: It is necessary to redraw both the left and the right
@@ -28792,6 +29084,7 @@ x_draw_vertical_border (struct window *w)
 
       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
     }
+
   if (!WINDOW_LEFTMOST_P (w)
       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
     {
@@ -28808,6 +29101,44 @@ x_draw_vertical_border (struct window *w)
 }
 
 
+/* Draw window dividers for window W.  */
+
+void
+x_draw_right_divider (struct window *w)
+{
+  struct frame *f = WINDOW_XFRAME (w);
+
+  if (w->mini || w->pseudo_window_p)
+    return;
+  else if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+    {
+      int x0 = WINDOW_RIGHT_EDGE_X (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
+      int x1 = WINDOW_RIGHT_EDGE_X (w);
+      int y0 = WINDOW_TOP_EDGE_Y (w);
+      int y1 = WINDOW_BOTTOM_EDGE_Y (w);
+
+      FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
+    }
+}
+
+static void
+x_draw_bottom_divider (struct window *w)
+{
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
+  if (w->mini || w->pseudo_window_p)
+    return;
+  else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
+    {
+      int x0 = WINDOW_LEFT_EDGE_X (w);
+      int x1 = WINDOW_RIGHT_EDGE_X (w);
+      int y0 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
+      int y1 = WINDOW_BOTTOM_EDGE_Y (w);
+
+      FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
+    }
+}
+
 /* Redraw the part of window W intersection rectangle FR.  Pixel
    coordinates in FR are frame-relative.  Call this function with
    input blocked.  Value is non-zero if the exposure overwrites
@@ -28839,8 +29170,8 @@ expose_window (struct window *w, XRectangle *fr)
   /* Frame-relative pixel rectangle of W.  */
   wr.x = WINDOW_LEFT_EDGE_X (w);
   wr.y = WINDOW_TOP_EDGE_Y (w);
-  wr.width = WINDOW_TOTAL_WIDTH (w);
-  wr.height = WINDOW_TOTAL_HEIGHT (w);
+  wr.width = WINDOW_PIXEL_WIDTH (w);
+  wr.height = WINDOW_PIXEL_HEIGHT (w);
 
   if (x_intersect_rectangles (fr, &wr, &r))
     {
@@ -28936,7 +29267,13 @@ expose_window (struct window *w, XRectangle *fr)
                              fr);
 
           /* Draw border between windows.  */
-          x_draw_vertical_border (w);
+          if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+            x_draw_right_divider (w);
+          else
+            x_draw_vertical_border (w);
+
+          if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
+            x_draw_bottom_divider (w);
 
           /* Turn the cursor on again.  */
           if (cursor_cleared_p
@@ -29154,13 +29491,14 @@ syms_of_xdisp (void)
   defsubr (&Strace_to_stderr);
 #endif
 #ifdef HAVE_WINDOW_SYSTEM
-  defsubr (&Stool_bar_lines_needed);
+  defsubr (&Stool_bar_height);
   defsubr (&Slookup_image_map);
 #endif
   defsubr (&Sline_pixel_height);
   defsubr (&Sformat_mode_line);
   defsubr (&Sinvisible_p);
   defsubr (&Scurrent_bidi_paragraph_direction);
+  defsubr (&Swindow_text_pixel_size);
   defsubr (&Smove_point_visually);
 
   DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
@@ -29788,12 +30126,18 @@ init_xdisp (void)
       echo_area_window = minibuf_window;
 
       r->top_line = FRAME_TOP_MARGIN (f);
-      r->total_lines = FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f);
+      r->pixel_top = r->top_line * FRAME_LINE_HEIGHT (f);
       r->total_cols = FRAME_COLS (f);
+      r->pixel_width = r->total_cols * FRAME_COLUMN_WIDTH (f);
+      r->total_lines = FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f);
+      r->pixel_height = r->total_lines * FRAME_LINE_HEIGHT (f);
 
       m->top_line = FRAME_LINES (f) - 1;
-      m->total_lines = 1;
+      m->pixel_top = m->top_line * FRAME_LINE_HEIGHT (f);
       m->total_cols = FRAME_COLS (f);
+      m->pixel_width = m->total_cols * FRAME_COLUMN_WIDTH (f);
+      m->total_lines = 1;
+      m->pixel_height = m->total_lines * FRAME_LINE_HEIGHT (f);
 
       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
       scratch_glyph_row.glyphs[TEXT_AREA + 1]
diff --git a/src/xfaces.c b/src/xfaces.c
index b9ddddfd9e2..8a74c92b10d 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -323,6 +323,7 @@ Lisp_Object Qheader_line, Qscroll_bar, Qcursor;
 static Lisp_Object Qborder, Qmouse, Qmenu;
 Lisp_Object Qmode_line_inactive;
 static Lisp_Object Qvertical_border;
+static Lisp_Object Qwindow_divider;
 
 /* The symbol `face-alias'.  A symbols having that property is an
    alias for another face.  Value of the property is the name of
@@ -911,8 +912,6 @@ load_pixmap (struct frame *f, Lisp_Object name)
                                 X Colors
  ***********************************************************************/
 
-#define NEAR_SAME_COLOR_THRESHOLD 30000
-
 /* Parse RGB_LIST, and fill in the RGB fields of COLOR.
    RGB_LIST should contain (at least) 3 lisp integers.
    Return 0 if there's a problem with RGB_LIST, otherwise return 1.  */
@@ -1264,6 +1263,8 @@ load_color (struct frame *f, struct face *face, Lisp_Object name,
 
 #ifdef HAVE_WINDOW_SYSTEM
 
+#define NEAR_SAME_COLOR_THRESHOLD 30000
+
 /* Load colors for face FACE which is used on frame F.  Colors are
    specified by slots LFACE_BACKGROUND_INDEX and LFACE_FOREGROUND_INDEX
    of ATTRS.  If the background color specified is not supported on F,
@@ -5246,6 +5247,7 @@ realize_basic_faces (struct frame *f)
       realize_named_face (f, Qmouse, MOUSE_FACE_ID);
       realize_named_face (f, Qmenu, MENU_FACE_ID);
       realize_named_face (f, Qvertical_border, VERTICAL_BORDER_FACE_ID);
+      realize_named_face (f, Qwindow_divider, WINDOW_DIVIDER_FACE_ID);
 
       /* Reflect changes in the `menu' face in menu bars.  */
       if (FRAME_FACE_CACHE (f)->menu_face_changed_p)
@@ -6448,6 +6450,7 @@ syms_of_xfaces (void)
   DEFSYM (Qmouse, "mouse");
   DEFSYM (Qmode_line_inactive, "mode-line-inactive");
   DEFSYM (Qvertical_border, "vertical-border");
+  DEFSYM (Qwindow_divider, "window-divider");
   DEFSYM (Qtty_color_desc, "tty-color-desc");
   DEFSYM (Qtty_color_standard_values, "tty-color-standard-values");
   DEFSYM (Qtty_color_by_index, "tty-color-by-index");
diff --git a/src/xfns.c b/src/xfns.c
index 46f377042f6..3c8df12f8c5 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -612,7 +612,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   struct x_output *x = f->output_data.x;
   Display *dpy = FRAME_X_DISPLAY (f);
   Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
-  Cursor hourglass_cursor, horizontal_drag_cursor;
+  Cursor hourglass_cursor, horizontal_drag_cursor, vertical_drag_cursor;
   unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
   unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
 
@@ -680,7 +680,7 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 
   if (!NILP (Vx_window_horizontal_drag_shape))
     {
-      CHECK_NUMBER (Vx_window_horizontal_drag_shape);
+      CHECK_TYPE_RANGED_INTEGER (unsigned, Vx_window_horizontal_drag_shape);
       horizontal_drag_cursor
         = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
     }
@@ -688,6 +688,16 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     horizontal_drag_cursor
       = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
 
+  if (!NILP (Vx_window_vertical_drag_shape))
+    {
+      CHECK_NUMBER (Vx_window_vertical_drag_shape);
+      vertical_drag_cursor
+        = XCreateFontCursor (dpy, XINT (Vx_window_vertical_drag_shape));
+    }
+  else
+    vertical_drag_cursor
+      = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
+
   /* Check and report errors with the above calls.  */
   x_check_errors (dpy, "can't set cursor shape: %s");
   x_uncatch_errors ();
@@ -745,6 +755,11 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     XFreeCursor (dpy, x->horizontal_drag_cursor);
   x->horizontal_drag_cursor = horizontal_drag_cursor;
 
+  if (vertical_drag_cursor != x->vertical_drag_cursor
+      && x->vertical_drag_cursor != 0)
+    XFreeCursor (dpy, x->vertical_drag_cursor);
+  x->vertical_drag_cursor = vertical_drag_cursor;
+
   XFlush (dpy);
   unblock_input ();
 
@@ -963,6 +978,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
   FRAME_MENU_BAR_LINES (f) = 0;
+  FRAME_MENU_BAR_HEIGHT (f) = 0;
   if (nlines)
     {
       FRAME_EXTERNAL_MENU_BAR (f) = 1;
@@ -980,7 +996,8 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     }
 #else /* not USE_X_TOOLKIT && not USE_GTK */
   FRAME_MENU_BAR_LINES (f) = nlines;
-  resize_frame_windows (f, FRAME_LINES (f), 0);
+  FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
+  resize_frame_windows (f, FRAME_LINES (f), 0, 0);
 
   /* If the menu bar height gets changed, the internal border below
      the top margin has to be cleared.  Also, if the menu bar gets
@@ -993,7 +1010,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
       int y;
 
       /* height can be zero here. */
-      if (height > 0 && width > 0)
+      if (FRAME_X_WINDOW (f) && height > 0 && width > 0)
         {
           y = FRAME_TOP_MARGIN_HEIGHT (f);
 
@@ -1051,6 +1068,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 #ifdef USE_GTK
 
   FRAME_TOOL_BAR_LINES (f) = 0;
+  FRAME_TOOL_BAR_HEIGHT (f) = 0;
   if (nlines)
     {
       FRAME_EXTERNAL_TOOL_BAR (f) = 1;
@@ -1083,7 +1101,8 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
     }
 
   FRAME_TOOL_BAR_LINES (f) = nlines;
-  resize_frame_windows (f, FRAME_LINES (f), 0);
+  FRAME_TOOL_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
+  resize_frame_windows (f, FRAME_LINES (f), 0, 0);
   adjust_frame_glyphs (f);
 
   /* We also have to make sure that the internal border at the top of
@@ -1092,7 +1111,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
      below the tool bar if one is displayed, but is below the menu bar
      if there isn't a tool bar.  The tool bar draws into the area
      below the menu bar.  */
-  if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
+  if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_HEIGHT (f) == 0)
     {
       clear_frame (f);
       clear_current_matrices (f);
@@ -1471,13 +1490,13 @@ x_set_scroll_bar_default_width (struct frame *f)
   FRAME_CONFIG_SCROLL_BAR_COLS (f) = (minw + wid - 1) / wid;
   FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = minw;
 #else
-  /* Make the actual width at least 14 pixels and a multiple of a
+  /* Make the actual width 16 pixels and a multiple of a
      character width.  */
-  FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
+  FRAME_CONFIG_SCROLL_BAR_COLS (f) = (16 + wid - 1) / wid;
 
   /* Use all of that space (aside from required margins) for the
      scroll bar.  */
-  FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
+  FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 16;
 #endif
 }
 
@@ -3050,6 +3069,22 @@ This function is an internal primitive--use `make-frame' instead.  */)
      happen.  */
   init_frame_faces (f);
 
+#ifdef USE_GTK
+  /* PXW: This is a duplicate from below.  We have to do it here since
+     otherwise x_set_tool_bar_lines will work with the character sizes
+     installed by init_frame_faces while the frame's pixel size is still
+     calculated from a character size of 1 and we subsequently hit the
+     eassert (height >= 0) assertion in window_box_height.  The
+     non-pixelwise code apparently worked around this because it had one
+     frame line vs one toolbar line which left us with a zero root
+     window height which was obviously wrong as well ...  */
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
+#endif /* USE_GTK */
+
   /* Set the menu-bar-lines and tool-bar-lines parameters.  We don't
      look up the X resources controlling the menu-bar and tool-bar
      here; they are processed specially at startup, and reflected in
@@ -3130,12 +3165,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
      Change will not be effected unless different from the current
      FRAME_LINES (f).  */
-  width = FRAME_COLS (f);
-  height = FRAME_LINES (f);
-
-  SET_FRAME_COLS (f, 0);
-  FRAME_LINES (f) = 0;
-  change_frame_size (f, height, width, 1, 0, 0);
+  width = FRAME_TEXT_WIDTH (f);
+  height = FRAME_TEXT_HEIGHT (f);
+  FRAME_TEXT_HEIGHT (f) = 0;
+  SET_FRAME_WIDTH (f, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 1);
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
   /* Create the menu bar.  */
@@ -4918,6 +4952,10 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
                        "internalBorderWidth", "internalBorderWidth",
                        RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qright_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
+                       NULL, NULL, RES_TYPE_NUMBER);
 
   /* Also do the stuff which must be set before the window exists.  */
   x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
@@ -5000,7 +5038,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
   height = FRAME_LINES (f);
   SET_FRAME_COLS (f, 0);
   FRAME_LINES (f) = 0;
-  change_frame_size (f, height, width, 1, 0, 0);
+  change_frame_size (f, width, height, 1, 0, 0, 0);
 
   /* Add `tooltip' frame parameter's default value. */
   if (NILP (Fframe_parameter (frame, Qtooltip)))
@@ -5260,6 +5298,10 @@ Text larger than the specified size is clipped.  */)
     parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
   if (NILP (Fassq (Qborder_width, parms)))
     parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
+  if (NILP (Fassq (Qbottom_divider_width, parms)))
+    parms = Fcons (Fcons (Qbottom_divider_width, make_number (0)), parms);
+  if (NILP (Fassq (Qright_divider_width, parms)))
+    parms = Fcons (Fcons (Qright_divider_width, make_number (0)), parms);
   if (NILP (Fassq (Qborder_color, parms)))
     parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
   if (NILP (Fassq (Qbackground_color, parms)))
@@ -5275,6 +5317,8 @@ Text larger than the specified size is clipped.  */)
   w = XWINDOW (FRAME_ROOT_WINDOW (f));
   w->left_col = 0;
   w->top_line = 0;
+  w->pixel_left = 0;
+  w->pixel_top = 0;
 
   if (CONSP (Vx_max_tooltip_size)
       && RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
@@ -5289,6 +5333,9 @@ Text larger than the specified size is clipped.  */)
       w->total_lines = 40;
     }
 
+  w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (f);
+  w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (f);
+
   FRAME_TOTAL_COLS (f) = w->total_cols;
   adjust_frame_glyphs (f);
   w->pseudo_window_p = 1;
@@ -5355,9 +5402,11 @@ Text larger than the specified size is clipped.  */)
     {
       /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
          not in pixels.  */
+      w->pixel_width = width;
       width /= WINDOW_FRAME_COLUMN_WIDTH (w);
       w->total_cols = width;
       FRAME_TOTAL_COLS (f) = width;
+      SET_FRAME_WIDTH (f, width);
       adjust_frame_glyphs (f);
       clear_glyph_matrix (w->desired_matrix);
       clear_glyph_matrix (w->current_matrix);
@@ -5958,6 +6007,8 @@ frame_parm_handler x_frame_parm_handlers[] =
   x_set_icon_name,
   x_set_icon_type,
   x_set_internal_border_width,
+  x_set_right_divider_width,
+  x_set_bottom_divider_width,
   x_set_menu_bar_lines,
   x_set_mouse_color,
   x_explicitly_set_name,
@@ -6041,6 +6092,13 @@ This variable takes effect when you create a new frame
 or when you set the mouse color.  */);
   Vx_window_horizontal_drag_shape = Qnil;
 
+  DEFVAR_LISP ("x-window-vertical-drag-cursor",
+              Vx_window_vertical_drag_shape,
+  doc: /* Pointer shape to use for indicating a window can be dragged vertically.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_vertical_drag_shape = Qnil;
+
   DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
     doc: /* A string indicating the foreground color of the cursor box.  */);
   Vx_cursor_fore_pixel = Qnil;
diff --git a/src/xmenu.c b/src/xmenu.c
index b2c7fb5f073..d587610fdd7 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1168,7 +1168,7 @@ free_frame_menubar (struct frame *f)
           if (x1 == 0 && y1 == 0)
             XtVaSetValues (f->output_data.x->widget, XtNx, x0, XtNy, y0, NULL);
 #endif
-          x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+          x_set_window_size (f, 0, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 1);
         }
       unblock_input ();
     }
@@ -2440,11 +2440,7 @@ DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_
        doc: /* Return t if a menu or popup dialog is active.  */)
   (void)
 {
-#ifdef HAVE_MENUS
   return (popup_activated ()) ? Qt : Qnil;
-#else
-  return Qnil;
-#endif /* HAVE_MENUS */
 }
 
 void
diff --git a/src/xrdb.c b/src/xrdb.c
index ea823b2b313..7220915e631 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -179,7 +179,7 @@ magic_db (const char *string, ptrdiff_t string_len, const char *class,
       else
         next = p, next_len = 1;
 
-      /* Do we have room for this component followed by a '\0' ?  */
+      /* Do we have room for this component followed by a '\0'?  */
       if (path_size - path_len <= next_len)
         {
           if (min (PTRDIFF_MAX, SIZE_MAX) / 2 - 1 - path_len < next_len)
diff --git a/src/xterm.c b/src/xterm.c
index 446b2cf1e45..e8e69c666ee 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -98,7 +98,7 @@ extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
 
 #ifdef USE_TOOLKIT_SCROLL_BARS
 #if defined USE_MOTIF
-#include <Xm/Xm.h>              /* for LESSTIF_VERSION */
+#include <Xm/Xm.h>              /* For LESSTIF_VERSION */
 #include <Xm/ScrollBar.h>
 #else /* !USE_MOTIF i.e. use Xaw */
 
@@ -165,11 +165,6 @@ static bool toolkit_scroll_bar_interaction;
 
 static Time ignore_next_mouse_click_timeout;
 
-/* Incremented by XTread_socket whenever it really tries to read
-   events.  */
-
-static int volatile input_signal_count;
-
 /* Used locally within XTread_socket.  */
 
 static int x_noop_count;
@@ -214,7 +209,7 @@ enum xembed_message
   };
 
 static bool x_alloc_nearest_color_1 (Display *, Colormap, XColor *);
-static void x_set_window_size_1 (struct frame *, int, int, int);
+static void x_set_window_size_1 (struct frame *, int, int, int, bool);
 static void x_raise_frame (struct frame *);
 static void x_lower_frame (struct frame *);
 static const XColor *x_color_cells (Display *, int *);
@@ -253,9 +248,6 @@ static void x_sync_with_move (struct frame *, int, int, int);
 static int handle_one_xevent (struct x_display_info *,
                               const XEvent *, int *,
                               struct input_event *);
-#ifdef USE_GTK
-static int x_dispatch_event (XEvent *, Display *);
-#endif
 /* Don't declare this _Noreturn because we want no
    interference with debugging failing X calls.  */
 static void x_connection_closed (Display *, const char *);
@@ -509,6 +501,23 @@ x_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
              f->output_data.x->normal_gc, x, y0, x, y1);
 }
 
+/* Draw a window divider from (x0,y0) to (x1,y1)  */
+
+static void
+x_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
+{
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+  struct face *face;
+
+  face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
+  if (face)
+    XSetForeground (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
+                    face->foreground);
+
+  XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                  f->output_data.x->normal_gc, x0, y0, x1 - x0, y1 - y0);
+}
+
 /* End update of window W.
 
    Draw vertical borders between horizontally adjacent windows, and
@@ -536,7 +545,12 @@ x_update_window_end (struct window *w, bool cursor_on_p,
                                 w->output_cursor.x, w->output_cursor.y);
 
       if (draw_window_fringes (w, 1))
-        x_draw_vertical_border (w);
+        {
+          if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
+            x_draw_right_divider (w);
+          else
+            x_draw_vertical_border (w);
+        }
 
       unblock_input ();
     }
@@ -631,10 +645,8 @@ x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fring
   /* Must clip because of partially visible lines.  */
   x_clip_to_row (w, row, ANY_AREA, gc);
 
-  if (!p->overlay_p)
+  if (p->bx >= 0 && !p->overlay_p)
     {
-      int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
-
       /* In case the same realized face is used for fringes and
          for something displayed in the text (e.g. face `region' on
          mono-displays, the fill style may have been changed to
@@ -644,55 +656,8 @@ x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fring
       else
         XSetForeground (display, face->gc, face->background);
 
-#ifdef USE_TOOLKIT_SCROLL_BARS
-      /* If the fringe is adjacent to the left (right) scroll bar of a
-         leftmost (rightmost, respectively) window, then extend its
-         background to the gap between the fringe and the bar.  */
-      if ((WINDOW_LEFTMOST_P (w)
-           && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
-          || (WINDOW_RIGHTMOST_P (w)
-              && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
-        {
-          int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
-
-          if (sb_width > 0)
-            {
-              int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
-              int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
-                                    * FRAME_COLUMN_WIDTH (f));
-
-              if (bx < 0)
-                {
-                  /* Bitmap fills the fringe.  */
-                  if (bar_area_x + bar_area_width == p->x)
-                    bx = bar_area_x + sb_width;
-                  else if (p->x + p->wd == bar_area_x)
-                    bx = bar_area_x;
-                  if (bx >= 0)
-                    {
-                      int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
-
-                      nx = bar_area_width - sb_width;
-                      by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
-                                                            row->y));
-                      ny = row->visible_height;
-                    }
-                }
-              else
-                {
-                  if (bar_area_x + bar_area_width == bx)
-                    {
-                      bx = bar_area_x + sb_width;
-                      nx += bar_area_width - sb_width;
-                    }
-                  else if (bx + nx == bar_area_x)
-                    nx += bar_area_width - sb_width;
-                }
-            }
-        }
-#endif
-      if (bx >= 0 && nx > 0)
-        XFillRectangle (display, window, face->gc, bx, by, nx, ny);
+      XFillRectangle (display, window, face->gc,
+                      p->bx, p->by, p->nx, p->ny);
 
       if (!face->stipple)
         XSetForeground (display, face->gc, face->foreground);
@@ -2947,7 +2912,7 @@ XTflash (struct frame *f)
 #endif
     {
       /* Get the height not including a menu bar widget.  */
-      int height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
+      int height = FRAME_PIXEL_HEIGHT (f);
       /* Height of each line to flash.  */
       int flash_height = FRAME_LINE_HEIGHT (f);
       /* These will be the left and right margins of the rectangles.  */
@@ -3107,34 +3072,6 @@ x_scroll_run (struct window *w, struct run *run)
      fringe of W.  */
   window_box (w, ANY_AREA, &x, &y, &width, &height);
 
-#ifdef USE_TOOLKIT_SCROLL_BARS
-  /* If the fringe is adjacent to the left (right) scroll bar of a
-     leftmost (rightmost, respectively) window, then extend its
-     background to the gap between the fringe and the bar.  */
-  if ((WINDOW_LEFTMOST_P (w)
-       && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
-      || (WINDOW_RIGHTMOST_P (w)
-          && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
-    {
-      int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
-
-      if (sb_width > 0)
-        {
-          int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
-          int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
-                                * FRAME_COLUMN_WIDTH (f));
-
-          if (bar_area_x + bar_area_width == x)
-            {
-              x = bar_area_x + sb_width;
-              width += bar_area_width - sb_width;
-            }
-          else if (x + width == bar_area_x)
-            width += bar_area_width - sb_width;
-        }
-    }
-#endif
-
   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
   bottom_y = y + height;
@@ -3528,7 +3465,7 @@ x_detect_focus_change (struct x_display_info *dpyinfo, struct frame *frame,
 }
 
 
-#if defined HAVE_MENUS && !defined USE_X_TOOLKIT && !defined USE_GTK
+#if !defined USE_X_TOOLKIT && !defined USE_GTK
 /* Handle an event saying the mouse has moved out of an Emacs frame.  */
 
 void
@@ -4945,7 +4882,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
     /* Clear the area of W that will serve as a scroll bar.  This is
        for the case that a window has been split horizontally.  In
        this case, no clear_frame is generated to reduce flickering.  */
-    if (width > 0 && height > 0)
+    if (width > 0 && window_box_height (w) > 0)
       x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                     left, top, width, window_box_height (w));
 
@@ -4971,7 +4908,6 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   bar->start = 0;
   bar->end = 0;
   bar->dragging = -1;
-  bar->fringe_extended_p = 0;
 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
   bar->last_seen_part = scroll_bar_nowhere;
 #endif
@@ -5147,44 +5083,17 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
   struct frame *f = XFRAME (w->frame);
   Lisp_Object barobj;
   struct scroll_bar *bar;
-  int top, height, left, sb_left, width, sb_width;
+  int top, height, left, width;
   int window_y, window_height;
-#ifdef USE_TOOLKIT_SCROLL_BARS
-  bool fringe_extended_p;
-#endif
 
   /* Get window dimensions.  */
   window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
   top = window_y;
-  width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
   height = window_height;
 
-  /* Compute the left edge of the scroll bar area.  */
+  /* Compute the left edge and the width of the scroll bar area.  */
   left = WINDOW_SCROLL_BAR_AREA_X (w);
-
-  /* Compute the width of the scroll bar which might be less than
-     the width of the area reserved for the scroll bar.  */
-  if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
-    sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
-  else
-    sb_width = width;
-
-  /* Compute the left edge of the scroll bar.  */
-#ifdef USE_TOOLKIT_SCROLL_BARS
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
-    sb_left = left + (WINDOW_RIGHTMOST_P (w) ? width - sb_width : 0);
-  else
-    sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
-#else
-  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
-    sb_left = left + width - sb_width;
-  else
-    sb_left = left;
-#endif
-
-#ifdef USE_TOOLKIT_SCROLL_BARS
-  fringe_extended_p = WINDOW_FRINGE_EXTENDED_P (w);
-#endif
+  width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
 
   /* Does the scroll bar exist yet?  */
   if (NILP (w->vertical_scroll_bar))
@@ -5192,18 +5101,12 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
       if (width > 0 && height > 0)
         {
           block_input ();
-#ifdef USE_TOOLKIT_SCROLL_BARS
-          if (fringe_extended_p)
-            x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                          sb_left, top, sb_width, height);
-          else
-#endif
-            x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                          left, top, width, height);
+          x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                        left, top, width, height);
           unblock_input ();
         }
 
-      bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
+      bar = x_scroll_bar_create (w, top, left, width, max (height, 1));
     }
   else
     {
@@ -5214,11 +5117,11 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 
       block_input ();
 
-      if (sb_left != bar->left)
+      if (left != bar->left)
         mask |= CWX;
       if (top != bar->top)
         mask |= CWY;
-      if (sb_width != bar->width)
+      if (width != bar->width)
         mask |= CWWidth;
       if (height != bar->height)
         mask |= CWHeight;
@@ -5226,55 +5129,31 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #ifdef USE_TOOLKIT_SCROLL_BARS
 
       /* Move/size the scroll bar widget.  */
-      if (mask || bar->fringe_extended_p != fringe_extended_p)
+      if (mask)
         {
           /* Since toolkit scroll bars are smaller than the space reserved
              for them on the frame, we have to clear "under" them.  */
           if (width > 0 && height > 0)
-            {
-              if (fringe_extended_p)
-                x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                              sb_left, top, sb_width, height);
-              else
-                x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                              left, top, width, height);
-            }
+            x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                          left, top, width, height);
 #ifdef USE_GTK
           xg_update_scrollbar_pos (f, bar->x_window, top,
-                                   sb_left, sb_width, max (height, 1));
+                                   left, width, max (height, 1));
 #else /* not USE_GTK */
           XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
-                             sb_left, top, sb_width, max (height, 1), 0);
+                             left, top, width, max (height, 1), 0);
 #endif /* not USE_GTK */
         }
 #else /* not USE_TOOLKIT_SCROLL_BARS */
 
-      /* Clear areas not covered by the scroll bar because it's not as
-         wide as the area reserved for it.  This makes sure a
-         previous mode line display is cleared after C-x 2 C-x 1, for
-         example.  */
-      {
-        int area_width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
-        int rest = area_width - sb_width;
-        if (rest > 0 && height > 0)
-          {
-            if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
-              x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                            left + area_width - rest, top, rest, height);
-            else
-              x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                            left, top, rest, height);
-          }
-      }
-
       /* Move/size the scroll bar window.  */
       if (mask)
         {
           XWindowChanges wc;
 
-          wc.x = sb_left;
+          wc.x = left;
           wc.y = top;
-          wc.width = sb_width;
+          wc.width = width;
           wc.height = height;
           XConfigureWindow (FRAME_X_DISPLAY (f), bar->x_window,
                             mask, &wc);
@@ -5283,17 +5162,15 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 
       /* Remember new settings.  */
-      bar->left = sb_left;
+      bar->left = left;
       bar->top = top;
-      bar->width = sb_width;
+      bar->width = width;
       bar->height = height;
 
       unblock_input ();
     }
 
 #ifdef USE_TOOLKIT_SCROLL_BARS
-  bar->fringe_extended_p = fringe_extended_p;
-
   x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
 #else /* not USE_TOOLKIT_SCROLL_BARS */
   /* Set the scroll bar's current state, unless we're currently being
@@ -5774,7 +5651,7 @@ static void xembed_send_message (struct frame *f, Time,
    *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
    *EVENT is unchanged unless we're processing KeyPress event.
 
-   We return the number of characters stored into the buffer. */
+   We return the number of characters stored into the buffer.  */
 
 static int
 handle_one_xevent (struct x_display_info *dpyinfo,
@@ -6202,7 +6079,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
             SET_FRAME_GARBAGED (f);
 
           /* Check if fullscreen was specified before we where mapped the
-             first time, i.e. from the command line. */
+             first time, i.e. from the command line.  */
           if (!f->output_data.x->has_been_visible)
             x_check_fullscreen (f);
 
@@ -6722,8 +6599,8 @@ handle_one_xevent (struct x_display_info *dpyinfo,
         {
 #ifndef USE_X_TOOLKIT
 #ifndef USE_GTK
-          int rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, event->xconfigure.height);
-          int columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, event->xconfigure.width);
+          int width = FRAME_PIXEL_TO_TEXT_WIDTH (f, event->xconfigure.width);
+          int height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, event->xconfigure.height);
 
           /* In the toolkit version, change_frame_size
              is called by the code that handles resizing
@@ -6732,12 +6609,12 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           /* Even if the number of character rows and columns has
              not changed, the font size may have changed, so we need
              to check the pixel dimensions as well.  */
-          if (columns != FRAME_COLS (f)
-              || rows != FRAME_LINES (f)
+          if (width != FRAME_TEXT_WIDTH (f)
+              || height != FRAME_TEXT_HEIGHT (f)
               || event->xconfigure.width != FRAME_PIXEL_WIDTH (f)
               || event->xconfigure.height != FRAME_PIXEL_HEIGHT (f))
             {
-              change_frame_size (f, rows, columns, 0, 1, 0);
+              change_frame_size (f, width, height, 0, 1, 0, 1);
               SET_FRAME_GARBAGED (f);
               cancel_mouse_face (f);
             }
@@ -6968,8 +6845,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
   return count;
 }
 
-#if defined USE_GTK || defined USE_X_TOOLKIT
-
 /* Handles the XEvent EVENT on display DISPLAY.
    This is used for event loops outside the normal event handling,
    i.e. looping while a popup menu or a dialog is posted.
@@ -6988,8 +6863,6 @@ x_dispatch_event (XEvent *event, Display *display)
 
   return finish;
 }
-#endif
-
 
 /* Read events coming from the X server.
    Return as soon as there are no more events to be read.
@@ -7008,9 +6881,6 @@ XTread_socket (struct terminal *terminal, struct input_event *hold_quit)
 
   block_input ();
 
-  /* So people can tell when we have read the available input.  */
-  input_signal_count++;
-
   /* For debugging, this gives a way to fake an I/O error.  */
   if (dpyinfo == XTread_socket_fake_io_error)
     {
@@ -7822,12 +7692,15 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
   if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
     {
       int wid = FRAME_COLUMN_WIDTH (f);
+
       FRAME_CONFIG_SCROLL_BAR_COLS (f)
         = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid;
     }
   else
     {
       int wid = FRAME_COLUMN_WIDTH (f);
+
+      FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 14;
       FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
     }
 
@@ -7837,7 +7710,8 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
          doing it because it's done in Fx_show_tip, and it leads to
          problems because the tip frame has no widget.  */
       if (NILP (tip_frame) || XFRAME (tip_frame) != f)
-        x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+        x_set_window_size (f, 0, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
+                           FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 1);
     }
 
 #ifdef HAVE_X_I18N
@@ -8652,11 +8526,11 @@ x_wait_for_event (struct frame *f, int eventtype)
    size changes.  Otherwise we leave the window gravity unchanged.  */
 
 static void
-x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
+x_set_window_size_1 (struct frame *f, int change_gravity, int width, int height, bool pixelwise)
 {
   int pixelwidth, pixelheight;
 
-  check_frame_size (f, &rows, &cols);
+  check_frame_size (f, &width, &height, pixelwise);
   f->scroll_bar_actual_width
     = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
        ? 0
@@ -8664,9 +8538,11 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
 
   compute_fringe_widths (f, 0);
 
-  pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols)
+  pixelwidth =
+    (pixelwise ? width : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width))
     + FRAME_TOOLBAR_WIDTH (f);
-  pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
+  pixelheight =
+    (pixelwise ? height : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height))
     + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
 
   if (change_gravity) f->win_gravity = NorthWestGravity;
@@ -8702,7 +8578,7 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
     x_wait_for_event (f, ConfigureNotify);
   else
     {
-      change_frame_size (f, rows, cols, 0, 1, 0);
+      change_frame_size (f, width, height, 0, 1, 0, 1);
       FRAME_PIXEL_WIDTH (f) = pixelwidth;
       FRAME_PIXEL_HEIGHT (f) = pixelheight;
       x_sync (f);
@@ -8716,17 +8592,19 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
    Otherwise we leave the window gravity unchanged.  */
 
 void
-x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
+x_set_window_size (struct frame *f, int change_gravity, int width, int height, bool pixelwise)
 {
   block_input ();
 
+  check_frame_size (f, &width, &height, pixelwise);
+
   if (NILP (tip_frame) || XFRAME (tip_frame) != f)
     {
-      int r, c;
+      int text_width, text_height;
 
       /* When the frame is maximized/fullscreen or running under for
          example Xmonad, x_set_window_size_1 will be a no-op.
-         In that case, the right thing to do is extend rows/cols to
+         In that case, the right thing to do is extend rows/width to
          the current frame size.  We do that first if x_set_window_size_1
          turns out to not be a no-op (there is no way to know).
          The size will be adjusted again if the frame gets a
@@ -8737,23 +8615,27 @@ x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
          is however.  */
       pixelh -= FRAME_MENUBAR_HEIGHT (f);
 #endif
-      r = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixelh);
+      text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, FRAME_PIXEL_WIDTH (f));
+      text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelh);
       /* Update f->scroll_bar_actual_width because it is used in
          FRAME_PIXEL_WIDTH_TO_TEXT_COLS.  */
       f->scroll_bar_actual_width
         = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
-      c = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, FRAME_PIXEL_WIDTH (f));
-      change_frame_size (f, r, c, 0, 1, 0);
+      change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
     }
 
 #ifdef USE_GTK
   if (FRAME_GTK_WIDGET (f))
-    xg_frame_set_char_size (f, cols, rows);
+    if (! pixelwise)
+      xg_frame_set_char_size (f, width * FRAME_COLUMN_WIDTH (f),
+                              height * FRAME_LINE_HEIGHT (f));
+    else
+      xg_frame_set_char_size (f, width, height);
   else
-    x_set_window_size_1 (f, change_gravity, cols, rows);
+    x_set_window_size_1 (f, change_gravity, width, height, pixelwise);
 #else /* not USE_GTK */
 
-  x_set_window_size_1 (f, change_gravity, cols, rows);
+  x_set_window_size_1 (f, change_gravity, width, height, pixelwise);
 
 #endif /* not USE_GTK */
 
@@ -8929,9 +8811,6 @@ void
 x_make_frame_visible (struct frame *f)
 {
   int original_top, original_left;
-  int retry_count = 2;
-
- retry:
 
   block_input ();
 
@@ -8980,7 +8859,6 @@ x_make_frame_visible (struct frame *f)
      so that incoming events are handled.  */
   {
     Lisp_Object frame;
-    int count;
     /* This must be before UNBLOCK_INPUT
        since events that arrive in response to the actions above
        will set it when they are handled.  */
@@ -9034,46 +8912,18 @@ x_make_frame_visible (struct frame *f)
 
     XSETFRAME (frame, f);
 
-    /* Wait until the frame is visible.  Process X events until a
-       MapNotify event has been seen, or until we think we won't get a
-       MapNotify at all..  */
-    for (count = input_signal_count + 10;
-         input_signal_count < count && !FRAME_VISIBLE_P (f);)
+    /* Process X events until a MapNotify event has been seen.  */
+    while (!FRAME_VISIBLE_P (f))
       {
         /* Force processing of queued events.  */
         x_sync (f);
-
-        /* Machines that do polling rather than SIGIO have been
-           observed to go into a busy-wait here.  So we'll fake an
-           alarm signal to let the handler know that there's something
-           to be read.  We used to raise a real alarm, but it seems
-           that the handler isn't always enabled here.  This is
-           probably a bug.  */
-        if (input_polling_used ())
+        if (XPending (FRAME_X_DISPLAY (f)))
           {
-            /* It could be confusing if a real alarm arrives while
-               processing the fake one.  Turn it off and let the
-               handler reset it.  */
-            int old_poll_suppress_count = poll_suppress_count;
-            poll_suppress_count = 1;
-            poll_for_input_1 ();
-            poll_suppress_count = old_poll_suppress_count;
+            XEvent xev;
+            XNextEvent (FRAME_X_DISPLAY (f), &xev);
+            x_dispatch_event (&xev, FRAME_X_DISPLAY (f));
           }
       }
-
-    /* 2000-09-28: In
-
-       (let ((f (selected-frame)))
-          (iconify-frame f)
-          (raise-frame f))
-
-       the frame is not raised with various window managers on
-       FreeBSD, GNU/Linux and Solaris.  It turns out that, for some
-       unknown reason, the call to XtMapWidget is completely ignored.
-       Mapping the widget a second time works.  */
-
-    if (!FRAME_VISIBLE_P (f) && --retry_count != 0)
-      goto retry;
   }
 }
 
@@ -9439,7 +9289,7 @@ x_wm_set_size_hint (struct frame *f, long flags, bool user_position)
     base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
     base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
 
-    check_frame_size (f, &min_rows, &min_cols);
+    check_frame_size (f, &min_cols, &min_rows, 0);
 
     /* The window manager uses the base width hints to calculate the
        current number of rows and columns in the frame while
@@ -10352,6 +10202,7 @@ static struct redisplay_interface x_redisplay_interface =
     x_clear_frame_area,
     x_draw_window_cursor,
     x_draw_vertical_window_border,
+    x_draw_window_divider,
     x_shift_glyphs_for_insert
   };
 
diff --git a/src/xterm.h b/src/xterm.h
index 753debff1bb..3d954fb8600 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -84,11 +84,6 @@ typedef GtkWidget *xt_or_gtk_widget;
 #define WHITE_PIX_DEFAULT(f)                                    \
   WhitePixel (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))
 
-#define FONT_WIDTH(f)   ((f)->max_width)
-#define FONT_HEIGHT(f)  ((f)->ascent + (f)->descent)
-#define FONT_BASE(f)    ((f)->ascent)
-#define FONT_DESCENT(f) ((f)->descent)
-
 /* The mask of events that text windows always want to receive.  This
    includes mouse movement events, since handling the mouse-font text property
    means that we must track mouse motion all the time.  */
@@ -549,6 +544,7 @@ struct x_output
   Cursor hand_cursor;
   Cursor hourglass_cursor;
   Cursor horizontal_drag_cursor;
+  Cursor vertical_drag_cursor;
   Cursor current_cursor;
 
   /* Window whose cursor is hourglass_cursor.  This window is temporarily
@@ -811,10 +807,6 @@ struct scroll_bar
   /* Last scroll bar part seen in xaw_jump_callback and xaw_scroll_callback.  */
   enum scroll_bar_part last_seen_part;
 #endif
-
-  /* 1 if the background of the fringe that is adjacent to a scroll
-     bar is extended to the gap between the fringe and the bar.  */
-  unsigned fringe_extended_p : 1;
 };
 
 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
@@ -930,7 +922,7 @@ extern void x_check_errors (Display *, const char *)
 extern bool x_had_errors_p (Display *);
 extern void x_uncatch_errors (void);
 extern void x_clear_errors (Display *);
-extern void x_set_window_size (struct frame *, int, int, int);
+extern void x_set_window_size (struct frame *, int, int, int, bool);
 extern void x_set_mouse_position (struct frame *, int, int);
 extern void x_set_mouse_pixel_position (struct frame *, int, int);
 extern void xembed_request_focus (struct frame *);
@@ -949,13 +941,11 @@ extern bool x_alloc_lighter_color_for_widget (Widget, Display *, Colormap,
 extern bool x_alloc_nearest_color (struct frame *, Colormap, XColor *);
 extern void x_query_color (struct frame *f, XColor *);
 extern void x_clear_area (Display *, Window, int, int, int, int);
-#if defined HAVE_MENUS && !defined USE_X_TOOLKIT && !defined USE_GTK
+#if !defined USE_X_TOOLKIT && !defined USE_GTK
 extern void x_mouse_leave (struct x_display_info *);
 #endif
 
-#ifdef USE_X_TOOLKIT
 extern int x_dispatch_event (XEvent *, Display *);
-#endif
 extern int x_x_to_emacs_modifiers (struct x_display_info *, int);
 extern int x_display_pixel_height (struct x_display_info *);
 extern int x_display_pixel_width (struct x_display_info *);
@@ -963,7 +953,7 @@ extern int x_display_pixel_width (struct x_display_info *);
 extern void x_set_sticky (struct frame *, Lisp_Object, Lisp_Object);
 extern void x_wait_for_event (struct frame *, int);
 
-/* Defined in xselect.c */
+/* Defined in xselect.c.  */
 
 extern void x_handle_property_notify (const XPropertyEvent *);
 extern void x_handle_selection_notify (const XSelectionEvent *);