src/terminal.c

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