src/frame.c

   1 /* Generic frame functions.
   2    Copyright (C) 1989, 1992 Free Software Foundation.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21
  22 #include "config.h"
  23 #include "lisp.h"
  24 #include "frame.h"
  25
  26 #ifdef MULTI_FRAME
  27
  28 #include "buffer.h"
  29 #include "window.h"
  30 #include "termhooks.h"
  31
  32 /* These help us bind and responding to switch-frame events.  */
  33 #include "commands.h"
  34 #include "keyboard.h"
  35
  36 Lisp_Object Vemacs_iconified;
  37 Lisp_Object Vframe_list;
  38 Lisp_Object Vterminal_frame;
  39 Lisp_Object Vdefault_minibuffer_frame;
  40 Lisp_Object Vdefault_frame_alist;
  41
  42 /* Evaluate this expression to rebuild the section of syms_of_frame
  43    that initializes and staticpros the symbols declared below.  Note
  44    that Emacs 18 has a bug that keeps C-x C-e from being able to
  45    evaluate this expression.
  46
  47 (progn
  48   ;; Accumulate a list of the symbols we want to initialize from the
  49   ;; declarations at the top of the file.
  50   (goto-char (point-min))
  51   (search-forward "/\*&&& symbols declared here &&&*\/\n")
  52   (let (symbol-list)
  53     (while (looking-at "Lisp_Object \\(Q[a-z_]+\\)")
  54       (setq symbol-list
  55             (cons (buffer-substring (match-beginning 1) (match-end 1))
  56                   symbol-list))
  57       (forward-line 1))
  58     (setq symbol-list (nreverse symbol-list))
  59     ;; Delete the section of syms_of_... where we initialize the symbols.
  60     (search-forward "\n  /\*&&& init symbols here &&&*\/\n")
  61     (let ((start (point)))
  62       (while (looking-at "^  Q")
  63         (forward-line 2))
  64       (kill-region start (point)))
  65     ;; Write a new symbol initialization section.
  66     (while symbol-list
  67       (insert (format "  %s = intern (\"" (car symbol-list)))
  68       (let ((start (point)))
  69         (insert (substring (car symbol-list) 1))
  70         (subst-char-in-region start (point) ?_ ?-))
  71       (insert (format "\");\n  staticpro (&%s);\n" (car symbol-list)))
  72       (setq symbol-list (cdr symbol-list)))))
  73   */
  74
  75 /*&&& symbols declared here &&&*/
  76 Lisp_Object Qframep;
  77 Lisp_Object Qlive_frame_p;
  78 Lisp_Object Qheight;
  79 Lisp_Object Qicon;
  80 Lisp_Object Qminibuffer;
  81 Lisp_Object Qmodeline;
  82 Lisp_Object Qname;
  83 Lisp_Object Qnone;
  84 Lisp_Object Qonly;
  85 Lisp_Object Qunsplittable;
  86 Lisp_Object Qwidth;
  87 Lisp_Object Qx;
  88
  89 extern Lisp_Object Vminibuffer_list;
  90 extern Lisp_Object get_minibuffer ();
  91 \f
  92 DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
  93   "Return non-nil if OBJECT is a frame.\n\
  94 Value is t for a termcap frame (a character-only terminal),\n\
  95 `x' for an Emacs frame that is really an X window.\n\
  96 Also see `live-frame-p'.")
  97   (object)
  98      Lisp_Object object;
  99 {
 100   if (XTYPE (object) != Lisp_Frame)
 101     return Qnil;
 102   switch (XFRAME (object)->output_method)
 103     {
 104     case output_termcap:
 105       return Qt;
 106     case output_x_window:
 107       return Qx;
 108     default:
 109       abort ();
 110     }
 111 }
 112
 113 DEFUN ("live-frame-p", Flive_frame_p, Slive_frame_p, 1, 1, 0,
 114   "Return non-nil if OBJECT is a frame which has not been deleted.\n\
 115 Value is nil if OBJECT is not a live frame.  If object is a live\n\
 116 frame, the return value indicates what sort of output device it is\n\
 117 displayed on.  Value is t for a termcap frame (a character-only\n\
 118 terminal), `x' for an Emacs frame being displayed in an X window.")
 119   (object)
 120      Lisp_Object object;
 121 {
 122   return ((FRAMEP (object)
 123            && FRAME_LIVE_P (XFRAME (object)))
 124           ? Fframep (object)
 125           : Qnil);
 126 }
 127
 128 struct frame *
 129 make_frame (mini_p)
 130      int mini_p;
 131 {
 132   Lisp_Object frame;
 133   register struct frame *f;
 134   register Lisp_Object root_window;
 135   register Lisp_Object mini_window;
 136
 137   frame = Fmake_vector (((sizeof (struct frame) - (sizeof (Lisp_Vector)
 138                                                      - sizeof (Lisp_Object)))
 139                           / sizeof (Lisp_Object)),
 140                          make_number (0));
 141   XSETTYPE (frame, Lisp_Frame);
 142   f = XFRAME (frame);
 143
 144   f->cursor_x = 0;
 145   f->cursor_y = 0;
 146   f->current_glyphs = 0;
 147   f->desired_glyphs = 0;
 148   f->visible = 0;
 149   f->async_visible = 0;
 150   f->display.nothing = 0;
 151   f->iconified = 0;
 152   f->async_iconified = 0;
 153   f->wants_modeline = 1;
 154   f->auto_raise = 0;
 155   f->auto_lower = 0;
 156   f->no_split = 0;
 157   f->garbaged = 0;
 158   f->has_minibuffer = mini_p;
 159   f->focus_frame = frame;
 160   f->explicit_name = 0;
 161
 162   f->param_alist = Qnil;
 163
 164   root_window = make_window ();
 165   if (mini_p)
 166     {
 167       mini_window = make_window ();
 168       XWINDOW (root_window)->next = mini_window;
 169       XWINDOW (mini_window)->prev = root_window;
 170       XWINDOW (mini_window)->mini_p = Qt;
 171       XWINDOW (mini_window)->frame = frame;
 172       f->minibuffer_window = mini_window;
 173     }
 174   else
 175     {
 176       mini_window = Qnil;
 177       XWINDOW (root_window)->next = Qnil;
 178       f->minibuffer_window = Qnil;
 179     }
 180
 181   XWINDOW (root_window)->frame = frame;
 182
 183   /* 10 is arbitrary,
 184      just so that there is "something there."
 185      Correct size will be set up later with change_frame_size.  */
 186
 187   f->width = 10;
 188   f->height = 10;
 189
 190   XFASTINT (XWINDOW (root_window)->width) = 10;
 191   XFASTINT (XWINDOW (root_window)->height) = (mini_p ? 9 : 10);
 192
 193   if (mini_p)
 194     {
 195       XFASTINT (XWINDOW (mini_window)->width) = 10;
 196       XFASTINT (XWINDOW (mini_window)->top) = 9;
 197       XFASTINT (XWINDOW (mini_window)->height) = 1;
 198     }
 199
 200   /* Choose a buffer for the frame's root window.  */
 201   {
 202     Lisp_Object buf;
 203
 204     XWINDOW (root_window)->buffer = Qt;
 205     buf = Fcurrent_buffer ();
 206     /* If buf is a 'hidden' buffer (i.e. one whose name starts with
 207        a space), try to find another one.  */
 208     if (XSTRING (Fbuffer_name (buf))->data[0] == ' ')
 209       buf = Fother_buffer (buf, Qnil);
 210     Fset_window_buffer (root_window, buf);
 211   }
 212
 213   if (mini_p)
 214     {
 215       XWINDOW (mini_window)->buffer = Qt;
 216       Fset_window_buffer (mini_window,
 217                           (NILP (Vminibuffer_list)
 218                            ? get_minibuffer (0)
 219                            : Fcar (Vminibuffer_list)));
 220     }
 221
 222   f->root_window = root_window;
 223   f->selected_window = root_window;
 224   /* Make sure this window seems more recently used than
 225      a newly-created, never-selected window.  */
 226   XFASTINT (XWINDOW (f->selected_window)->use_time) = ++window_select_count;
 227
 228   Vframe_list = Fcons (frame, Vframe_list);
 229
 230   return f;
 231 }
 232 \f
 233 /* Make a frame using a separate minibuffer window on another frame.
 234    MINI_WINDOW is the minibuffer window to use.  nil means use the
 235    default (the global minibuffer).  */
 236
 237 struct frame *
 238 make_frame_without_minibuffer (mini_window)
 239      register Lisp_Object mini_window;
 240 {
 241   register struct frame *f;
 242
 243   /* Choose the minibuffer window to use.  */
 244   if (NILP (mini_window))
 245     {
 246       if (XTYPE (Vdefault_minibuffer_frame) != Lisp_Frame)
 247         error ("default-minibuffer-frame must be set when creating minibufferless frames");
 248       if (! FRAME_LIVE_P (XFRAME (Vdefault_minibuffer_frame)))
 249         error ("default-minibuffer-frame must be a live frame");
 250       mini_window = XFRAME (Vdefault_minibuffer_frame)->minibuffer_window;
 251     }
 252   else
 253     {
 254       CHECK_LIVE_WINDOW (mini_window, 0);
 255     }
 256
 257   /* Make a frame containing just a root window.  */
 258   f = make_frame (0);
 259
 260   /* Install the chosen minibuffer window, with proper buffer.  */
 261   f->minibuffer_window = mini_window;
 262   Fset_window_buffer (mini_window,
 263                       (NILP (Vminibuffer_list)
 264                        ? get_minibuffer (0)
 265                        : Fcar (Vminibuffer_list)));
 266   return f;
 267 }
 268
 269 /* Make a frame containing only a minibuffer window.  */
 270
 271 struct frame *
 272 make_minibuffer_frame ()
 273 {
 274   /* First make a frame containing just a root window, no minibuffer.  */
 275
 276   register struct frame *f = make_frame (0);
 277   register Lisp_Object mini_window;
 278   register Lisp_Object frame;
 279
 280   XSET (frame, Lisp_Frame, f);
 281
 282   f->auto_raise = 0;
 283   f->auto_lower = 0;
 284   f->no_split = 1;
 285   f->wants_modeline = 0;
 286   f->has_minibuffer = 1;
 287
 288   /* Now label the root window as also being the minibuffer.
 289      Avoid infinite looping on the window chain by marking next pointer
 290      as nil. */
 291
 292   mini_window = f->minibuffer_window = f->root_window;
 293   XWINDOW (mini_window)->mini_p = Qt;
 294   XWINDOW (mini_window)->next = Qnil;
 295   XWINDOW (mini_window)->prev = Qnil;
 296   XWINDOW (mini_window)->frame = frame;
 297
 298   /* Put the proper buffer in that window.  */
 299
 300   Fset_window_buffer (mini_window,
 301                       (NILP (Vminibuffer_list)
 302                        ? get_minibuffer (0)
 303                        : Fcar (Vminibuffer_list)));
 304   return f;
 305 }
 306 \f
 307 /* Construct a frame that refers to the terminal (stdin and stdout).  */
 308
 309 struct frame *
 310 make_terminal_frame ()
 311 {
 312   register struct frame *f;
 313
 314   Vframe_list = Qnil;
 315   f = make_frame (1);
 316   f->name = build_string ("terminal");
 317   f->visible = 1;
 318   f->display.nothing = 1;   /* Nonzero means frame isn't deleted.  */
 319   XSET (Vterminal_frame, Lisp_Frame, f);
 320   return f;
 321 }
 322 \f
 323 DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
 324   "Select the frame FRAME.  FRAME's selected window becomes \"the\"\n\
 325 selected window.  If the optional parameter NO-ENTER is non-nil, don't\n\
 326 focus on that frame.\n\
 327 \n\
 328 This function is interactive, and may be bound to the ``switch-frame''\n\
 329 event; when invoked this way, it switches to the frame named in the\n\
 330 event.  When called from lisp, FRAME may be a ``switch-frame'' event;\n\
 331 if it is, select the frame named in the event.")
 332   (frame, no_enter)
 333      Lisp_Object frame, no_enter;
 334 {
 335   /* If FRAME is a switch-frame event, extract the frame we should
 336      switch to.  */
 337   if (CONSP (frame)
 338       && EQ (XCONS (frame)->car, Qswitch_frame)
 339       && CONSP (XCONS (frame)->cdr))
 340     frame = XCONS (XCONS (frame)->cdr)->car;
 341
 342   CHECK_LIVE_FRAME (frame, 0);
 343
 344   if (selected_frame == XFRAME (frame))
 345     return frame;
 346
 347   selected_frame = XFRAME (frame);
 348   if (! FRAME_MINIBUF_ONLY_P (selected_frame))
 349     last_nonminibuf_frame = selected_frame;
 350
 351   Fselect_window (XFRAME (frame)->selected_window);
 352
 353 #ifdef HAVE_X_WINDOWS
 354 #ifdef MULTI_FRAME
 355   if (FRAME_X_P (XFRAME (frame))
 356       && NILP (no_enter))
 357     {
 358       Ffocus_frame (frame);
 359     }
 360 #endif
 361 #endif
 362   choose_minibuf_frame ();
 363
 364   return frame;
 365 }
 366
 367 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
 368   "Return the frame that is now selected.")
 369   ()
 370 {
 371   Lisp_Object tem;
 372   XSET (tem, Lisp_Frame, selected_frame);
 373   return tem;
 374 }
 375
 376 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
 377   "Return the frame object that window WINDOW is on.")
 378   (window)
 379      Lisp_Object window;
 380 {
 381   CHECK_LIVE_WINDOW (window, 0);
 382   return XWINDOW (window)->frame;
 383 }
 384
 385 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
 386        "Returns the root-window of FRAME.\n\
 387 If omitted, FRAME defaults to the currently selected frame.")
 388   (frame)
 389      Lisp_Object frame;
 390 {
 391   if (NILP (frame))
 392     XSET (frame, Lisp_Frame, selected_frame);
 393   else
 394     CHECK_LIVE_FRAME (frame, 0);
 395
 396   return XFRAME (frame)->root_window;
 397 }
 398
 399 DEFUN ("frame-selected-window", Fframe_selected_window,
 400        Sframe_selected_window, 0, 1, 0,
 401   "Return the selected window of frame object FRAME.\n\
 402 If omitted, FRAME defaults to the currently selected frame.")
 403   (frame)
 404      Lisp_Object frame;
 405 {
 406   if (NILP (frame))
 407     XSET (frame, Lisp_Frame, selected_frame);
 408   else
 409     CHECK_LIVE_FRAME (frame, 0);
 410
 411   return XFRAME (frame)->selected_window;
 412 }
 413
 414 DEFUN ("frame-list", Fframe_list, Sframe_list,
 415        0, 0, 0,
 416        "Return a list of all frames.")
 417   ()
 418 {
 419   return Fcopy_sequence (Vframe_list);
 420 }
 421
 422 #ifdef MULTI_FRAME
 423
 424 /* Return the next frame in the frame list after FRAME.
 425    If MINIBUF is nil, exclude minibuffer-only frames.
 426    If MINIBUF is a window, include only frames using that window for
 427    their minibuffer.
 428    If MINIBUF is non-nil, and not a window, include all frames.  */
 429 Lisp_Object
 430 next_frame (frame, minibuf)
 431      Lisp_Object frame;
 432      Lisp_Object minibuf;
 433 {
 434   Lisp_Object tail;
 435   int passed = 0;
 436
 437   /* There must always be at least one frame in Vframe_list.  */
 438   if (! CONSP (Vframe_list))
 439     abort ();
 440
 441   while (1)
 442     for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
 443       {
 444         Lisp_Object f = XCONS (tail)->car;
 445
 446         if (passed)
 447           {
 448             /* Decide whether this frame is eligible to be returned.  */
 449
 450             /* If we've looped all the way around without finding any
 451                eligible frames, return the original frame.  */
 452             if (EQ (f, frame))
 453               return f;
 454
 455             /* Let minibuf decide if this frame is acceptable.  */
 456             if (NILP (minibuf))
 457               {
 458                 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
 459                   return f;
 460               }
 461             else if (XTYPE (minibuf) == Lisp_Window)
 462               {
 463                 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf))
 464                   return f;
 465               }
 466             else
 467               return f;
 468           }
 469
 470         if (EQ (frame, f))
 471           passed++;
 472       }
 473 }
 474
 475 #if 0
 476 /* Nobody seems to be using this code right now.  */
 477
 478 /* Return the previous frame in the frame list before FRAME.
 479    If MINIBUF is nil, exclude minibuffer-only frames.
 480    If MINIBUF is a window, include only frames using that window for
 481    their minibuffer.
 482    If MINIBUF is non-nil and not a window, include all frames.  */
 483 Lisp_Object
 484 prev_frame (frame, minibuf)
 485      Lisp_Object frame;
 486      Lisp_Object minibuf;
 487 {
 488   Lisp_Object tail;
 489   Lisp_Object prev;
 490
 491   /* There must always be at least one frame in Vframe_list.  */
 492   if (! CONSP (Vframe_list))
 493     abort ();
 494
 495   prev = Qnil;
 496   for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
 497     {
 498       Lisp_Object f = XCONS (tail)->car;
 499
 500       if (XTYPE (f) != Lisp_Frame)
 501         abort ();
 502
 503       if (EQ (frame, f) && !NILP (prev))
 504         return prev;
 505
 506       /* Decide whether this frame is eligible to be returned,
 507          according to minibuf.  */
 508       if (NILP (minibuf))
 509         {
 510           if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
 511             prev = f;
 512         }
 513       else if (XTYPE (minibuf) == Lisp_Window)
 514         {
 515           if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf))
 516             prev = f;
 517         }
 518       else
 519         prev = f;
 520     }
 521
 522   /* We've scanned the entire list.  */
 523   if (NILP (prev))
 524     /* We went through the whole frame list without finding a single
 525        acceptable frame.  Return the original frame.  */
 526     return frame;
 527   else
 528     /* There were no acceptable frames in the list before FRAME; otherwise,
 529        we would have returned directly from the loop.  Since PREV is the last
 530        acceptable frame in the list, return it.  */
 531     return prev;
 532 }
 533 #endif
 534
 535 DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
 536   "Return the next frame in the frame list after FRAME.\n\
 537 By default, skip minibuffer-only frames.
 538 If omitted, FRAME defaults to the selected frame.\n\
 539 If optional argument MINIFRAME is non-nil, include minibuffer-only frames.\n\
 540 If MINIFRAME is a window, include only frames using that window for their\n\
 541 minibuffer.\n\
 542 If MINIFRAME is non-nil and not a window, include all frames.")
 543   (frame, miniframe)
 544      Lisp_Object frame, miniframe;
 545 {
 546   Lisp_Object tail;
 547
 548   if (NILP (frame))
 549     XSET (frame, Lisp_Frame, selected_frame);
 550   else
 551     CHECK_LIVE_FRAME (frame, 0);
 552
 553   return next_frame (frame, miniframe);
 554 }
 555 #endif /* MULTI_FRAME */
 556 \f
 557 DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 1, "",
 558   "Delete FRAME, permanently eliminating it from use.\n\
 559 If omitted, FRAME defaults to the selected frame.\n\
 560 A frame may not be deleted if its minibuffer is used by other frames.")
 561   (frame)
 562      Lisp_Object frame;
 563 {
 564   struct frame *f;
 565   union display displ;
 566
 567   if (EQ (frame, Qnil))
 568     {
 569       f = selected_frame;
 570       XSET (frame, Lisp_Frame, f);
 571     }
 572   else
 573     {
 574       CHECK_FRAME (frame, 0);
 575       f = XFRAME (frame);
 576     }
 577
 578   if (! FRAME_LIVE_P (f))
 579     return;
 580
 581   /* Are there any other frames besides this one?  */
 582   if (f == selected_frame && EQ (next_frame (frame, Qt), frame))
 583     error ("Attempt to delete the only frame");
 584
 585   /* Does this frame have a minibuffer, and is it the surrogate
 586      minibuffer for any other frame?  */
 587   if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
 588     {
 589       Lisp_Object frames;
 590
 591       for (frames = Vframe_list;
 592            CONSP (frames);
 593            frames = XCONS (frames)->cdr)
 594         {
 595           Lisp_Object this = XCONS (frames)->car;
 596
 597           if (! EQ (this, frame)
 598               && EQ (frame,
 599                      (WINDOW_FRAME
 600                       (XWINDOW
 601                        (FRAME_MINIBUF_WINDOW
 602                         (XFRAME (this)))))))
 603             error ("Attempt to delete a surrogate minibuffer frame");
 604         }
 605     }
 606
 607   /* Don't let the frame remain selected.  */
 608   if (f == selected_frame)
 609     Fselect_frame (next_frame (frame, Qt), Qnil);
 610
 611   /* Don't allow minibuf_window to remain on a deleted frame.  */
 612   if (EQ (f->minibuffer_window, minibuf_window))
 613     {
 614       Fset_window_buffer (selected_frame->minibuffer_window,
 615                           XWINDOW (minibuf_window)->buffer);
 616       minibuf_window = selected_frame->minibuffer_window;
 617     }
 618
 619   Vframe_list = Fdelq (frame, Vframe_list);
 620   f->visible = 0;
 621   displ = f->display;
 622   f->display.nothing = 0;
 623
 624 #ifdef HAVE_X_WINDOWS
 625   if (FRAME_X_P (f))
 626     x_destroy_window (f, displ);
 627 #endif
 628
 629   /* If we've deleted the last_nonminibuf_frame, then try to find
 630      another one.  */
 631   if (f == last_nonminibuf_frame)
 632     {
 633       Lisp_Object frames;
 634
 635       last_nonminibuf_frame = 0;
 636
 637       for (frames = Vframe_list;
 638            CONSP (frames);
 639            frames = XCONS (frames)->cdr)
 640         {
 641           f = XFRAME (XCONS (frames)->car);
 642           if (!FRAME_MINIBUF_ONLY_P (f))
 643             {
 644               last_nonminibuf_frame = f;
 645               break;
 646             }
 647         }
 648     }
 649
 650   /* If we've deleted Vdefault_minibuffer_frame, try to find another
 651      one.  Prefer minibuffer-only frames, but also notice frames
 652      with other windows.  */
 653   if (EQ (frame, Vdefault_minibuffer_frame))
 654     {
 655       Lisp_Object frames;
 656
 657       /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
 658       Lisp_Object frame_with_minibuf = Qnil;
 659
 660       for (frames = Vframe_list;
 661            CONSP (frames);
 662            frames = XCONS (frames)->cdr)
 663         {
 664           Lisp_Object this = XCONS (frames)->car;
 665
 666           if (XTYPE (this) != Lisp_Frame)
 667             abort ();
 668           f = XFRAME (this);
 669
 670           if (FRAME_HAS_MINIBUF_P (f))
 671             {
 672               frame_with_minibuf = this;
 673               if (FRAME_MINIBUF_ONLY_P (f))
 674                 break;
 675             }
 676         }
 677
 678       /* We know that there must be some frame with a minibuffer out
 679          there.  If this were not true, all of the frames present
 680          would have to be minibufferless, which implies that at some
 681          point their minibuffer frames must have been deleted, but
 682          that is prohibited at the top; you can't delete surrogate
 683          minibuffer frames.  */
 684       if (NILP (frame_with_minibuf))
 685         abort ();
 686
 687       Vdefault_minibuffer_frame = frame_with_minibuf;
 688     }
 689
 690   return Qnil;
 691 }
 692 \f
 693 /* Return mouse position in character cell units.  */
 694
 695 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
 696   "Return a list (FRAME X . Y) giving the current mouse frame and position.\n\
 697 If Emacs is running on a mouseless terminal or hasn't been programmed\n\
 698 to read the mouse position, it returns the selected frame for FRAME\n\
 699 and nil for X and Y.")
 700   ()
 701 {
 702   Lisp_Object x, y, dummy;
 703   FRAME_PTR f;
 704
 705   if (mouse_position_hook)
 706     (*mouse_position_hook) (&f, &x, &y, &dummy);
 707   else
 708     {
 709       f = selected_frame;
 710       x = y = Qnil;
 711     }
 712
 713   XSET (dummy, Lisp_Frame, f);
 714   return Fcons (dummy, Fcons (make_number (x), make_number (y)));
 715 }
 716
 717 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
 718   "Move the mouse pointer to the center of cell (X,Y) in FRAME.\n\
 719 WARNING:  If you use this under X, you should do `unfocus-frame' afterwards.")
 720   (frame, x, y)
 721      Lisp_Object frame, x, y;
 722 {
 723   CHECK_LIVE_FRAME (frame, 0);
 724   CHECK_NUMBER (x, 2);
 725   CHECK_NUMBER (y, 1);
 726
 727 #ifdef HAVE_X_WINDOWS
 728   if (FRAME_X_P (XFRAME (frame)))
 729     /* Warping the mouse will cause  enternotify and focus events. */
 730     x_set_mouse_position (XFRAME (frame), x, y);
 731 #endif
 732
 733   return Qnil;
 734 }
 735 \f
 736 #if 0
 737 /* ??? Can this be replaced with a Lisp function?
 738    It is used in minibuf.c.  Can we get rid of that?
 739    Yes.  All uses in minibuf.c are gone, and parallels to these
 740    functions have been defined in frame.el.  */
 741
 742 DEFUN ("frame-configuration", Fframe_configuration, Sframe_configuration,
 743        0, 0, 0,
 744   "Return object describing current frame configuration.\n\
 745 The frame configuration is the current mouse position and selected frame.\n\
 746 This object can be given to `restore-frame-configuration'\n\
 747 to restore this frame configuration.")
 748   ()
 749 {
 750   Lisp_Object c, time;
 751
 752   c = Fmake_vector (make_number(4), Qnil);
 753   XVECTOR (c)->contents[0] = Fselected_frame();
 754   if (mouse_position_hook)
 755     (*mouse_position_hook) (&XVECTOR (c)->contents[1]
 756                             &XVECTOR (c)->contents[2],
 757                             &XVECTOR (c)->contents[3],
 758                             &time);
 759   return c;
 760 }
 761
 762 DEFUN ("restore-frame-configuration", Frestore_frame_configuration,
 763        Srestore_frame_configuration,
 764        1, 1, 0,
 765   "Restores frame configuration CONFIGURATION.")
 766   (config)
 767   Lisp_Object config;
 768 {
 769   Lisp_Object x_pos, y_pos, frame;
 770
 771   CHECK_VECTOR (config, 0);
 772   if (XVECTOR (config)->size != 3)
 773     {
 774       error ("Wrong size vector passed to restore-frame-configuration");
 775     }
 776   frame = XVECTOR (config)->contents[0];
 777   CHECK_LIVE_FRAME (frame, 0);
 778
 779   Fselect_frame (frame, Qnil);
 780
 781 #if 0
 782   /* This seems to interfere with the frame selection mechanism. jla */
 783   x_pos = XVECTOR (config)->contents[2];
 784   y_pos = XVECTOR (config)->contents[3];
 785   set_mouse_position (frame, XINT (x_pos), XINT (y_pos));
 786 #endif
 787
 788   return frame;
 789 }
 790 #endif
 791 \f
 792 DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
 793        0, 1, 0,
 794   "Make the frame FRAME visible (assuming it is an X-window).\n\
 795 Also raises the frame so that nothing obscures it.\n\
 796 If omitted, FRAME defaults to the currently selected frame.")
 797   (frame)
 798      Lisp_Object frame;
 799 {
 800   if (NILP (frame))
 801     XSET (frame, Lisp_Frame, selected_frame);
 802
 803   CHECK_LIVE_FRAME (frame, 0);
 804
 805 #ifdef HAVE_X_WINDOWS
 806   if (FRAME_X_P (XFRAME (frame)))
 807     x_make_frame_visible (XFRAME (frame));
 808 #endif
 809
 810   return frame;
 811 }
 812
 813 DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
 814        0, 1, "",
 815   "Make the frame FRAME invisible (assuming it is an X-window).\n\
 816 If omitted, FRAME defaults to the currently selected frame.")
 817   (frame)
 818      Lisp_Object frame;
 819 {
 820   if (NILP (frame))
 821     XSET (frame, Lisp_Frame, selected_frame);
 822
 823   CHECK_LIVE_FRAME (frame, 0);
 824
 825 #ifdef HAVE_X_WINDOWS
 826   if (FRAME_X_P (XFRAME (frame)))
 827     x_make_frame_invisible (XFRAME (frame));
 828 #endif
 829
 830   return Qnil;
 831 }
 832
 833 DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
 834        0, 1, "",
 835   "Make the frame FRAME into an icon.\n\
 836 If omitted, FRAME defaults to the currently selected frame.")
 837   (frame)
 838      Lisp_Object frame;
 839 {
 840   if (NILP (frame))
 841     XSET (frame, Lisp_Frame, selected_frame);
 842
 843   CHECK_LIVE_FRAME (frame, 0);
 844
 845 #ifdef HAVE_X_WINDOWS
 846   if (FRAME_X_P (XFRAME (frame)))
 847       x_iconify_frame (XFRAME (frame));
 848 #endif
 849
 850   return Qnil;
 851 }
 852
 853 DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
 854        1, 1, 0,
 855        "Return t if FRAME is now \"visible\" (actually in use for display).\n\
 856 A frame that is not \"visible\" is not updated and, if it works through\n\
 857 a window system, it may not show at all.\n\
 858 Return the symbol `icon' if frame is visible only as an icon.")
 859   (frame)
 860      Lisp_Object frame;
 861 {
 862   CHECK_LIVE_FRAME (frame, 0);
 863
 864   if (XFRAME (frame)->visible)
 865     return Qt;
 866   if (XFRAME (frame)->iconified)
 867     return Qicon;
 868   return Qnil;
 869 }
 870
 871 DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
 872        0, 0, 0,
 873        "Return a list of all frames now \"visible\" (being updated).")
 874   ()
 875 {
 876   Lisp_Object tail, frame;
 877   struct frame *f;
 878   Lisp_Object value;
 879
 880   value = Qnil;
 881   for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
 882     {
 883       frame = XCONS (tail)->car;
 884       if (XTYPE (frame) != Lisp_Frame)
 885         continue;
 886       f = XFRAME (frame);
 887       if (f->visible)
 888         value = Fcons (frame, value);
 889     }
 890   return value;
 891 }
 892
 893
 894 \f
 895 DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
 896        1, 2, 0,
 897   "Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.\n\
 898 This means that, after reading a keystroke typed at FRAME,\n\
 899 `last-event-frame' will be FOCUS-FRAME.\n\
 900 \n\
 901 If FOCUS-FRAME is omitted or eq to FRAME, any existing redirection is\n\
 902 cancelled, and the frame again receives its own keystrokes.\n\
 903 \n\
 904 The redirection lasts until the next call to `redirect-frame-focus'\n\
 905 or `select-frame'.\n\
 906 \n\
 907 This is useful for temporarily redirecting keystrokes to the minibuffer\n\
 908 window when a frame doesn't have its own minibuffer.")
 909   (frame, focus_frame)
 910     Lisp_Object frame, focus_frame;
 911 {
 912   CHECK_LIVE_FRAME (frame, 0);
 913
 914   if (NILP (focus_frame))
 915     focus_frame = frame;
 916   else
 917     CHECK_LIVE_FRAME (focus_frame, 1);
 918
 919   XFRAME (frame)->focus_frame = focus_frame;
 920
 921   if (frame_rehighlight_hook)
 922     (*frame_rehighlight_hook) ();
 923
 924   return Qnil;
 925 }
 926
 927
 928 DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
 929   "Return the frame to which FRAME's keystrokes are currently being sent.\n\
 930 See `redirect-frame-focus'.")
 931   (frame)
 932     Lisp_Object frame;
 933 {
 934   CHECK_LIVE_FRAME (frame, 0);
 935   return FRAME_FOCUS_FRAME (XFRAME (frame));
 936 }
 937
 938
 939 \f
 940 Lisp_Object
 941 get_frame_param (frame, prop)
 942      register struct frame *frame;
 943      Lisp_Object prop;
 944 {
 945   register Lisp_Object tem;
 946
 947   tem = Fassq (prop, frame->param_alist);
 948   if (EQ (tem, Qnil))
 949     return tem;
 950   return Fcdr (tem);
 951 }
 952
 953 void
 954 store_in_alist (alistptr, prop, val)
 955      Lisp_Object *alistptr, val;
 956      Lisp_Object prop;
 957 {
 958   register Lisp_Object tem;
 959
 960   tem = Fassq (prop, *alistptr);
 961   if (EQ (tem, Qnil))
 962     *alistptr = Fcons (Fcons (prop, val), *alistptr);
 963   else
 964     Fsetcdr (tem, val);
 965 }
 966
 967 void
 968 store_frame_param (f, prop, val)
 969      struct frame *f;
 970      Lisp_Object prop, val;
 971 {
 972   register Lisp_Object tem;
 973
 974   tem = Fassq (prop, f->param_alist);
 975   if (EQ (tem, Qnil))
 976     f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
 977   else
 978     Fsetcdr (tem, val);
 979
 980   if (EQ (prop, Qminibuffer)
 981       && XTYPE (val) == Lisp_Window)
 982     {
 983       if (! MINI_WINDOW_P (XWINDOW (val)))
 984         error ("Surrogate minibuffer windows must be minibuffer windows.");
 985
 986       if (FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
 987         error ("Can't change the surrogate minibuffer of a frame with its own minibuffer.");
 988
 989       /* Install the chosen minibuffer window, with proper buffer.  */
 990       f->minibuffer_window = val;
 991     }
 992 }
 993
 994 DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
 995   "Return the parameters-alist of frame FRAME.\n\
 996 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.\n\
 997 The meaningful PARMs depend on the kind of frame.\n\
 998 If FRAME is omitted, return information on the currently selected frame.")
 999   (frame)
1000      Lisp_Object frame;
1001 {
1002   Lisp_Object alist;
1003   struct frame *f;
1004
1005   if (EQ (frame, Qnil))
1006     f = selected_frame;
1007   else
1008     {
1009       CHECK_FRAME (frame, 0);
1010       f = XFRAME (frame);
1011     }
1012
1013   if (f->display.nothing == 0)
1014     return Qnil;
1015
1016   alist = Fcopy_alist (f->param_alist);
1017   store_in_alist (&alist, Qname, f->name);
1018   store_in_alist (&alist, Qheight, make_number (f->height));
1019   store_in_alist (&alist, Qwidth, make_number (f->width));
1020   store_in_alist (&alist, Qmodeline, (f->wants_modeline ? Qt : Qnil));
1021   store_in_alist (&alist, Qminibuffer,
1022                   (! FRAME_HAS_MINIBUF_P (f) ? Qnone
1023                    : (FRAME_MINIBUF_ONLY_P (f) ? Qonly
1024                    : FRAME_MINIBUF_WINDOW (f))));
1025   store_in_alist (&alist, Qunsplittable, (f->no_split ? Qt : Qnil));
1026
1027 #ifdef HAVE_X_WINDOWS
1028   if (FRAME_X_P (f))
1029     x_report_frame_params (f, &alist);
1030 #endif
1031   return alist;
1032 }
1033
1034 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
1035        Smodify_frame_parameters, 2, 2, 0,
1036   "Modify the parameters of frame FRAME according to ALIST.\n\
1037 ALIST is an alist of parameters to change and their new values.\n\
1038 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.\n\
1039 The meaningful PARMs depend on the kind of frame; undefined PARMs are ignored.")
1040   (frame, alist)
1041      Lisp_Object frame, alist;
1042 {
1043   FRAME_PTR f;
1044   register Lisp_Object tail, elt, prop, val;
1045
1046   if (EQ (frame, Qnil))
1047     f = selected_frame;
1048   else
1049     {
1050       CHECK_LIVE_FRAME (frame, 0);
1051       f = XFRAME (frame);
1052     }
1053
1054 #ifdef HAVE_X_WINDOWS
1055   if (FRAME_X_P (f))
1056 #if 1
1057     x_set_frame_parameters (f, alist);
1058 #else
1059     for (tail = alist; !EQ (tail, Qnil); tail = Fcdr (tail))
1060       {
1061         elt = Fcar (tail);
1062         prop = Fcar (elt);
1063         val = Fcdr (elt);
1064         x_set_frame_param (f, prop, val, get_frame_param (f, prop));
1065         store_frame_param (f, prop, val);
1066       }
1067 #endif
1068 #endif
1069
1070   return Qnil;
1071 }
1072 \f
1073
1074 #if 0
1075 /* This function isn't useful enough by itself to include; we need to
1076    add functions to allow the user to find the size of a font before
1077    this is actually useful.  */
1078
1079 DEFUN ("frame-pixel-size", Fframe_pixel_size,
1080        Sframe_pixel_size, 1, 1, 0,
1081   "Return a cons (width . height) of FRAME's size in pixels.")
1082   (frame)
1083      Lisp_Object frame;
1084 {
1085   register struct frame *f;
1086   int width, height;
1087
1088   CHECK_LIVE_FRAME (frame, 0);
1089   f = XFRAME (frame);
1090
1091   return Fcons (make_number (x_pixel_width (f)),
1092                 make_number (x_pixel_height (f)));
1093 }
1094 #endif
1095
1096 #if 0
1097 /* These functions have no C callers, and can be written nicely in lisp.  */
1098
1099 DEFUN ("frame-height", Fframe_height, Sframe_height, 0, 0, 0,
1100   "Return number of lines available for display on selected frame.")
1101   ()
1102 {
1103   return make_number (FRAME_HEIGHT (selected_frame));
1104 }
1105
1106 DEFUN ("frame-width", Fframe_width, Sframe_width, 0, 0, 0,
1107   "Return number of columns available for display on selected frame.")
1108   ()
1109 {
1110   return make_number (FRAME_WIDTH (selected_frame));
1111 }
1112 #endif
1113
1114 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
1115   "Specify that the frame FRAME has LINES lines.\n\
1116 Optional third arg non-nil means that redisplay should use LINES lines\n\
1117 but that the idea of the actual height of the frame should not be changed.")
1118   (frame, rows, pretend)
1119      Lisp_Object frame, rows, pretend;
1120 {
1121   register struct frame *f;
1122
1123   CHECK_NUMBER (rows, 0);
1124   if (NILP (frame))
1125     f = selected_frame;
1126   else
1127     {
1128       CHECK_LIVE_FRAME (frame, 0);
1129       f = XFRAME (frame);
1130     }
1131
1132 #ifdef HAVE_X_WINDOWS
1133   if (FRAME_X_P (f))
1134     {
1135       if (XINT (rows) != f->width)
1136         x_set_window_size (f, f->width, XINT (rows));
1137     }
1138   else
1139 #endif
1140     change_frame_size (f, XINT (rows), 0, !NILP (pretend), 0);
1141   return Qnil;
1142 }
1143
1144 DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
1145   "Specify that the frame FRAME has COLS columns.\n\
1146 Optional third arg non-nil means that redisplay should use COLS columns\n\
1147 but that the idea of the actual width of the frame should not be changed.")
1148   (frame, cols, pretend)
1149      Lisp_Object frame, cols, pretend;
1150 {
1151   register struct frame *f;
1152   CHECK_NUMBER (cols, 0);
1153   if (NILP (frame))
1154     f = selected_frame;
1155   else
1156     {
1157       CHECK_LIVE_FRAME (frame, 0);
1158       f = XFRAME (frame);
1159     }
1160
1161 #ifdef HAVE_X_WINDOWS
1162   if (FRAME_X_P (f))
1163     {
1164       if (XINT (cols) != f->width)
1165         x_set_window_size (f, XINT (cols), f->height);
1166     }
1167   else
1168 #endif
1169     change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0);
1170   return Qnil;
1171 }
1172
1173 DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
1174   "Sets size of FRAME to COLS by ROWS, measured in characters.")
1175   (frame, cols, rows)
1176      Lisp_Object frame, cols, rows;
1177 {
1178   register struct frame *f;
1179   int mask;
1180
1181   CHECK_LIVE_FRAME (frame, 0);
1182   CHECK_NUMBER (cols, 2);
1183   CHECK_NUMBER (rows, 1);
1184   f = XFRAME (frame);
1185
1186 #ifdef HAVE_X_WINDOWS
1187   if (FRAME_X_P (f))
1188     {
1189       if (XINT (rows) != f->height || XINT (cols) != f->width)
1190         x_set_window_size (f, XINT (cols), XINT (rows));
1191     }
1192   else
1193 #endif
1194     change_frame_size (f, XINT (rows), XINT (cols), 0, 0);
1195
1196   return Qnil;
1197 }
1198
1199 DEFUN ("set-frame-position", Fset_frame_position,
1200        Sset_frame_position, 3, 3, 0,
1201   "Sets position of FRAME in pixels to XOFFSET by YOFFSET.\n\
1202 If XOFFSET or YOFFSET are negative, they are interpreted relative to\n\
1203 the leftmost or bottommost position FRAME could occupy without going\n\
1204 off the screen.")
1205   (frame, xoffset, yoffset)
1206      Lisp_Object frame, xoffset, yoffset;
1207 {
1208   register struct frame *f;
1209   int mask;
1210
1211   CHECK_LIVE_FRAME (frame, 0);
1212   CHECK_NUMBER (xoffset, 1);
1213   CHECK_NUMBER (yoffset, 2);
1214   f = XFRAME (frame);
1215
1216 #ifdef HAVE_X_WINDOWS
1217   if (FRAME_X_P (f))
1218     x_set_offset (f, XINT (xoffset), XINT (yoffset));
1219 #endif
1220
1221   return Qt;
1222 }
1223
1224 \f
1225 #ifndef HAVE_X11
1226 DEFUN ("rubber-band-rectangle", Frubber_band_rectangle, Srubber_band_rectangle,
1227        3, 3, "",
1228   "Ask user to specify a window position and size on FRAME with the mouse.\n\
1229 Arguments are FRAME, NAME and GEO.  NAME is a name to be displayed as\n\
1230 the purpose of this rectangle.  GEO is an X-windows size spec that can\n\
1231 specify defaults for some sizes/positions.  If GEO specifies everything,\n\
1232 the mouse is not used.\n\
1233 Returns a list of five values: (FRAME LEFT TOP WIDTH HEIGHT).")
1234   (frame, name, geo)
1235      Lisp_Object frame;
1236      Lisp_Object name;
1237      Lisp_Object geo;
1238 {
1239   int vals[4];
1240   Lisp_Object nums[4];
1241   int i;
1242
1243   CHECK_FRAME (frame, 0);
1244   CHECK_STRING (name, 1);
1245   CHECK_STRING (geo, 2);
1246
1247   switch (XFRAME (frame)->output_method)
1248     {
1249     case output_x_window:
1250       x_rubber_band (XFRAME (frame), &vals[0], &vals[1], &vals[2], &vals[3],
1251                      XSTRING (geo)->data, XSTRING (name)->data);
1252       break;
1253
1254     default:
1255       return Qnil;
1256     }
1257
1258   for (i = 0; i < 4; i++)
1259     XFASTINT (nums[i]) = vals[i];
1260   return Fcons (frame, Flist (4, nums));
1261   return Qnil;
1262 }
1263 #endif /* not HAVE_X11 */
1264 \f
1265 choose_minibuf_frame ()
1266 {
1267   /* For lowest-level minibuf, put it on currently selected frame
1268      if frame has a minibuffer.  */
1269
1270   if (minibuf_level == 0
1271       && selected_frame != 0
1272       && !EQ (minibuf_window, selected_frame->minibuffer_window))
1273     {
1274       /* I don't think that any frames may validly have a null minibuffer
1275          window anymore.  */
1276       if (NILP (selected_frame->minibuffer_window))
1277         abort ();
1278
1279       Fset_window_buffer (selected_frame->minibuffer_window,
1280                           XWINDOW (minibuf_window)->buffer);
1281       minibuf_window = selected_frame->minibuffer_window;
1282     }
1283 }
1284 \f
1285 syms_of_frame ()
1286 {
1287   /*&&& init symbols here &&&*/
1288   Qframep = intern ("framep");
1289   staticpro (&Qframep);
1290   Qlive_frame_p = intern ("live-frame-p");
1291   staticpro (&Qlive_frame_p);
1292   Qheight = intern ("height");
1293   staticpro (&Qheight);
1294   Qicon = intern ("icon");
1295   staticpro (&Qicon);
1296   Qminibuffer = intern ("minibuffer");
1297   staticpro (&Qminibuffer);
1298   Qmodeline = intern ("modeline");
1299   staticpro (&Qmodeline);
1300   Qname = intern ("name");
1301   staticpro (&Qname);
1302   Qnone = intern ("none");
1303   staticpro (&Qnone);
1304   Qonly = intern ("only");
1305   staticpro (&Qonly);
1306   Qunsplittable = intern ("unsplittable");
1307   staticpro (&Qunsplittable);
1308   Qwidth = intern ("width");
1309   staticpro (&Qwidth);
1310   Qx = intern ("x");
1311   staticpro (&Qx);
1312
1313   staticpro (&Vframe_list);
1314
1315   DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
1316     "The initial frame-object, which represents Emacs's stdout.");
1317
1318   DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
1319     "Non-nil if all of emacs is iconified and frame updates are not needed.");
1320   Vemacs_iconified = Qnil;
1321
1322   DEFVAR_LISP ("default-minibuffer-frame", &Vdefault_minibuffer_frame,
1323     "Minibufferless frames use this frame's minibuffer.\n\
1324 \n\
1325 Emacs cannot create minibufferless frames unless this is set to an\n\
1326 appropriate surrogate.\n\
1327 \n\
1328 Emacs consults this variable only when creating minibufferless\n\
1329 frames; once the frame is created, it sticks with its assigned\n\
1330 minibuffer, no matter what this variable is set to.  This means that\n\
1331 this variable doesn't necessarily say anything meaningful about the\n\
1332 current set of frames, or where the minibuffer is currently being\n\
1333 displayed.");
1334   Vdefault_minibuffer_frame = Qnil;
1335
1336   DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
1337     "Alist of default values for frame creation.\n\
1338 These may be set in your init file, like this:\n\
1339   (setq default-frame-alist '((width . 80) (height . 55)))\n\
1340 These override values given in window system configuration data, like\n\
1341 X Windows' defaults database.\n\
1342 For values specific to the first Emacs frame, see `initial-frame-alist'.\n\
1343 For values specific to the separate minibuffer frame, see\n\
1344 `minibuffer-frame-alist'.");
1345   Vdefault_frame_alist = Qnil;
1346
1347   defsubr (&Sframep);
1348   defsubr (&Slive_frame_p);
1349   defsubr (&Sselect_frame);
1350   defsubr (&Sselected_frame);
1351   defsubr (&Swindow_frame);
1352   defsubr (&Sframe_root_window);
1353   defsubr (&Sframe_selected_window);
1354   defsubr (&Sframe_list);
1355   defsubr (&Snext_frame);
1356   defsubr (&Sdelete_frame);
1357   defsubr (&Smouse_position);
1358   defsubr (&Sset_mouse_position);
1359 #if 0
1360   defsubr (&Sframe_configuration);
1361   defsubr (&Srestore_frame_configuration);
1362 #endif
1363   defsubr (&Smake_frame_visible);
1364   defsubr (&Smake_frame_invisible);
1365   defsubr (&Siconify_frame);
1366   defsubr (&Sframe_visible_p);
1367   defsubr (&Svisible_frame_list);
1368   defsubr (&Sredirect_frame_focus);
1369   defsubr (&Sframe_focus);
1370   defsubr (&Sframe_parameters);
1371   defsubr (&Smodify_frame_parameters);
1372 #if 0
1373   defsubr (&Sframe_pixel_size);
1374   defsubr (&Sframe_height);
1375   defsubr (&Sframe_width);
1376 #endif
1377   defsubr (&Sset_frame_height);
1378   defsubr (&Sset_frame_width);
1379   defsubr (&Sset_frame_size);
1380   defsubr (&Sset_frame_position);
1381 #ifndef HAVE_X11
1382   defsubr (&Srubber_band_rectangle);
1383 #endif  /* HAVE_X11 */
1384 }
1385
1386 keys_of_frame ()
1387 {
1388   initial_define_lispy_key (global_map, "switch-frame", "select-frame");
1389 }
1390
1391 #else /* not MULTI_FRAME */
1392
1393 /* If we're not using multi-frame stuff, we still need to provide some
1394    support functions.  */
1395
1396 /* Unless this function is defined, providing set-frame-height and
1397    set-frame-width doesn't help compatibility any, since they both
1398    want this as their first argument.  */
1399 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
1400   "Return the frame that is now selected.")
1401   ()
1402 {
1403   Lisp_Object tem;
1404   XFASTINT (tem) = 0;
1405   return tem;
1406 }
1407
1408 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
1409   "Specify that the frame FRAME has LINES lines.\n\
1410 Optional third arg non-nil means that redisplay should use LINES lines\n\
1411 but that the idea of the actual height of the frame should not be changed.")
1412   (frame, rows, pretend)
1413      Lisp_Object frame, rows, pretend;
1414 {
1415   CHECK_NUMBER (rows, 0);
1416
1417   change_frame_size (0, XINT (rows), 0, !NILP (pretend), 0);
1418   return Qnil;
1419 }
1420
1421 DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
1422   "Specify that the frame FRAME has COLS columns.\n\
1423 Optional third arg non-nil means that redisplay should use COLS columns\n\
1424 but that the idea of the actual width of the frame should not be changed.")
1425   (frame, cols, pretend)
1426      Lisp_Object frame, cols, pretend;
1427 {
1428   CHECK_NUMBER (cols, 0);
1429
1430   change_frame_size (0, 0, XINT (cols), !NILP (pretend), 0);
1431   return Qnil;
1432 }
1433
1434 DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
1435   "Sets size of FRAME to COLS by ROWS, measured in characters.")
1436   (frame, cols, rows)
1437      Lisp_Object frame, cols, rows;
1438 {
1439   CHECK_NUMBER (cols, 2);
1440   CHECK_NUMBER (rows, 1);
1441
1442   change_frame_size (0, XINT (rows), XINT (cols), 0, 0);
1443
1444   return Qnil;
1445 }
1446
1447 DEFUN ("frame-height", Fframe_height, Sframe_height, 0, 0, 0,
1448   "Return number of lines available for display on selected frame.")
1449   ()
1450 {
1451   return make_number (FRAME_HEIGHT (selected_frame));
1452 }
1453
1454 DEFUN ("frame-width", Fframe_width, Sframe_width, 0, 0, 0,
1455   "Return number of columns available for display on selected frame.")
1456   ()
1457 {
1458   return make_number (FRAME_WIDTH (selected_frame));
1459 }
1460
1461 /* These are for backward compatibility with Emacs 18.  */
1462
1463 DEFUN ("set-screen-height", Fset_screen_height, Sset_screen_height, 1, 2, 0,
1464   "Tell redisplay that the screen has LINES lines.\n\
1465 Optional second arg non-nil means that redisplay should use LINES lines\n\
1466 but that the idea of the actual height of the screen should not be changed.")
1467   (lines, pretend)
1468      Lisp_Object lines, pretend;
1469 {
1470   CHECK_NUMBER (lines, 0);
1471
1472   change_frame_size (0, XINT (lines), 0, !NILP (pretend), 0);
1473   return Qnil;
1474 }
1475
1476 DEFUN ("set-screen-width", Fset_screen_width, Sset_screen_width, 1, 2, 0,
1477   "Tell redisplay that the screen has COLS columns.\n\
1478 Optional second arg non-nil means that redisplay should use COLS columns\n\
1479 but that the idea of the actual width of the screen should not be changed.")
1480   (cols, pretend)
1481      Lisp_Object cols, pretend;
1482 {
1483   CHECK_NUMBER (cols, 0);
1484
1485   change_frame_size (0, 0, XINT (cols), !NILP (pretend), 0);
1486   return Qnil;
1487 }
1488
1489 syms_of_frame ()
1490 {
1491   defsubr (&Sset_frame_height);
1492   defsubr (&Sset_frame_width);
1493   defsubr (&Sset_frame_size);
1494   defsubr (&Sset_screen_height);
1495   defsubr (&Sset_screen_width);
1496   defsubr (&Sframe_height);
1497   Ffset (intern ("screen-height"), intern ("frame-height"));
1498   defsubr (&Sframe_width);
1499   Ffset (intern ("screen-width"), intern ("frame-width"));
1500 }
1501
1502 keys_of_frame ()
1503 {
1504 }
1505
1506 #endif /* not MULTI_FRAME */
1507
1508
1509
1510