src/terminal.c

   1 /* Functions related to terminal devices.
   2    Copyright (C) 2005, 2006, 2007, 2008 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.  Fdelete_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           /* Maybe this should pass Qnoelisp rather than Qt?  */
 273           Fdelete_frame (frame, Qt);
 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 #ifdef MULTI_KBOARD
 288   if (terminal->kboard && --terminal->kboard->reference_count == 0)
 289     {
 290       delete_kboard (terminal->kboard);
 291       terminal->kboard = NULL;
 292     }
 293 #endif
 294 }
 295
 296 Lisp_Object Qrun_hook_with_args;
 297 static Lisp_Object Qdelete_terminal_functions;
 298 static Lisp_Object Vdelete_terminal_functions;
 299
 300 DEFUN ("delete-terminal", Fdelete_terminal, Sdelete_terminal, 0, 2, 0,
 301        doc: /* Delete TERMINAL by deleting all frames on it and closing the terminal.
 302 TERMINAL may be a terminal id, a frame, or nil (meaning the selected
 303 frame's terminal).
 304
 305 Normally, you may not delete a display if all other displays are suspended,
 306 but if the second argument FORCE is non-nil, you may do so. */)
 307   (terminal, force)
 308      Lisp_Object terminal, force;
 309 {
 310   struct terminal *t = get_terminal (terminal, 0);
 311
 312   if (!t)
 313     return Qnil;
 314
 315   if (NILP (force))
 316     {
 317       struct terminal *p = terminal_list;
 318       while (p && (p == t || !TERMINAL_ACTIVE_P (p)))
 319         p = p->next_terminal;
 320
 321       if (!p)
 322         error ("Attempt to delete the sole active display terminal");
 323     }
 324
 325   if (NILP (Vrun_hooks))
 326     ;
 327   else if (EQ (force, Qnoelisp))
 328     pending_funcalls
 329       = Fcons (list3 (Qrun_hook_with_args,
 330                       Qdelete_terminal_functions, terminal),
 331                pending_funcalls);
 332   else
 333     safe_call2 (Qrun_hook_with_args, Qdelete_terminal_functions, terminal);
 334
 335   if (t->delete_terminal_hook)
 336     (*t->delete_terminal_hook) (t);
 337   else
 338     delete_terminal (t);
 339
 340   return Qnil;
 341 }
 342
 343 \f
 344 DEFUN ("frame-terminal", Fframe_terminal, Sframe_terminal, 0, 1, 0,
 345        doc: /* Return the terminal that FRAME is displayed on.
 346 If FRAME is nil, the selected frame is used.
 347
 348 The terminal device is represented by its integer identifier.  */)
 349   (frame)
 350      Lisp_Object frame;
 351 {
 352   struct terminal *t;
 353
 354   if (NILP (frame))
 355     frame = selected_frame;
 356
 357   CHECK_LIVE_FRAME (frame);
 358
 359   t = FRAME_TERMINAL (XFRAME (frame));
 360
 361   if (!t)
 362     return Qnil;
 363   else
 364     {
 365       Lisp_Object terminal;
 366       XSETTERMINAL (terminal, t);
 367       return terminal;
 368     }
 369 }
 370
 371 DEFUN ("terminal-live-p", Fterminal_live_p, Sterminal_live_p, 1, 1, 0,
 372        doc: /* Return non-nil if OBJECT is a terminal which has not been deleted.
 373 Value is nil if OBJECT is not a live display terminal.
 374 If object is a live display terminal, the return value indicates what
 375 sort of output terminal it uses.  See the documentation of `framep' for
 376 possible return values.  */)
 377      (object)
 378      Lisp_Object object;
 379 {
 380   struct terminal *t;
 381
 382   t = get_terminal (object, 0);
 383
 384   if (!t)
 385     return Qnil;
 386
 387   switch (t->type)
 388     {
 389     case output_initial: /* The initial frame is like a termcap frame. */
 390     case output_termcap:
 391       return Qt;
 392     case output_x_window:
 393       return Qx;
 394     case output_w32:
 395       return Qw32;
 396     case output_msdos_raw:
 397       return Qpc;
 398     case output_mac:
 399       return Qmac;
 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 id, 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 id, a frame or nil (meaning the selected
 480 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 id, a frame or nil (meaning the selected
 492 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 id, a frame or nil (meaning the selected
 511 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 #ifdef MULTI_KBOARD
 537   initial_terminal->kboard = initial_kboard;
 538 #endif
 539   initial_terminal->delete_terminal_hook = &delete_initial_terminal;
 540   /* All other hooks are NULL. */
 541
 542   return initial_terminal;
 543 }
 544
 545 /* Deletes the bootstrap terminal device.
 546    Called through delete_terminal_hook. */
 547
 548 static void
 549 delete_initial_terminal (struct terminal *terminal)
 550 {
 551   if (terminal != initial_terminal)
 552     abort ();
 553
 554   delete_terminal (terminal);
 555   initial_terminal = NULL;
 556 }
 557
 558 void
 559 syms_of_terminal ()
 560 {
 561
 562   DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
 563     doc: /* Non-nil means call this function to ring the bell.
 564 The function should accept no arguments.  */);
 565   Vring_bell_function = Qnil;
 566
 567   DEFVAR_LISP ("delete-terminal-functions", &Vdelete_terminal_functions,
 568     doc: /* Special hook run when a terminal is deleted.
 569 Each function is called with argument, the terminal.
 570 This may be called just before actually deleting the terminal,
 571 or some time later.  */);
 572   Vdelete_terminal_functions = Qnil;
 573   Qdelete_terminal_functions = intern ("delete-terminal-functions");
 574   staticpro (&Qdelete_terminal_functions);
 575   Qrun_hook_with_args = intern ("run-hook-with-args");
 576   staticpro (&Qrun_hook_with_args);
 577
 578   defsubr (&Sdelete_terminal);
 579   defsubr (&Sframe_terminal);
 580   defsubr (&Sterminal_live_p);
 581   defsubr (&Sterminal_list);
 582   defsubr (&Sterminal_name);
 583   defsubr (&Sterminal_parameters);
 584   defsubr (&Sterminal_parameter);
 585   defsubr (&Sset_terminal_parameter);
 586
 587   Fprovide (intern ("multi-tty"), Qnil);
 588 }
 589
 590 /* arch-tag: e9af6f27-b483-47dc-bb1a-730c1c5cab03
 591    (do not change this comment) */