src/terminal.c

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