Merge from emacs-24

6 files changed, 156 insertions, 52 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 7dfa2f80775..257cc34c909 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,43 @@
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_createwindow): Accept an additional argument, an
+        array of 2 values specifying the coordinates of the frame's
+        top-left corner.  Use these values instead of calling x_get_arg,
+        which can cons Lisp objects, and therefore cannot be called except
+        from the main thread.  Remove redundant tests for the default
+        values.
+        (my_create_window): Move the calculation of the coordinates of the
+        frame's top-left edge here.  Pass them to the input thread via the
+        second parameter of the WM_EMACS_CREATEWINDOW message.  See
+        http://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00892.html
+        for the details.
+
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (cursor_row_fully_visible_p): Update commentary.
+        (redisplay_window): Treat the frame's frozen_window_starts flag
+        the same way as the optional_new_start flag for the window: only
+        obey it if the glyph row showing point will be fully visible.
+        Likewise when the window start is in a continuation line.  If,
+        after trying everything under the 'force_start' label, point is
+        still not fully visible, give up and scroll the window.  Add
+        debugging traces.  (Bug#18545)
+
+        * window.c (Frecenter): Set the window's redisplay flag.
+
+2014-09-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (w32_read_socket): Don't use frame dimensions for
+        resizing if GetClientRect returned an empty (0, 0, 0, 0)
+        rectangle.  Check the return value of GetClientRect, and don't use
+        the results if it didn't succeed.
+
+        * dispnew.c (change_frame_size_1): Recompute the frame dimensions
+        in columns and lines after correcting the pixel dimensions in
+        check_frame_size.
+        (adjust_decode_mode_spec_buffer): Add assertion to avoid passing
+        negative values to xrealloc.  (Bug#18528)
+
 2014-09-30  Paul Eggert  <eggert@cs.ucla.edu>
 
         * alloc.c: Remove now-unnecessary check.
diff --git a/src/dispnew.c b/src/dispnew.c
index 078c1ea2164..54657d976ad 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -2137,8 +2137,11 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
 static void
 adjust_decode_mode_spec_buffer (struct frame *f)
 {
+  ssize_t frame_message_buf_size = FRAME_MESSAGE_BUF_SIZE (f);
+
+  eassert (frame_message_buf_size >= 0);
   f->decode_mode_spec_buffer = xrealloc (f->decode_mode_spec_buffer,
-                                         FRAME_MESSAGE_BUF_SIZE (f) + 1);
+                                         frame_message_buf_size + 1);
 }
 
 
diff --git a/src/w32fns.c b/src/w32fns.c
index 0a8bde1f661..98eb8e9f97b 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1956,13 +1956,12 @@ w32_createhscrollbar (struct frame *f, struct scroll_bar * bar)
 }
 
 static void
-w32_createwindow (struct frame *f)
+w32_createwindow (struct frame *f, int *coords)
 {
   HWND hwnd;
   RECT rect;
-  Lisp_Object top = Qunbound;
-  Lisp_Object left = Qunbound;
-  struct w32_display_info *dpyinfo = &one_w32_display_info;
+  int top;
+  int left;
 
   rect.left = rect.top = 0;
   rect.right = FRAME_PIXEL_WIDTH (f);
@@ -1977,25 +1976,21 @@ w32_createwindow (struct frame *f)
 
   if (f->size_hint_flags & USPosition || f->size_hint_flags & PPosition)
     {
-      XSETINT (left, f->left_pos);
-      XSETINT (top, f->top_pos);
+      left = f->left_pos;
+      top = f->top_pos;
     }
-  else if (EQ (left, Qunbound) && EQ (top, Qunbound))
+  else
     {
-      /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
-         for anything that is not a number and is not Qunbound.  */
-      left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
-      top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
+      left = coords[0];
+      top = coords[1];
     }
 
   FRAME_W32_WINDOW (f) = hwnd
     = CreateWindow (EMACS_CLASS,
                     f->namebuf,
                     f->output_data.w32->dwStyle | WS_CLIPCHILDREN,
-                    EQ (left, Qunbound) ? CW_USEDEFAULT : XINT (left),
-                    EQ (top, Qunbound) ? CW_USEDEFAULT : XINT (top),
-                    rect.right - rect.left,
-                    rect.bottom - rect.top,
+                    left, top,
+                    rect.right - rect.left, rect.bottom - rect.top,
                     NULL,
                     NULL,
                     hinst,
@@ -2516,7 +2511,8 @@ w32_msg_pump (deferred_msg * msg_buf)
                  the patch for XP is not publicly available until XP SP3,
                  and older versions will never be patched.  */
               CoInitialize (NULL);
-              w32_createwindow ((struct frame *) msg.wParam);
+              w32_createwindow ((struct frame *) msg.wParam,
+                                (int *) msg.lParam);
               if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
                 emacs_abort ();
               break;
@@ -4136,8 +4132,25 @@ static void
 my_create_window (struct frame * f)
 {
   MSG msg;
+  static int coords[2];
+  Lisp_Object left, top;
+  struct w32_display_info *dpyinfo = &one_w32_display_info;
+
+  /* When called with RES_TYPE_NUMBER, x_get_arg will return zero for
+     anything that is not a number and is not Qunbound.  */
+  left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
+  top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
+  if (EQ (left, Qunbound))
+    coords[0] = CW_USEDEFAULT;
+  else
+    coords[0] = XINT (left);
+  if (EQ (top, Qunbound))
+    coords[1] = CW_USEDEFAULT;
+  else
+    coords[1] = XINT (top);
 
-  if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW, (WPARAM)f, 0))
+  if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW,
+                          (WPARAM)f, (LPARAM)coords))
     emacs_abort ();
   GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
 }
diff --git a/src/w32term.c b/src/w32term.c
index 4f8482736c3..2a4c30af12d 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -5144,30 +5144,38 @@ w32_read_socket (struct terminal *terminal,
               RECT rect;
               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); */
-
-              /* TODO: Clip size to the screen dimensions.  */
-
-              /* 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 (width != FRAME_PIXEL_WIDTH (f)
-                  || height != FRAME_PIXEL_HEIGHT (f)
-                  || text_width != FRAME_TEXT_WIDTH (f)
-                  || text_height != FRAME_TEXT_HEIGHT (f))
+              if (GetClientRect (msg.msg.hwnd, &rect)
+                  /* GetClientRect evidently returns (0, 0, 0, 0) if
+                     called on a minimized frame.  Such "dimensions"
+                     aren't useful anyway.  */
+                  && !(rect.bottom == 0
+                       && rect.top == 0
+                       && rect.left == 0
+                       && rect.right == 0))
                 {
-                  change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
-                  SET_FRAME_GARBAGED (f);
-                  cancel_mouse_face (f);
-                  f->win_gravity = NorthWestGravity;
+                  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); */
+
+                  /* TODO: Clip size to the screen dimensions.  */
+
+                  /* 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 (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, text_width, text_height, 0, 1, 0, 1);
+                      SET_FRAME_GARBAGED (f);
+                      cancel_mouse_face (f);
+                      f->win_gravity = NorthWestGravity;
+                    }
                 }
             }
 
diff --git a/src/window.c b/src/window.c
index f05ea561263..456a8bce691 100644
--- a/src/window.c
+++ b/src/window.c
@@ -5914,6 +5914,8 @@ and redisplay normally--don't erase and redraw the frame.  */)
   w->start_at_line_beg = (bytepos == BEGV_BYTE
                           || FETCH_BYTE (bytepos - 1) == '\n');
 
+  wset_redisplay (w);
+
   return Qnil;
 }
 
diff --git a/src/xdisp.c b/src/xdisp.c
index bf620085727..c27f46677bb 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -15002,6 +15002,10 @@ run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
    If FORCE_P is non-zero, return 0 even if partial visible cursor row
    is higher than window.
 
+   If CURRENT_MATRIX_P is non-zero, use the information from the
+   window's current glyph matrix; otherwise use the desired glyph
+   matrix.
+
    A value of 0 means the caller should do scrolling
    as if point had gone off the screen.  */
 
@@ -16175,26 +16179,48 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
 
   /* If someone specified a new starting point but did not insist,
      check whether it can be used.  */
-  if (w->optional_new_start
+  if ((w->optional_new_start || window_frozen_p (w))
       && CHARPOS (startp) >= BEGV
       && CHARPOS (startp) <= ZV)
     {
+      ptrdiff_t it_charpos;
+
       w->optional_new_start = 0;
       start_display (&it, w, startp);
       move_it_to (&it, PT, 0, it.last_visible_y, -1,
                   MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
-      if (IT_CHARPOS (it) == PT)
-        w->force_start = 1;
-      /* IT may overshoot PT if text at PT is invisible.  */
-      else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
-        w->force_start = 1;
+      /* Record IT's position now, since line_bottom_y might change
+         that.  */
+      it_charpos = IT_CHARPOS (it);
+      /* Make sure we set the force_start flag only if the cursor row
+         will be fully visible.  Otherwise, the code under force_start
+         label below will try to move point back into view, which is
+         not what the code which sets optional_new_start wants.  */
+      if ((it.current_y == 0 || line_bottom_y (&it) < it.last_visible_y)
+          && !w->force_start)
+        {
+          if (it_charpos == PT)
+            w->force_start = 1;
+          /* IT may overshoot PT if text at PT is invisible.  */
+          else if (it_charpos > PT && CHARPOS (startp) <= PT)
+            w->force_start = 1;
+#ifdef GLYPH_DEBUG
+          if (w->force_start)
+            {
+              if (window_frozen_p (w))
+                debug_method_add (w, "set force_start from frozen window start");
+              else
+                debug_method_add (w, "set force_start from optional_new_start");
+            }
+#endif
+        }
     }
 
  force_start:
 
   /* Handle case where place to start displaying has been specified,
      unless the specified location is outside the accessible range.  */
-  if (w->force_start || window_frozen_p (w))
+  if (w->force_start)
     {
       /* We set this later on if we have to adjust point.  */
       int new_vpos = -1;
@@ -16239,7 +16265,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
           goto need_larger_matrices;
         }
 
-      if (w->cursor.vpos < 0 && !window_frozen_p (w))
+      if (w->cursor.vpos < 0)
         {
           /* If point does not appear, try to move point so it does
              appear. The desired matrix has been built above, so we
@@ -16332,6 +16358,11 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
             }
           */
         }
+      if (w->cursor.vpos < 0 || !cursor_row_fully_visible_p (w, 0, 0))
+        {
+          clear_glyph_matrix (w->desired_matrix);
+          goto try_to_scroll;
+        }
 
 #ifdef GLYPH_DEBUG
       debug_method_add (w, "forced window start");
@@ -16396,7 +16427,8 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
                || CHARPOS (startp) == BEGV
                || !window_outdated (w)))
     {
-      int d1, d2, d3, d4, d5, d6;
+      int d1, d2, d5, d6;
+      int rtop, rbot;
 
       /* If first window line is a continuation line, and window start
          is inside the modified region, but the first change is before
@@ -16421,14 +16453,20 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
           && compute_window_start_on_continuation_line (w)
           /* It doesn't make sense to force the window start like we
              do at label force_start if it is already known that point
-             will not be visible in the resulting window, because
+             will not be fully visible in the resulting window, because
              doing so will move point from its correct position
              instead of scrolling the window to bring point into view.
              See bug#9324.  */
-          && pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6))
+          && pos_visible_p (w, PT, &d1, &d2, &rtop, &rbot, &d5, &d6)
+          /* A very tall row could need more than the window height,
+             in which case we accept that it is partially visible.  */
+          && (rtop != 0) == (rbot != 0))
         {
           w->force_start = 1;
           SET_TEXT_POS_FROM_MARKER (startp, w->start);
+#ifdef GLYPH_DEBUG
+          debug_method_add (w, "recomputed window start in continuation line");
+#endif
           goto force_start;
         }