src/terminal.c

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