+ return Qt;
+}
+
+DEFUN ("tty-no-underline", Ftty_no_underline, Stty_no_underline, 0, 1, 0,
+ doc: /* Declare that the tty used by TERMINAL does not handle underlining.
+This is used to override the terminfo data, for certain terminals that
+do not really do underlining, but say that they do. This function has
+no effect if used on a non-tty terminal.
+
+TERMINAL can be a terminal object, a frame or nil (meaning the
+selected frame's terminal). This function always returns nil if
+TERMINAL does not refer to a text-only terminal. */)
+ (terminal)
+ Lisp_Object terminal;
+{
+ struct terminal *t = get_terminal (terminal, 1);
+
+ if (t->type == output_termcap)
+ t->display_info.tty->TS_enter_underline_mode = 0;
+ return Qnil;
+}
+
+\f
+
+DEFUN ("suspend-tty", Fsuspend_tty, Ssuspend_tty, 0, 1, 0,
+ doc: /* Suspend the terminal device TTY.
+
+The device is restored to its default state, and Emacs ceases all
+access to the tty device. Frames that use the device are not deleted,
+but input is not read from them and if they change, their display is
+not updated.
+
+TTY may be a terminal object, a frame, or nil for the terminal device
+of the currently selected frame.
+
+This function runs `suspend-tty-functions' after suspending the
+device. The functions are run with one arg, the id of the suspended
+terminal device.
+
+`suspend-tty' does nothing if it is called on a device that is already
+suspended.
+
+A suspended tty may be resumed by calling `resume-tty' on it. */)
+ (tty)
+ Lisp_Object tty;
+{
+ struct terminal *t = get_tty_terminal (tty, 1);
+ FILE *f;
+
+ if (!t)
+ error ("Unknown tty device");
+
+ f = t->display_info.tty->input;
+
+ if (f)
+ {
+ /* First run `suspend-tty-functions' and then clean up the tty
+ state because `suspend-tty-functions' might need to change
+ the tty state. */
+ if (!NILP (Vrun_hooks))
+ {
+ Lisp_Object args[2];
+ args[0] = intern ("suspend-tty-functions");
+ XSETTERMINAL (args[1], t);
+ Frun_hook_with_args (2, args);
+ }
+
+ reset_sys_modes (t->display_info.tty);
+
+#ifdef subprocesses
+ delete_keyboard_wait_descriptor (fileno (f));
+#endif
+
+#ifndef MSDOS
+ fclose (f);
+ if (f != t->display_info.tty->output)
+ fclose (t->display_info.tty->output);
+#endif
+
+ t->display_info.tty->input = 0;
+ t->display_info.tty->output = 0;
+
+ if (FRAMEP (t->display_info.tty->top_frame))
+ FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 0);
+
+ }
+
+ /* Clear display hooks to prevent further output. */
+ clear_tty_hooks (t);
+
+ return Qnil;
+}
+
+DEFUN ("resume-tty", Fresume_tty, Sresume_tty, 0, 1, 0,
+ doc: /* Resume the previously suspended terminal device TTY.
+The terminal is opened and reinitialized. Frames that are on the
+suspended terminal are revived.
+
+It is an error to resume a terminal while another terminal is active
+on the same device.
+
+This function runs `resume-tty-functions' after resuming the terminal.
+The functions are run with one arg, the id of the resumed terminal
+device.
+
+`resume-tty' does nothing if it is called on a device that is not
+suspended.
+
+TTY may be a terminal object, a frame, or nil (meaning the selected
+frame's terminal). */)
+ (tty)
+ Lisp_Object tty;
+{
+ struct terminal *t = get_tty_terminal (tty, 1);
+ int fd;
+
+ if (!t)
+ error ("Unknown tty device");
+
+ if (!t->display_info.tty->input)
+ {
+ if (get_named_tty (t->display_info.tty->name))
+ error ("Cannot resume display while another display is active on the same device");
+
+#ifdef MSDOS
+ t->display_info.tty->output = stdout;
+ t->display_info.tty->input = stdin;
+#else /* !MSDOS */
+ fd = emacs_open (t->display_info.tty->name, O_RDWR | O_NOCTTY, 0);
+
+ if (fd == -1)
+ error ("Can not reopen tty device %s: %s", t->display_info.tty->name, strerror (errno));
+
+ if (strcmp (t->display_info.tty->name, DEV_TTY))
+ dissociate_if_controlling_tty (fd);
+
+ t->display_info.tty->output = fdopen (fd, "w+");
+ t->display_info.tty->input = t->display_info.tty->output;
+#endif
+
+#ifdef subprocesses
+ add_keyboard_wait_descriptor (fd);
+#endif
+
+ if (FRAMEP (t->display_info.tty->top_frame))
+ {
+ struct frame *f = XFRAME (t->display_info.tty->top_frame);
+ int width, height;
+ int old_height = FRAME_COLS (f);
+ int old_width = FRAME_LINES (f);
+
+ /* Check if terminal/window size has changed while the frame
+ was suspended. */
+ get_tty_size (fileno (t->display_info.tty->input), &width, &height);
+ if (width != old_width || height != old_height)
+ change_frame_size (f, height, width, 0, 0, 0);
+ FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
+ }
+
+ init_sys_modes (t->display_info.tty);
+
+ /* Run `resume-tty-functions'. */
+ if (!NILP (Vrun_hooks))
+ {
+ Lisp_Object args[2];
+ args[0] = intern ("resume-tty-functions");
+ XSETTERMINAL (args[1], t);
+ Frun_hook_with_args (2, args);
+ }
+ }
+
+ set_tty_hooks (t);
+
+ return Qnil;
+}
+
+\f
+/***********************************************************************
+ Mouse
+ ***********************************************************************/
+
+#ifdef HAVE_GPM
+void
+term_mouse_moveto (int x, int y)
+{
+ /* TODO: how to set mouse position?
+ const char *name;
+ int fd;
+ name = (const char *) ttyname (0);
+ fd = open (name, O_WRONLY);
+ SOME_FUNCTION (x, y, fd);
+ close (fd);
+ last_mouse_x = x;
+ last_mouse_y = y; */
+}
+
+static void
+term_show_mouse_face (enum draw_glyphs_face draw)
+{
+ struct window *w = XWINDOW (mouse_face_window);
+ int save_x, save_y;
+ int i;
+
+ struct frame *f = XFRAME (w->frame);
+ struct tty_display_info *tty = FRAME_TTY (f);
+
+ if (/* If window is in the process of being destroyed, don't bother
+ to do anything. */
+ w->current_matrix != NULL
+ /* Recognize when we are called to operate on rows that don't exist
+ anymore. This can happen when a window is split. */
+ && mouse_face_end_row < w->current_matrix->nrows)
+ {
+ /* write_glyphs writes at cursor position, so we need to
+ temporarily move cursor coordinates to the beginning of
+ the highlight region. */
+
+ /* Save current cursor co-ordinates */
+ save_y = curY (tty);
+ save_x = curX (tty);
+
+ /* Note that mouse_face_beg_row etc. are window relative. */
+ for (i = mouse_face_beg_row; i <= mouse_face_end_row; i++)
+ {
+ int start_hpos, end_hpos, nglyphs;
+ struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
+
+ /* Don't do anything if row doesn't have valid contents. */
+ if (!row->enabled_p)
+ continue;
+
+ /* For all but the first row, the highlight starts at column 0. */
+ if (i == mouse_face_beg_row)
+ start_hpos = mouse_face_beg_col;
+ else
+ start_hpos = 0;
+
+ if (i == mouse_face_end_row)
+ end_hpos = mouse_face_end_col;
+ else
+ {
+ end_hpos = row->used[TEXT_AREA];
+ if (draw == DRAW_NORMAL_TEXT)
+ row->fill_line_p = 1; /* Clear to end of line */
+ }
+
+ if (end_hpos <= start_hpos)
+ continue;
+ /* Record that some glyphs of this row are displayed in
+ mouse-face. */
+ row->mouse_face_p = draw > 0;
+
+ nglyphs = end_hpos - start_hpos;
+
+ if (end_hpos >= row->used[TEXT_AREA])
+ nglyphs = row->used[TEXT_AREA] - start_hpos;
+
+ pos_y = row->y + WINDOW_TOP_EDGE_Y (w);
+ pos_x = row->used[LEFT_MARGIN_AREA] + start_hpos
+ + WINDOW_LEFT_EDGE_X (w);
+
+ cursor_to (f, pos_y, pos_x);
+
+ if (draw == DRAW_MOUSE_FACE)
+ {
+ tty_write_glyphs_with_face (f, row->glyphs[TEXT_AREA] + start_hpos,
+ nglyphs, mouse_face_face_id);
+ }
+ else /* draw == DRAW_NORMAL_TEXT */
+ write_glyphs (f, row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
+ }
+ cursor_to (f, save_y, save_x);
+ }
+}
+
+static void
+term_clear_mouse_face ()
+{
+ if (!NILP (mouse_face_window))
+ term_show_mouse_face (DRAW_NORMAL_TEXT);
+
+ mouse_face_beg_row = mouse_face_beg_col = -1;
+ mouse_face_end_row = mouse_face_end_col = -1;
+ mouse_face_window = Qnil;
+}
+
+/* Find the glyph matrix position of buffer position POS in window W.
+ *HPOS and *VPOS are set to the positions found. W's current glyphs
+ must be up to date. If POS is above window start return (0, 0).
+ If POS is after end of W, return end of last line in W.
+ - taken from msdos.c */
+static int
+fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
+{
+ int i, lastcol, line_start_position, maybe_next_line_p = 0;
+ int yb = window_text_bottom_y (w);
+ struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0), *best_row = row;
+
+ while (row->y < yb)
+ {
+ if (row->used[TEXT_AREA])
+ line_start_position = row->glyphs[TEXT_AREA]->charpos;
+ else
+ line_start_position = 0;
+
+ if (line_start_position > pos)
+ break;
+ /* If the position sought is the end of the buffer,
+ don't include the blank lines at the bottom of the window. */
+ else if (line_start_position == pos
+ && pos == BUF_ZV (XBUFFER (w->buffer)))
+ {
+ maybe_next_line_p = 1;
+ break;
+ }
+ else if (line_start_position > 0)
+ best_row = row;
+
+ /* Don't overstep the last matrix row, lest we get into the
+ never-never land... */
+ if (row->y + 1 >= yb)
+ break;
+
+ ++row;
+ }
+
+ /* Find the right column within BEST_ROW. */
+ lastcol = 0;
+ row = best_row;
+ for (i = 0; i < row->used[TEXT_AREA]; i++)
+ {
+ struct glyph *glyph = row->glyphs[TEXT_AREA] + i;
+ int charpos;
+
+ charpos = glyph->charpos;
+ if (charpos == pos)
+ {
+ *hpos = i;
+ *vpos = row->y;
+ return 1;
+ }
+ else if (charpos > pos)
+ break;
+ else if (charpos > 0)
+ lastcol = i;
+ }
+
+ /* If we're looking for the end of the buffer,
+ and we didn't find it in the line we scanned,
+ use the start of the following line. */
+ if (maybe_next_line_p)
+ {
+ ++row;
+ lastcol = 0;
+ }
+
+ *vpos = row->y;
+ *hpos = lastcol + 1;
+ return 0;
+}
+
+static void
+term_mouse_highlight (struct frame *f, int x, int y)
+{
+ enum window_part part;
+ Lisp_Object window;
+ struct window *w;
+ struct buffer *b;
+
+ if (NILP (Vmouse_highlight)
+ || !f->glyphs_initialized_p)
+ return;
+
+ /* Which window is that in? */
+ window = window_from_coordinates (f, x, y, &part, &x, &y, 0);
+
+ /* Not on a window -> return. */
+ if (!WINDOWP (window))
+ return;
+
+ if (!EQ (window, mouse_face_window))
+ term_clear_mouse_face ();
+
+ w = XWINDOW (window);
+
+ /* Are we in a window whose display is up to date?
+ And verify the buffer's text has not changed. */
+ b = XBUFFER (w->buffer);
+ if (part == ON_TEXT
+ && EQ (w->window_end_valid, w->buffer)
+ && XFASTINT (w->last_modified) == BUF_MODIFF (b)
+ && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
+ {
+ int pos, i, nrows = w->current_matrix->nrows;
+ struct glyph_row *row;
+ struct glyph *glyph;
+
+ /* Find the glyph under X/Y. */
+ glyph = NULL;
+ if (y >= 0 && y < nrows)
+ {
+ row = MATRIX_ROW (w->current_matrix, y);
+ /* Give up if some row before the one we are looking for is
+ not enabled. */
+ for (i = 0; i <= y; i++)
+ if (!MATRIX_ROW (w->current_matrix, i)->enabled_p)
+ break;
+ if (i > y /* all rows upto and including the one at Y are enabled */
+ && row->displays_text_p
+ && x < window_box_width (w, TEXT_AREA))
+ {
+ glyph = row->glyphs[TEXT_AREA];
+ if (x >= row->used[TEXT_AREA])
+ glyph = NULL;
+ else
+ {
+ glyph += x;
+ if (!BUFFERP (glyph->object))
+ glyph = NULL;
+ }
+ }
+ }
+
+ /* Clear mouse face if X/Y not over text. */
+ if (glyph == NULL)
+ {
+ term_clear_mouse_face ();
+ return;
+ }
+
+ if (!BUFFERP (glyph->object))
+ abort ();
+ pos = glyph->charpos;
+
+ /* Check for mouse-face. */
+ {
+ extern Lisp_Object Qmouse_face;
+ Lisp_Object mouse_face, overlay, position, *overlay_vec;
+ int noverlays, obegv, ozv;
+ struct buffer *obuf;
+
+ /* If we get an out-of-range value, return now; avoid an error. */
+ if (pos > BUF_Z (b))
+ return;
+
+ /* Make the window's buffer temporarily current for
+ overlays_at and compute_char_face. */
+ obuf = current_buffer;
+ current_buffer = b;
+ obegv = BEGV;
+ ozv = ZV;
+ BEGV = BEG;
+ ZV = Z;
+
+ /* Is this char mouse-active? */
+ XSETINT (position, pos);
+
+ /* Put all the overlays we want in a vector in overlay_vec. */
+ GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
+ /* Sort overlays into increasing priority order. */
+ noverlays = sort_overlays (overlay_vec, noverlays, w);
+
+ /* Check mouse-face highlighting. */
+ if (!(EQ (window, mouse_face_window)
+ && y >= mouse_face_beg_row
+ && y <= mouse_face_end_row
+ && (y > mouse_face_beg_row
+ || x >= mouse_face_beg_col)
+ && (y < mouse_face_end_row
+ || x < mouse_face_end_col
+ || mouse_face_past_end)))
+ {
+ /* Clear the display of the old active region, if any. */
+ term_clear_mouse_face ();
+
+ /* Find the highest priority overlay that has a mouse-face
+ property. */
+ overlay = Qnil;
+ for (i = noverlays - 1; i >= 0; --i)
+ {
+ mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
+ if (!NILP (mouse_face))
+ {
+ overlay = overlay_vec[i];
+ break;
+ }
+ }
+
+ /* If no overlay applies, get a text property. */
+ if (NILP (overlay))
+ mouse_face = Fget_text_property (position, Qmouse_face,
+ w->buffer);
+
+ /* Handle the overlay case. */
+ if (!NILP (overlay))
+ {
+ /* Find the range of text around this char that
+ should be active. */
+ Lisp_Object before, after;
+ EMACS_INT ignore;
+
+
+ before = Foverlay_start (overlay);
+ after = Foverlay_end (overlay);
+ /* Record this as the current active region. */
+ fast_find_position (w, XFASTINT (before),
+ &mouse_face_beg_col,
+ &mouse_face_beg_row);
+
+ mouse_face_past_end
+ = !fast_find_position (w, XFASTINT (after),
+ &mouse_face_end_col,
+ &mouse_face_end_row);
+ mouse_face_window = window;
+
+ mouse_face_face_id
+ = face_at_buffer_position (w, pos, 0, 0,
+ &ignore, pos + 1, 1, -1);
+
+ /* Display it as active. */
+ term_show_mouse_face (DRAW_MOUSE_FACE);
+ }
+ /* Handle the text property case. */
+ else if (!NILP (mouse_face))
+ {
+ /* Find the range of text around this char that
+ should be active. */
+ Lisp_Object before, after, beginning, end;
+ EMACS_INT ignore;
+
+ beginning = Fmarker_position (w->start);
+ XSETINT (end, (BUF_Z (b) - XFASTINT (w->window_end_pos)));
+ before
+ = Fprevious_single_property_change (make_number (pos + 1),
+ Qmouse_face,
+ w->buffer, beginning);
+ after
+ = Fnext_single_property_change (position, Qmouse_face,
+ w->buffer, end);
+
+ /* Record this as the current active region. */
+ fast_find_position (w, XFASTINT (before),
+ &mouse_face_beg_col,
+ &mouse_face_beg_row);
+ mouse_face_past_end
+ = !fast_find_position (w, XFASTINT (after),
+ &mouse_face_end_col,
+ &mouse_face_end_row);
+ mouse_face_window = window;
+
+ mouse_face_face_id
+ = face_at_buffer_position (w, pos, 0, 0,
+ &ignore, pos + 1, 1, -1);
+
+ /* Display it as active. */
+ term_show_mouse_face (DRAW_MOUSE_FACE);
+ }
+ }
+
+ /* Look for a `help-echo' property. */
+ {
+ Lisp_Object help;
+ extern Lisp_Object Qhelp_echo;
+
+ /* Check overlays first. */
+ help = Qnil;
+ for (i = noverlays - 1; i >= 0 && NILP (help); --i)
+ {
+ overlay = overlay_vec[i];
+ help = Foverlay_get (overlay, Qhelp_echo);
+ }
+
+ if (!NILP (help))
+ {
+ help_echo_string = help;
+ help_echo_window = window;
+ help_echo_object = overlay;
+ help_echo_pos = pos;
+ }
+ /* Try text properties. */
+ else if (NILP (help)
+ && ((STRINGP (glyph->object)
+ && glyph->charpos >= 0
+ && glyph->charpos < SCHARS (glyph->object))
+ || (BUFFERP (glyph->object)
+ && glyph->charpos >= BEGV
+ && glyph->charpos < ZV)))
+ {
+ help = Fget_text_property (make_number (glyph->charpos),
+ Qhelp_echo, glyph->object);
+ if (!NILP (help))
+ {
+ help_echo_string = help;
+ help_echo_window = window;
+ help_echo_object = glyph->object;
+ help_echo_pos = glyph->charpos;
+ }
+ }
+ }
+
+ BEGV = obegv;
+ ZV = ozv;
+ current_buffer = obuf;
+ }
+ }
+}
+
+static int
+term_mouse_movement (FRAME_PTR frame, Gpm_Event *event)
+{
+ /* Has the mouse moved off the glyph it was on at the last sighting? */
+ if (event->x != last_mouse_x || event->y != last_mouse_y)
+ {
+ frame->mouse_moved = 1;
+ term_mouse_highlight (frame, event->x, event->y);
+ /* Remember which glyph we're now on. */
+ last_mouse_x = event->x;
+ last_mouse_y = event->y;
+ return 1;
+ }
+ return 0;
+}
+
+/* Return the current position of the mouse.
+
+ Set *f to the frame the mouse is in, or zero if the mouse is in no
+ Emacs frame. If it is set to zero, all the other arguments are
+ garbage.
+
+ Set *bar_window to Qnil, and *x and *y to the column and
+ row of the character cell the mouse is over.
+
+ Set *time to the time the mouse was at the returned position.
+
+ This clears mouse_moved until the next motion
+ event arrives. */
+static void
+term_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
+ enum scroll_bar_part *part, Lisp_Object *x,
+ Lisp_Object *y, unsigned long *time)
+{
+ struct timeval now;
+
+ *fp = SELECTED_FRAME ();
+ (*fp)->mouse_moved = 0;
+
+ *bar_window = Qnil;
+ *part = 0;
+
+ XSETINT (*x, last_mouse_x);
+ XSETINT (*y, last_mouse_y);
+ gettimeofday(&now, 0);
+ *time = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+}
+
+/* Prepare a mouse-event in *RESULT for placement in the input queue.
+
+ If the event is a button press, then note that we have grabbed
+ the mouse. */
+
+static Lisp_Object
+term_mouse_click (struct input_event *result, Gpm_Event *event,
+ struct frame *f)
+{
+ struct timeval now;
+ int i, j;
+
+ result->kind = GPM_CLICK_EVENT;
+ for (i = 0, j = GPM_B_LEFT; i < 3; i++, j >>= 1 )
+ {
+ if (event->buttons & j) {
+ result->code = i; /* button number */
+ break;
+ }
+ }
+ gettimeofday(&now, 0);
+ result->timestamp = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+
+ if (event->type & GPM_UP)
+ result->modifiers = up_modifier;
+ else if (event->type & GPM_DOWN)
+ result->modifiers = down_modifier;