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