src/terminal.c

   1 /* Functions related to terminal devices.
   2    Copyright (C) 2005-2014 Free Software Foundation, Inc.
   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 3 of the License, or
   9 (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22
  23 #include "lisp.h"
  24 #include "frame.h"
  25 #include "termchar.h"
  26 #include "termhooks.h"
  27 #include "charset.h"
  28 #include "coding.h"
  29 #include "keyboard.h"
  30
  31 /* Chain of all terminals currently in use. */
  32 struct terminal *terminal_list;
  33
  34 /* The first unallocated terminal id. */
  35 static int next_terminal_id;
  36
  37 /* The initial terminal device, created by initial_term_init. */
  38 struct terminal *initial_terminal;
  39
  40 static Lisp_Object Qterminal_live_p;
  41
  42 static void delete_initial_terminal (struct terminal *);
  43
  44 /* This setter is used only in this file, so it can be private.  */
  45 static void
  46 tset_param_alist (struct terminal *t, Lisp_Object val)
  47 {
  48   t->param_alist = val;
  49 }
  50
  51 \f
  52
  53 void
  54 ring_bell (struct frame *f)
  55 {
  56   if (!NILP (Vring_bell_function))
  57     {
  58       Lisp_Object function;
  59
  60       /* Temporarily set the global variable to nil
  61          so that if we get an error, it stays nil
  62          and we don't call it over and over.
  63
  64          We don't specbind it, because that would carefully
  65          restore the bad value if there's an error
  66          and make the loop of errors happen anyway.  */
  67
  68       function = Vring_bell_function;
  69       Vring_bell_function = Qnil;
  70
  71       call0 (function);
  72
  73       Vring_bell_function = function;
  74     }
  75   else if (FRAME_TERMINAL (f)->ring_bell_hook)
  76     (*FRAME_TERMINAL (f)->ring_bell_hook) (f);
  77 }
  78
  79 void
  80 update_begin (struct frame *f)
  81 {
  82   if (FRAME_TERMINAL (f)->update_begin_hook)
  83     (*FRAME_TERMINAL (f)->update_begin_hook) (f);
  84 }
  85
  86 void
  87 update_end (struct frame *f)
  88 {
  89   if (FRAME_TERMINAL (f)->update_end_hook)
  90     (*FRAME_TERMINAL (f)->update_end_hook) (f);
  91 }
  92
  93 /* Specify how many text lines, from the top of the window,
  94    should be affected by insert-lines and delete-lines operations.
  95    This, and those operations, are used only within an update
  96    that is bounded by calls to update_begin and update_end.  */
  97
  98 void
  99 set_terminal_window (struct frame *f, int size)
 100 {
 101   if (FRAME_TERMINAL (f)->set_terminal_window_hook)
 102     (*FRAME_TERMINAL (f)->set_terminal_window_hook) (f, size);
 103 }
 104
 105 /* Move cursor to row/column position VPOS/HPOS.  HPOS/VPOS are
 106    frame-relative coordinates.  */
 107
 108 void
 109 cursor_to (struct frame *f, int vpos, int hpos)
 110 {
 111   if (FRAME_TERMINAL (f)->cursor_to_hook)
 112     (*FRAME_TERMINAL (f)->cursor_to_hook) (f, vpos, hpos);
 113 }
 114
 115 /* Similar but don't take any account of the wasted characters.  */
 116
 117 void
 118 raw_cursor_to (struct frame *f, int row, int col)
 119 {
 120   if (FRAME_TERMINAL (f)->raw_cursor_to_hook)
 121     (*FRAME_TERMINAL (f)->raw_cursor_to_hook) (f, row, col);
 122 }
 123
 124 /* Erase operations */
 125
 126 /* Clear from cursor to end of frame. */
 127 void
 128 clear_to_end (struct frame *f)
 129 {
 130   if (FRAME_TERMINAL (f)->clear_to_end_hook)
 131     (*FRAME_TERMINAL (f)->clear_to_end_hook) (f);
 132 }
 133
 134 /* Clear entire frame */
 135
 136 void
 137 clear_frame (struct frame *f)
 138 {
 139   if (FRAME_TERMINAL (f)->clear_frame_hook)
 140     (*FRAME_TERMINAL (f)->clear_frame_hook) (f);
 141 }
 142
 143 /* Clear from cursor to end of line.
 144    Assume that the line is already clear starting at column first_unused_hpos.
 145
 146    Note that the cursor may be moved, on terminals lacking a `ce' string.  */
 147
 148 void
 149 clear_end_of_line (struct frame *f, int first_unused_hpos)
 150 {
 151   if (FRAME_TERMINAL (f)->clear_end_of_line_hook)
 152     (*FRAME_TERMINAL (f)->clear_end_of_line_hook) (f, first_unused_hpos);
 153 }
 154
 155 /* Output LEN glyphs starting at STRING at the nominal cursor position.
 156    Advance the nominal cursor over the text.  */
 157
 158 void
 159 write_glyphs (struct frame *f, struct glyph *string, int len)
 160 {
 161   if (FRAME_TERMINAL (f)->write_glyphs_hook)
 162     (*FRAME_TERMINAL (f)->write_glyphs_hook) (f, string, len);
 163 }
 164
 165 /* Insert LEN glyphs from START at the nominal cursor position.
 166
 167    If start is zero, insert blanks instead of a string at start */
 168
 169 void
 170 insert_glyphs (struct frame *f, struct glyph *start, int len)
 171 {
 172   if (len <= 0)
 173     return;
 174
 175   if (FRAME_TERMINAL (f)->insert_glyphs_hook)
 176     (*FRAME_TERMINAL (f)->insert_glyphs_hook) (f, start, len);
 177 }
 178
 179 /* Delete N glyphs at the nominal cursor position. */
 180
 181 void
 182 delete_glyphs (struct frame *f, int n)
 183 {
 184   if (FRAME_TERMINAL (f)->delete_glyphs_hook)
 185     (*FRAME_TERMINAL (f)->delete_glyphs_hook) (f, n);
 186 }
 187
 188 /* Insert N lines at vpos VPOS.  If N is negative, delete -N lines.  */
 189
 190 void
 191 ins_del_lines (struct frame *f, int vpos, int n)
 192 {
 193   if (FRAME_TERMINAL (f)->ins_del_lines_hook)
 194     (*FRAME_TERMINAL (f)->ins_del_lines_hook) (f, vpos, n);
 195 }
 196
 197
 198 \f
 199
 200 /* Return the terminal object specified by TERMINAL.  TERMINAL may be
 201    a terminal object, a frame, or nil for the terminal device of the
 202    current frame.  If THROW is false, return NULL for failure,
 203    otherwise throw an error.  */
 204
 205 struct terminal *
 206 get_terminal (Lisp_Object terminal, bool throw)
 207 {
 208   struct terminal *result = NULL;
 209
 210   if (NILP (terminal))
 211     terminal = selected_frame;
 212
 213   if (TERMINALP (terminal))
 214     result = XTERMINAL (terminal);
 215   else if (FRAMEP (terminal))
 216     result = FRAME_TERMINAL (XFRAME (terminal));
 217
 218   if (result && !result->name)
 219     result = NULL;
 220
 221   if (result == NULL && throw)
 222     wrong_type_argument (Qterminal_live_p, terminal);
 223
 224   return result;
 225 }
 226
 227 /* Create a new terminal object of TYPE and add it to the terminal list.  RIF
 228    may be NULL if this terminal type doesn't support window-based redisplay.  */
 229
 230 struct terminal *
 231 create_terminal (enum output_method type, struct redisplay_interface *rif)
 232 {
 233   struct terminal *terminal = allocate_terminal ();
 234   Lisp_Object terminal_coding, keyboard_coding;
 235
 236   terminal->next_terminal = terminal_list;
 237   terminal_list = terminal;
 238   terminal->type = type;
 239   terminal->rif = rif;
 240   terminal->id = next_terminal_id++;
 241
 242   terminal->keyboard_coding = xmalloc (sizeof (struct coding_system));
 243   terminal->terminal_coding = xmalloc (sizeof (struct coding_system));
 244
 245   /* If default coding systems for the terminal and the keyboard are
 246      already defined, use them in preference to the defaults.  This is
 247      needed when Emacs runs in daemon mode.  */
 248   keyboard_coding =
 249     find_symbol_value (intern ("default-keyboard-coding-system"));
 250   if (NILP (keyboard_coding)
 251       || EQ (keyboard_coding, Qunbound)
 252       || NILP (Fcoding_system_p (keyboard_coding)))
 253     keyboard_coding = Qno_conversion;
 254   terminal_coding =
 255     find_symbol_value (intern ("default-terminal-coding-system"));
 256   if (NILP (terminal_coding)
 257       || EQ (terminal_coding, Qunbound)
 258       || NILP (Fcoding_system_p (terminal_coding)))
 259     terminal_coding = Qundecided;
 260
 261   setup_coding_system (keyboard_coding, terminal->keyboard_coding);
 262   setup_coding_system (terminal_coding, terminal->terminal_coding);
 263
 264   return terminal;
 265 }
 266
 267 /* Low-level function to close all frames on a terminal, remove it
 268    from the terminal list and free its memory.  */
 269
 270 void
 271 delete_terminal (struct terminal *terminal)
 272 {
 273   struct terminal **tp;
 274   Lisp_Object tail, frame;
 275
 276   /* Protect against recursive calls.  delete_frame calls the
 277      delete_terminal_hook when we delete our last frame.  */
 278   if (!terminal->name)
 279     return;
 280   xfree (terminal->name);
 281   terminal->name = NULL;
 282
 283   /* Check for live frames that are still on this terminal.  */
 284   FOR_EACH_FRAME (tail, frame)
 285     {
 286       struct frame *f = XFRAME (frame);
 287       if (FRAME_LIVE_P (f) && f->terminal == terminal)
 288         {
 289           /* Pass Qnoelisp rather than Qt.  */
 290           delete_frame (frame, Qnoelisp);
 291         }
 292     }
 293
 294   for (tp = &terminal_list; *tp != terminal; tp = &(*tp)->next_terminal)
 295     if (! *tp)
 296       emacs_abort ();
 297   *tp = terminal->next_terminal;
 298
 299   xfree (terminal->keyboard_coding);
 300   terminal->keyboard_coding = NULL;
 301   xfree (terminal->terminal_coding);
 302   terminal->terminal_coding = NULL;
 303
 304   if (terminal->kboard && --terminal->kboard->reference_count == 0)
 305     {
 306       delete_kboard (terminal->kboard);
 307       terminal->kboard = NULL;
 308     }
 309 }
 310
 311 Lisp_Object Qrun_hook_with_args;
 312 static Lisp_Object Qdelete_terminal_functions;
 313 DEFUN ("delete-terminal", Fdelete_terminal, Sdelete_terminal, 0, 2, 0,
 314        doc: /* Delete TERMINAL by deleting all frames on it and closing the terminal.
 315 TERMINAL may be a terminal object, a frame, or nil (meaning the
 316 selected frame's terminal).
 317
 318 Normally, you may not delete a display if all other displays are suspended,
 319 but if the second argument FORCE is non-nil, you may do so. */)
 320   (Lisp_Object terminal, Lisp_Object force)
 321 {
 322   struct terminal *t = get_terminal (terminal, 0);
 323
 324   if (!t)
 325     return Qnil;
 326
 327   if (NILP (force))
 328     {
 329       struct terminal *p = terminal_list;
 330       while (p && (p == t || !TERMINAL_ACTIVE_P (p)))
 331         p = p->next_terminal;
 332
 333       if (!p)
 334         error ("Attempt to delete the sole active display terminal");
 335     }
 336
 337   if (NILP (Vrun_hooks))
 338     ;
 339   else if (EQ (force, Qnoelisp))
 340     pending_funcalls
 341       = Fcons (list3 (Qrun_hook_with_args,
 342                       Qdelete_terminal_functions, terminal),
 343                pending_funcalls);
 344   else
 345     safe_call2 (Qrun_hook_with_args, Qdelete_terminal_functions, terminal);
 346
 347   if (t->delete_terminal_hook)
 348     (*t->delete_terminal_hook) (t);
 349   else
 350     delete_terminal (t);
 351
 352   return Qnil;
 353 }
 354
 355 \f
 356 DEFUN ("frame-terminal", Fframe_terminal, Sframe_terminal, 0, 1, 0,
 357        doc: /* Return the terminal that FRAME is displayed on.
 358 If FRAME is nil, the selected frame is used.
 359
 360 The terminal device is represented by its integer identifier.  */)
 361   (Lisp_Object frame)
 362 {
 363   struct terminal *t = FRAME_TERMINAL (decode_live_frame (frame));
 364
 365   if (!t)
 366     return Qnil;
 367   else
 368     {
 369       Lisp_Object terminal;
 370       XSETTERMINAL (terminal, t);
 371       return terminal;
 372     }
 373 }
 374
 375 DEFUN ("terminal-live-p", Fterminal_live_p, Sterminal_live_p, 1, 1, 0,
 376        doc: /* Return non-nil if OBJECT is a terminal which has not been deleted.
 377 Value is nil if OBJECT is not a live display terminal.
 378 If object is a live display terminal, the return value indicates what
 379 sort of output terminal it uses.  See the documentation of `framep' for
 380 possible return values.  */)
 381   (Lisp_Object object)
 382 {
 383   struct terminal *t;
 384
 385   t = get_terminal (object, 0);
 386
 387   if (!t)
 388     return Qnil;
 389
 390   switch (t->type)
 391     {
 392     case output_initial: /* The initial frame is like a termcap frame. */
 393     case output_termcap:
 394       return Qt;
 395     case output_x_window:
 396       return Qx;
 397     case output_w32:
 398       return Qw32;
 399     case output_msdos_raw:
 400       return Qpc;
 401     case output_ns:
 402       return Qns;
 403     default:
 404       emacs_abort ();
 405     }
 406 }
 407
 408 DEFUN ("terminal-list", Fterminal_list, Sterminal_list, 0, 0, 0,
 409        doc: /* Return a list of all terminal devices.  */)
 410   (void)
 411 {
 412   Lisp_Object terminal, terminals = Qnil;
 413   struct terminal *t;
 414
 415   for (t = terminal_list; t; t = t->next_terminal)
 416     {
 417       XSETTERMINAL (terminal, t);
 418       terminals = Fcons (terminal, terminals);
 419     }
 420
 421   return terminals;
 422 }
 423
 424 DEFUN ("terminal-name", Fterminal_name, Sterminal_name, 0, 1, 0,
 425        doc: /* Return the name of the terminal device TERMINAL.
 426 It is not guaranteed that the returned value is unique among opened devices.
 427
 428 TERMINAL may be a terminal object, a frame, or nil (meaning the
 429 selected frame's terminal). */)
 430   (Lisp_Object terminal)
 431 {
 432   struct terminal *t
 433     = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
 434
 435   return t->name ? build_string (t->name) : Qnil;
 436 }
 437
 438
 439 \f
 440 /* Set the value of terminal parameter PARAMETER in terminal D to VALUE.
 441    Return the previous value.  */
 442
 443 static Lisp_Object
 444 store_terminal_param (struct terminal *t, Lisp_Object parameter, Lisp_Object value)
 445 {
 446   Lisp_Object old_alist_elt = Fassq (parameter, t->param_alist);
 447   if (EQ (old_alist_elt, Qnil))
 448     {
 449       tset_param_alist (t, Fcons (Fcons (parameter, value), t->param_alist));
 450       return Qnil;
 451     }
 452   else
 453     {
 454       Lisp_Object result = Fcdr (old_alist_elt);
 455       Fsetcdr (old_alist_elt, value);
 456       return result;
 457     }
 458 }
 459
 460
 461 DEFUN ("terminal-parameters", Fterminal_parameters, Sterminal_parameters, 0, 1, 0,
 462        doc: /* Return the parameter-alist of terminal TERMINAL.
 463 The value is a list of elements of the form (PARM . VALUE), where PARM
 464 is a symbol.
 465
 466 TERMINAL can be a terminal object, a frame, or nil (meaning the
 467 selected frame's terminal).  */)
 468   (Lisp_Object terminal)
 469 {
 470   struct terminal *t
 471     = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
 472   return Fcopy_alist (t->param_alist);
 473 }
 474
 475 DEFUN ("terminal-parameter", Fterminal_parameter, Sterminal_parameter, 2, 2, 0,
 476        doc: /* Return TERMINAL's value for parameter PARAMETER.
 477 TERMINAL can be a terminal object, a frame, or nil (meaning the
 478 selected frame's terminal).  */)
 479   (Lisp_Object terminal, Lisp_Object parameter)
 480 {
 481   Lisp_Object value;
 482   struct terminal *t
 483     = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
 484   CHECK_SYMBOL (parameter);
 485   value = Fcdr (Fassq (parameter, t->param_alist));
 486   return value;
 487 }
 488
 489 DEFUN ("set-terminal-parameter", Fset_terminal_parameter,
 490        Sset_terminal_parameter, 3, 3, 0,
 491        doc: /* Set TERMINAL's value for parameter PARAMETER to VALUE.
 492 Return the previous value of PARAMETER.
 493
 494 TERMINAL can be a terminal object, a frame or nil (meaning the
 495 selected frame's terminal).  */)
 496   (Lisp_Object terminal, Lisp_Object parameter, Lisp_Object value)
 497 {
 498   struct terminal *t
 499     = TERMINALP (terminal) ? XTERMINAL (terminal) : get_terminal (terminal, 1);
 500   return store_terminal_param (t, parameter, value);
 501 }
 502
 503 /* Initial frame has no device-dependent output data, but has
 504    face cache which should be freed when the frame is deleted.  */
 505
 506 static void
 507 initial_free_frame_resources (struct frame *f)
 508 {
 509   eassert (FRAME_INITIAL_P (f));
 510   free_frame_faces (f);
 511 }
 512
 513 /* Create the bootstrap display terminal for the initial frame.
 514    Returns a terminal of type output_initial.  */
 515
 516 struct terminal *
 517 init_initial_terminal (void)
 518 {
 519   if (initialized || terminal_list || tty_list)
 520     emacs_abort ();
 521
 522   initial_terminal = create_terminal (output_initial, NULL);
 523   initial_terminal->name = xstrdup ("initial_terminal");
 524   initial_terminal->kboard = initial_kboard;
 525   initial_terminal->delete_terminal_hook = &delete_initial_terminal;
 526   initial_terminal->delete_frame_hook = &initial_free_frame_resources;
 527   /* Other hooks are NULL by default.  */
 528
 529   return initial_terminal;
 530 }
 531
 532 /* Deletes the bootstrap terminal device.
 533    Called through delete_terminal_hook. */
 534
 535 static void
 536 delete_initial_terminal (struct terminal *terminal)
 537 {
 538   if (terminal != initial_terminal)
 539     emacs_abort ();
 540
 541   delete_terminal (terminal);
 542   initial_terminal = NULL;
 543 }
 544
 545 void
 546 syms_of_terminal (void)
 547 {
 548
 549   DEFVAR_LISP ("ring-bell-function", Vring_bell_function,
 550     doc: /* Non-nil means call this function to ring the bell.
 551 The function should accept no arguments.  */);
 552   Vring_bell_function = Qnil;
 553
 554   DEFVAR_LISP ("delete-terminal-functions", Vdelete_terminal_functions,
 555     doc: /* Special hook run when a terminal is deleted.
 556 Each function is called with argument, the terminal.
 557 This may be called just before actually deleting the terminal,
 558 or some time later.  */);
 559   Vdelete_terminal_functions = Qnil;
 560
 561   DEFSYM (Qterminal_live_p, "terminal-live-p");
 562   DEFSYM (Qdelete_terminal_functions, "delete-terminal-functions");
 563   DEFSYM (Qrun_hook_with_args, "run-hook-with-args");
 564
 565   defsubr (&Sdelete_terminal);
 566   defsubr (&Sframe_terminal);
 567   defsubr (&Sterminal_live_p);
 568   defsubr (&Sterminal_list);
 569   defsubr (&Sterminal_name);
 570   defsubr (&Sterminal_parameters);
 571   defsubr (&Sterminal_parameter);
 572   defsubr (&Sset_terminal_parameter);
 573
 574   Fprovide (intern_c_string ("multi-tty"), Qnil);
 575 }