#endif
#include "lisp.h"
+#include "systty.h" /* For emacs_tty in termchar.h */
#include "termchar.h"
#include "termopts.h"
#include "termhooks.h"
struct frame *last_nonminibuf_frame;
-/* Stdio stream being used for copy of all output. */
-
-FILE *termscript;
-
-/* Structure for info on cursor positioning. */
-
-struct cm Wcm;
-
/* 1 means SIGWINCH happened when not safe. */
int delayed_size_change;
{
int c = glyph->u.ch;
int face_id = glyph->face_id;
- if (must_write_spaces)
+ if (TTY_MUST_WRITE_SPACES (CURTTY ()))
c -= SPACEGLYPH;
hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + face_id;
int glyph_table_len = GLYPH_TABLE_LENGTH;
/* Ignore trailing and leading spaces if we can. */
- if (!must_write_spaces)
+ if (!TTY_MUST_WRITE_SPACES (CURTTY ()))
{
/* Skip from the end over trailing spaces. */
while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
#if GLYPH_DEBUG
-/* Flush standard output. This is sometimes useful to call from
- the debugger. */
+/* Flush standard output. This is sometimes useful to call from the debugger.
+ XXX Maybe this should be changed to flush the current terminal instead of
+ stdout.
+*/
void
flush_stdout ()
clear_frame ();
clear_current_matrices (f);
update_end (f);
- fflush (stdout);
+ fflush (TTY_OUTPUT (FRAME_TTY (f)));
windows_or_buffers_changed++;
/* Mark all windows as inaccurate, so that every window will have
its redisplay done. */
/* If we can't insert glyphs, we can use this method only
at the end of a line. */
- if (!char_ins_del_ok)
+ if (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f)))
if (PT != ZV && FETCH_BYTE (PT_BYTE) != '\n')
return 0;
rif->update_window_end_hook (w, 1, 0);
update_end (f);
updated_row = NULL;
- fflush (stdout);
+ fflush (TTY_OUTPUT (CURTTY ()));
TRACE ((stderr, "direct output for insert\n"));
mark_window_display_accurate (it.window, 1);
cursor_to (y, x);
}
- fflush (stdout);
+ fflush (TTY_OUTPUT (CURTTY ()));
redisplay_performed_directly_p = 1;
return 1;
}
paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p);
update_end (f);
- if (termscript)
- fflush (termscript);
- fflush (stdout);
+ if (TTY_TERMSCRIPT (FRAME_TTY (f)))
+ fflush (TTY_TERMSCRIPT (FRAME_TTY (f)));
+ fflush (TTY_OUTPUT (FRAME_TTY (f)));
/* Check window matrices for lost pointers. */
#if GLYPH_DEBUG
}
/* If we cannot insert/delete lines, it's no use trying it. */
- if (!line_ins_del_ok)
+ if (!TTY_LINE_INS_DEL_OK (FRAME_TTY (f)))
inhibit_id_p = 1;
/* See if any of the desired lines are enabled; don't compute for
Also flush out if likely to have more than 1k buffered
otherwise. I'm told that some telnet connections get
really screwed by more than 1k output at once. */
- int outq = PENDING_OUTPUT_COUNT (stdout);
+ int outq = PENDING_OUTPUT_COUNT (TTY_OUTPUT (FRAME_TTY (f)));
if (outq > 900
|| (outq > 20 && ((i - 1) % preempt_count == 0)))
{
- fflush (stdout);
+ fflush (TTY_OUTPUT (FRAME_TTY (f)));
if (preempt_count == 1)
{
#ifdef EMACS_OUTQSIZE
if (EMACS_OUTQSIZE (0, &outq) < 0)
/* Probably not a tty. Ignore the error and reset
the outq count. */
- outq = PENDING_OUTPUT_COUNT (stdout);
+ outq = PENDING_OUTPUT_COUNT (TTY_OUTPUT (FRAME_TTY (f)));
#endif
outq *= 10;
if (baud_rate <= outq && baud_rate > 0)
}
/* If changed lines are few, don't allow preemption, don't scroll. */
- if ((!scroll_region_ok && changed_lines < baud_rate / 2400)
+ if ((!TTY_SCROLL_REGION_OK (FRAME_TTY (frame))
+ && changed_lines < baud_rate / 2400)
|| unchanged_at_bottom == FRAME_LINES (frame))
return 1;
window_size = (FRAME_LINES (frame) - unchanged_at_top
- unchanged_at_bottom);
- if (scroll_region_ok)
+ if (TTY_SCROLL_REGION_OK (FRAME_TTY (frame)))
free_at_end_vpos -= unchanged_at_bottom;
- else if (memory_below_frame)
+ else if (TTY_MEMORY_BELOW_FRAME (FRAME_TTY (frame)))
free_at_end_vpos = -1;
/* If large window, fast terminal and few lines in common between
current frame and desired frame, don't bother with i/d calc. */
- if (!scroll_region_ok && window_size >= 18 && baud_rate > 2400
+ if (!TTY_SCROLL_REGION_OK (FRAME_TTY (frame))
+ && window_size >= 18 && baud_rate > 2400
&& (window_size >=
10 * scrolling_max_lines_saved (unchanged_at_top,
FRAME_LINES (frame) - unchanged_at_bottom,
struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos);
struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos);
int must_write_whole_line_p;
- int write_spaces_p = must_write_spaces;
+ int write_spaces_p = TTY_MUST_WRITE_SPACES (FRAME_TTY (f));
int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
!= FACE_TTY_DEFAULT_BG_COLOR);
nlen--;
/* If there's no i/d char, quickly do the best we can without it. */
- if (!char_ins_del_ok)
+ if (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f)))
{
int i, j;
tem = (nlen - nsp) - (olen - osp);
if (endmatch && tem
- && (!char_ins_del_ok || endmatch <= char_ins_del_cost (f)[tem]))
+ && (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f))
+ || endmatch <= char_ins_del_cost (f)[tem]))
endmatch = 0;
/* nsp - osp is the distance to insert or delete.
Is it worth it? */
if (nsp != osp
- && (!char_ins_del_ok
+ && (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f))
|| begmatch + endmatch <= char_ins_del_cost (f)[nsp - osp]))
{
begmatch = 0;
#endif
int old_errno = errno;
- get_frame_size (&width, &height);
-
- /* The frame size change obviously applies to a termcap-controlled
- frame. Find such a frame in the list, and assume it's the only
- one (since the redisplay code always writes to stdout, not a
- FILE * specified in the frame structure). Record the new size,
- but don't reallocate the data structures now. Let that be done
- later outside of the signal handler. */
-
- {
- Lisp_Object tail, frame;
+ struct tty_output *tty;
+
+ /* The frame size change obviously applies to a single
+ termcap-controlled terminal, but we can't decide which.
+ Therefore, we resize the frames corresponding to each tty.
+
+ XXX In fact we only get the signal for the initial terminal.
+ */
+ for (tty = tty_list; tty; tty = tty->next) {
- FOR_EACH_FRAME (tail, frame)
- {
- if (FRAME_TERMCAP_P (XFRAME (frame)))
- {
- change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
- break;
- }
- }
+ get_tty_size (tty, &width, &height);
+
+ {
+ Lisp_Object tail, frame;
+
+ FOR_EACH_FRAME (tail, frame)
+ {
+ if (FRAME_TERMCAP_P (XFRAME (frame)) && FRAME_TTY (XFRAME (frame)) == tty)
+ {
+ /* Record the new sizes, but don't reallocate the data structures
+ now. Let that be done later outside of the signal handler. */
+ change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
+ break;
+ }
+ }
+ }
}
-
+
signal (SIGWINCH, window_change_signal);
errno = old_errno;
}
{
Lisp_Object tail, frame;
- if (! FRAME_WINDOW_P (f))
+ if (FRAME_MSDOS_P (f))
{
- /* When using termcap, or on MS-DOS, all frames use
- the same screen, so a change in size affects all frames. */
+ /* On MS-DOS, all frames use the same screen, so a change in
+ size affects all frames. Termcap now supports multiple
+ ttys. */
FOR_EACH_FRAME (tail, frame)
if (! FRAME_WINDOW_P (XFRAME (frame)))
change_frame_size_1 (XFRAME (frame), newheight, newwidth,
newheight - FRAME_TOP_MARGIN (f), 0);
if (FRAME_TERMCAP_P (f) && !pretend)
- FrameRows = newheight;
+ FrameRows (FRAME_TTY (f)) = newheight;
}
if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_total_cols, 0);
if (FRAME_TERMCAP_P (f) && !pretend)
- FrameCols = newwidth;
+ FrameCols (FRAME_TTY (f)) = newwidth;
if (WINDOWP (f->tool_bar_window))
XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth);
(file)
Lisp_Object file;
{
- if (termscript != 0) fclose (termscript);
- termscript = 0;
+ if (TTY_TERMSCRIPT (CURTTY ()) != 0)
+ fclose (TTY_TERMSCRIPT (CURTTY ()));
+ TTY_TERMSCRIPT (CURTTY ()) = 0;
if (! NILP (file))
{
file = Fexpand_file_name (file, Qnil);
- termscript = fopen (SDATA (file), "w");
- if (termscript == 0)
+ TTY_TERMSCRIPT (CURTTY ()) = fopen (SDATA (file), "w");
+ if (TTY_TERMSCRIPT (CURTTY ()) == 0)
report_file_error ("Opening termscript", Fcons (file, Qnil));
}
return Qnil;
{
/* ??? Perhaps we should do something special for multibyte strings here. */
CHECK_STRING (string);
- fwrite (SDATA (string), 1, SBYTES (string), stdout);
- fflush (stdout);
- if (termscript)
+ if (TTY_TERMSCRIPT (CURTTY ()))
{
fwrite (SDATA (string), 1, SBYTES (string),
- termscript);
- fflush (termscript);
+ TTY_TERMSCRIPT (CURTTY ()));
+ fflush (TTY_TERMSCRIPT (CURTTY ()));
}
+ fwrite (SDATA (string), 1, SBYTES (string),
+ TTY_OUTPUT (CURTTY ()));
+ fflush (TTY_OUTPUT (CURTTY ()));
return Qnil;
}
putchar (07);
else
ring_bell ();
- fflush (stdout);
+ fflush (TTY_OUTPUT (CURTTY ()));
}
else
bitch_at_user ();
error ("Keyboard macro terminated by a command ringing the bell");
else
ring_bell ();
- fflush (stdout);
+ fflush (TTY_OUTPUT (CURTTY ()));
}
Initialization
***********************************************************************/
-char *terminal_type;
-
/* Initialization done when Emacs fork is started, before doing stty.
Determine terminal type and set terminal_driver. Then invoke its
decoding routine to set up variables in the terminal package. */
void
init_display ()
{
+ char *terminal_type;
+
#ifdef HAVE_X_WINDOWS
extern int display_arg;
#endif
SET_CHAR_GLYPH_FROM_GLYPH (space_glyph, ' ');
space_glyph.charpos = -1;
- meta_key = 0;
inverse_video = 0;
cursor_in_echo_area = 0;
terminal_type = (char *) 0;
}
#endif /* VMS */
- term_init (terminal_type);
+ term_init (0, terminal_type);
{
struct frame *sf = SELECTED_FRAME ();