src/terminal.c

   1 /* Functions related to terminal devices.
   2    Copyright (C) 2005 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 2, 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 (INTEGERP (terminal))
 209     {
 210       struct terminal *t;
 211
 212       for (t = terminal_list; t; t = t->next_terminal)
 213         {
 214           if (t->id == XINT (terminal))
 215             {
 216               result = t;
 217               break;
 218             }
 219         }
 220     }
 221   else if (FRAMEP (terminal))
 222     {
 223       result = FRAME_TERMINAL (XFRAME (terminal));
 224     }
 225
 226   if (result == NULL && throw)
 227     wrong_type_argument (Qterminal_live_p, terminal);
 228
 229   return result;
 230 }
 231
 232 \f
 233
 234 /* Create a new terminal object and add it to the terminal list. */
 235
 236 struct terminal *
 237 create_terminal (void)
 238 {
 239   struct terminal *terminal = (struct terminal *) xmalloc (sizeof (struct terminal));
 240
 241   bzero (terminal, sizeof (struct terminal));
 242   terminal->next_terminal = terminal_list;
 243   terminal_list = terminal;
 244
 245   terminal->id = next_terminal_id++;
 246
 247   terminal->keyboard_coding =
 248     (struct coding_system *) xmalloc (sizeof (struct coding_system));
 249   terminal->terminal_coding =
 250     (struct coding_system *) xmalloc (sizeof (struct coding_system));
 251
 252   setup_coding_system (Qnil, terminal->keyboard_coding);
 253   setup_coding_system (Qnil, terminal->terminal_coding);
 254
 255   terminal->param_alist = Qnil;
 256   return terminal;
 257 }
 258
 259 /* Mark the Lisp pointers in the terminal objects.
 260    Called by the Fgarbage_collector.  */
 261
 262 void
 263 mark_terminals (void)
 264 {
 265   struct terminal *t;
 266   for (t = terminal_list; t; t = t->next_terminal)
 267     {
 268       mark_object (t->param_alist);
 269     }
 270 }
 271
 272
 273 /* Remove a terminal from the terminal list and free its memory. */
 274
 275 void
 276 delete_terminal (struct terminal *terminal)
 277 {
 278   struct terminal **tp;
 279   Lisp_Object tail, frame;
 280
 281   /* Check for and close live frames that are still on this
 282      terminal. */
 283   FOR_EACH_FRAME (tail, frame)
 284     {
 285       struct frame *f = XFRAME (frame);
 286       if (FRAME_LIVE_P (f) && f->terminal == terminal)
 287         {
 288           Fdelete_frame (frame, Qt);
 289         }
 290     }
 291
 292   for (tp = &terminal_list; *tp != terminal; tp = &(*tp)->next_terminal)
 293     if (! *tp)
 294       abort ();
 295   *tp = terminal->next_terminal;
 296
 297   if (terminal->keyboard_coding)
 298     xfree (terminal->keyboard_coding);
 299   if (terminal->terminal_coding)
 300     xfree (terminal->terminal_coding);
 301   if (terminal->name)
 302     xfree (terminal->name);
 303
 304 #ifdef MULTI_KBOARD
 305   if (terminal->kboard && --terminal->kboard->reference_count == 0)
 306     delete_kboard (terminal->kboard);
 307 #endif
 308
 309   bzero (terminal, sizeof (struct terminal));
 310   xfree (terminal);
 311 }
 312
 313 DEFUN ("delete-terminal", Fdelete_terminal, Sdelete_terminal, 0, 2, 0,
 314        doc: /* Delete TERMINAL by deleting all frames on it and closing the terminal.
 315 TERMINAL may be a terminal id, a frame, or nil (meaning the selected
 316 frame's terminal).
 317
 318 Normally, you may not delete a display if all other displays are suspended,
 319 but if the second argument FORCE is non-nil, you may do so. */)
 320   (terminal, force)
 321      Lisp_Object terminal, force;
 322 {
 323   struct terminal *t, *p;
 324
 325   t = get_terminal (terminal, 0);
 326
 327   if (!t)
 328     return Qnil;
 329
 330   p = terminal_list;
 331   while (p && (p == t || !TERMINAL_ACTIVE_P (p)))
 332     p = p->next_terminal;
 333
 334   if (NILP (force) && !p)
 335     error ("Attempt to delete the sole active display 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 = get_terminal (frame, 0);
 362
 363   if (!t)
 364     return Qnil;
 365   else
 366     return make_number (t->id);
 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
 376 Display terminals are represented by their integer identifiers. */)
 377      (object)
 378      Lisp_Object object;
 379 {
 380   struct terminal *t;
 381
 382   if (!INTEGERP (object))
 383     return Qnil;
 384
 385   t = get_terminal (object, 0);
 386
 387   if (!t)
 388     return Qnil;
 389
 390   switch (t->type)
 391     {
 392     case output_initial: /* The initial frame is like a termcap frame. */
 393     case output_termcap:
 394       return Qt;
 395     case output_x_window:
 396       return Qx;
 397     case output_w32:
 398       return Qw32;
 399     case output_msdos_raw:
 400       return Qpc;
 401     case output_mac:
 402       return Qmac;
 403     default:
 404       abort ();
 405     }
 406 }
 407
 408 DEFUN ("terminal-list", Fterminal_list, Sterminal_list, 0, 0, 0,
 409        doc: /* Return a list of all terminal devices.
 410 Terminal devices are represented by their integer identifiers. */)
 411   ()
 412 {
 413   Lisp_Object terminals = Qnil;
 414   struct terminal *t;
 415
 416   for (t = terminal_list; t; t = t->next_terminal)
 417     terminals = Fcons (make_number (t->id), terminals);
 418
 419   return terminals;
 420 }
 421
 422 DEFUN ("terminal-name", Fterminal_name, Sterminal_name, 0, 1, 0,
 423        doc: /* Return the name of the terminal device TERMINAL.
 424 It is not guaranteed that the returned value is unique among opened devices.
 425
 426 TERMINAL may be a terminal id, a frame, or nil (meaning the
 427 selected frame's terminal). */)
 428   (terminal)
 429      Lisp_Object terminal;
 430 {
 431   struct terminal *t = get_terminal (terminal, 1);
 432
 433   if (t->name)
 434     return build_string (t->name);
 435   else
 436     return Qnil;
 437 }
 438
 439
 440 \f
 441 /* Return the value of terminal parameter PARAM in terminal T.  */
 442 Lisp_Object
 443 get_terminal_param (t, param)
 444      struct terminal *t;
 445      Lisp_Object param;
 446 {
 447   Lisp_Object tem = Fassq (param, t->param_alist);
 448   if (EQ (tem, Qnil))
 449     return tem;
 450   return Fcdr (tem);
 451 }
 452
 453 /* Set the value of terminal parameter PARAMETER in terminal D to VALUE.
 454    Return the previous value.  */
 455
 456 Lisp_Object
 457 store_terminal_param (t, parameter, value)
 458      struct terminal *t;
 459      Lisp_Object parameter;
 460      Lisp_Object value;
 461 {
 462   Lisp_Object old_alist_elt = Fassq (parameter, t->param_alist);
 463   if (EQ (old_alist_elt, Qnil))
 464     {
 465       t->param_alist = Fcons (Fcons (parameter, value), t->param_alist);
 466       return Qnil;
 467     }
 468   else
 469     {
 470       Lisp_Object result = Fcdr (old_alist_elt);
 471       Fsetcdr (old_alist_elt, value);
 472       return result;
 473     }
 474 }
 475
 476
 477 DEFUN ("terminal-parameters", Fterminal_parameters, Sterminal_parameters, 0, 1, 0,
 478        doc: /* Return the parameter-alist of terminal TERMINAL.
 479 The value is a list of elements of the form (PARM . VALUE), where PARM
 480 is a symbol.
 481
 482 TERMINAL can be a terminal id, a frame or nil (meaning the selected
 483 frame's terminal).  */)
 484      (terminal)
 485      Lisp_Object terminal;
 486 {
 487   struct terminal *t = 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 = get_terminal (terminal, 1);
 501   CHECK_SYMBOL (parameter);
 502   value = Fcdr (Fassq (parameter, t->param_alist));
 503   return value;
 504 }
 505
 506 DEFUN ("modify-terminal-parameters", Fmodify_terminal_parameters,
 507        Smodify_terminal_parameters, 2, 2, 0,
 508        doc: /* Modify the parameters of terminal TERMINAL according to ALIST.
 509 ALIST is an alist of parameters to change and their new values.
 510 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
 511
 512 TERMINAL can be a terminal id, a frame or nil (meaning the selected
 513 frame's terminal).  */)
 514      (terminal, alist)
 515      Lisp_Object terminal;
 516      Lisp_Object alist;
 517 {
 518   Lisp_Object tail, prop, val;
 519   struct terminal *t = get_terminal (terminal, 1);
 520   int length = XINT (Fsafe_length (alist));
 521   int i;
 522   Lisp_Object *parms = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
 523   Lisp_Object *values = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
 524
 525   /* Extract parm names and values into those vectors.  */
 526
 527   i = 0;
 528   for (tail = alist; CONSP (tail); tail = Fcdr (tail))
 529     {
 530       Lisp_Object elt;
 531
 532       elt = Fcar (tail);
 533       parms[i] = Fcar (elt);
 534       values[i] = Fcdr (elt);
 535       i++;
 536     }
 537
 538   /* Now process them in reverse of specified order.  */
 539   for (i--; i >= 0; i--)
 540     {
 541       prop = parms[i];
 542       val = values[i];
 543       store_terminal_param (t, prop, val);
 544     }
 545   return Qnil;
 546 }
 547
 548 DEFUN ("set-terminal-parameter", Fset_terminal_parameter,
 549        Sset_terminal_parameter, 3, 3, 0,
 550        doc: /* Set TERMINAL's value for parameter PARAMETER to VALUE.
 551 Return the previous value of PARAMETER.
 552
 553 TERMINAL can be a terminal id, a frame or nil (meaning the selected
 554 frame's terminal).  */)
 555      (terminal, parameter, value)
 556      Lisp_Object terminal;
 557      Lisp_Object parameter;
 558      Lisp_Object value;
 559 {
 560   struct terminal *t = get_terminal (terminal, 1);
 561   return store_terminal_param (t, parameter, value);
 562 }
 563
 564 \f
 565
 566 /* Create the bootstrap display terminal for the initial frame.
 567    Returns a terminal of type output_initial.  */
 568
 569 struct terminal *
 570 init_initial_terminal (void)
 571 {
 572   if (initialized || terminal_list || tty_list)
 573     abort ();
 574
 575   initial_terminal = create_terminal ();
 576   initial_terminal->type = output_initial;
 577   initial_terminal->name = xstrdup ("initial_terminal");
 578   initial_terminal->kboard = initial_kboard;
 579
 580   initial_terminal->delete_terminal_hook = &delete_initial_terminal;
 581   /* All other hooks are NULL. */
 582
 583   return initial_terminal;
 584 }
 585
 586 /* Deletes the bootstrap terminal device.
 587    Called through delete_terminal_hook. */
 588
 589 static void
 590 delete_initial_terminal (struct terminal *terminal)
 591 {
 592   if (terminal != initial_terminal)
 593     abort ();
 594
 595   delete_terminal (terminal);
 596   initial_terminal = NULL;
 597 }
 598
 599 void
 600 syms_of_terminal ()
 601 {
 602
 603   DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
 604     doc: /* Non-nil means call this function to ring the bell.
 605 The function should accept no arguments.  */);
 606   Vring_bell_function = Qnil;
 607
 608   defsubr (&Sdelete_terminal);
 609   defsubr (&Sframe_terminal);
 610   defsubr (&Sterminal_live_p);
 611   defsubr (&Sterminal_list);
 612   defsubr (&Sterminal_name);
 613   defsubr (&Sterminal_parameters);
 614   defsubr (&Sterminal_parameter);
 615   defsubr (&Smodify_terminal_parameters);
 616   defsubr (&Sset_terminal_parameter);
 617
 618   Fprovide (intern ("multi-tty"), Qnil);
 619 }
 620
 621 /* arch-tag: e9af6f27-b483-47dc-bb1a-730c1c5cab03
 622    (do not change this comment) */