void (*frame_up_to_date_hook) P_ ((struct frame *));
-/* 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.
-
- If the motion started in a scroll bar, set *bar_window to the
- scroll bar's window, *part to the part the mouse is currently over,
- *x to the position of the mouse along the scroll bar, and *y to the
- overall length of the scroll bar.
-
- Otherwise, 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 should clear mouse_moved until the next motion
- event arrives. */
-
void (*mouse_position_hook) P_ ((FRAME_PTR *f, int insist,
Lisp_Object *bar_window,
enum scroll_bar_part *part,
char *tparam ();
extern char *tgetstr ();
+
+static void term_clear_mouse_face ();
+static void term_mouse_highlight (struct frame *f, int x, int y);
\f
#ifdef WINDOWSNT
#define FRAME_TERMCAP_P(_f_) 0
#endif /* WINDOWSNT */
+#ifdef HAVE_GPM_H
+#include <sys/fcntl.h>
+#include "buffer.h"
+
+/* Nonzero means mouse is enabled on Linux console. */
+int term_gpm = 0;
+
+/* These variables describe the range of text currently shown in its
+ mouse-face, together with the window they apply to. As long as
+ the mouse stays within this range, we need not redraw anything on
+ its account. Rows and columns are glyph matrix positions in
+ MOUSE_FACE_WINDOW. */
+static int mouse_face_beg_row, mouse_face_beg_col;
+static int mouse_face_end_row, mouse_face_end_col;
+static int mouse_face_past_end;
+static Lisp_Object mouse_face_window;
+static int mouse_face_face_id;
+
+/* FRAME and X, Y position of mouse when last checked for
+ highlighting. X and Y can be negative or out of range for the frame. */
+struct frame *mouse_face_mouse_frame;
+int mouse_face_mouse_x, mouse_face_mouse_y;
+
+static int pos_x, pos_y;
+static int last_mouse_x, last_mouse_y;
+#endif /* HAVE_GPM_H */
+
void
ring_bell ()
{
cmcheckmagic ();
}
+void
+write_glyphs_with_face (string, len, face_id)
+ register struct glyph *string;
+ register int len, face_id;
+{
+ struct frame *sf = XFRAME (selected_frame);
+ struct frame *f = updating_frame ? updating_frame : sf;
+ unsigned char *conversion_buffer;
+ struct coding_system *coding;
+
+ turn_off_insert ();
+ tty_hide_cursor ();
+
+ /* Don't dare write in last column of bottom line, if Auto-Wrap,
+ since that would scroll the whole frame on some terminals. */
+
+ if (AutoWrap
+ && curY + 1 == FRAME_LINES (sf)
+ && (curX + len) == FRAME_COLS (sf))
+ len --;
+ if (len <= 0)
+ return;
+
+ cmplus (len);
+
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always return 1 if the member src_multibyte is 1. */
+ coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+ ? &terminal_coding : &safe_terminal_coding);
+ /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
+ the tail. */
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
+
+
+ /* Turn appearance modes of the face. */
+ highlight_if_desired ();
+ turn_on_face (f, face_id);
+
+ coding->mode |= CODING_MODE_LAST_BLOCK;
+ conversion_buffer = encode_terminal_code (string, len, coding);
+ if (coding->produced > 0)
+ {
+ BLOCK_INPUT;
+ fwrite (conversion_buffer, 1, coding->produced, stdout);
+ if (ferror (stdout))
+ clearerr (stdout);
+ if (termscript)
+ fwrite (conversion_buffer, 1, coding->produced, termscript);
+ UNBLOCK_INPUT;
+ }
+
+ /* Turn appearance modes off. */
+ turn_off_face (f, face_id);
+ turn_off_highlight ();
+
+ cmcheckmagic ();
+}
+
/* If start is zero, insert blanks instead of a string at start */
void
#endif /* !WINDOWSNT */
+\f
+/***********************************************************************
+ Mouse
+ ***********************************************************************/
+
+#ifdef HAVE_GPM_H
+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, j;
+
+ 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;
+ save_x = curX;
+
+ /* 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 (pos_y, pos_x);
+
+ if (draw == DRAW_MOUSE_FACE)
+ {
+ write_glyphs_with_face (row->glyphs[TEXT_AREA] + start_hpos,
+ nglyphs, mouse_face_face_id);
+ }
+ else /* draw == DRAW_NORMAL_TEXT */
+ write_glyphs (row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
+ }
+ cursor_to (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;
+
+ mouse_face_mouse_x = x;
+ mouse_face_mouse_y = y;
+ mouse_face_mouse_frame = f;
+
+ /* 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;
+ 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);
+
+ /* 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;
+ 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);
+
+ /* 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 - 1, event->y - 1);
+ /* 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 should clear mouse_moved until the next motion
+ event arrives.
+
+ NOT CURRENTLY INVOKED: see mouse_position_hook below. */
+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)
+{
+ Gpm_Event event;
+ struct timeval now;
+ int i;
+
+ BLOCK_INPUT;
+
+ *fp = SELECTED_FRAME ();
+
+ *bar_window = Qnil;
+ *part = 0;
+
+ i = Gpm_GetSnapshot (&event);
+
+ XSETINT (*x, event.x);
+ XSETINT (*y, event.y);
+ gettimeofday(&now, 0);
+ *time = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+
+ UNBLOCK_INPUT;
+}
+
+/* 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;
+ else
+ result->modifiers = 0;
+
+ if (event->type & GPM_SINGLE)
+ result->modifiers |= click_modifier;
+
+ if (event->type & GPM_DOUBLE)
+ result->modifiers |= double_modifier;
+
+ if (event->type & GPM_TRIPLE)
+ result->modifiers |= triple_modifier;
+
+ if (event->type & GPM_DRAG)
+ result->modifiers |= drag_modifier;
+
+ if (!(event->type & (GPM_MOVE|GPM_DRAG))) {
+
+ /* 1 << KG_SHIFT */
+ if (event->modifiers & (1 << 0))
+ result->modifiers |= shift_modifier;
+
+ /* 1 << KG_CTRL */
+ if (event->modifiers & (1 << 2))
+ result->modifiers |= ctrl_modifier;
+
+ /* 1 << KG_ALT || KG_ALTGR */
+ if (event->modifiers & (1 << 3)
+ || event->modifiers & (1 << 1))
+ result->modifiers |= meta_modifier;
+ }
+
+ XSETINT (result->x, event->x - 1);
+ XSETINT (result->y, event->y - 1);
+ XSETFRAME (result->frame_or_window, f);
+ result->arg = Qnil;
+ return Qnil;
+}
+
+int
+handle_one_term_event (Gpm_Event *event, struct input_event* hold_quit)
+{
+ struct frame *f = SELECTED_FRAME ();
+ int i, j, fd;
+ struct input_event ie;
+ int do_help = 0;
+ int count = 0;
+
+ EVENT_INIT (ie);
+ ie.kind = NO_EVENT;
+ ie.arg = Qnil;
+
+ if (event->type & GPM_MOVE) {
+ unsigned char buf[6 * sizeof (short)];
+ unsigned short *arg = (unsigned short *) buf + 1;
+ const char *name;
+
+ previous_help_echo_string = help_echo_string;
+ help_echo_string = Qnil;
+
+ /* Display mouse pointer */
+ buf[sizeof(short) - 1] = 2; /* set selection */
+
+ arg[0] = arg[2] = (unsigned short) event->x;
+ arg[1] = arg[3] = (unsigned short) event->y;
+ arg[4] = (unsigned short) 3;
+
+ name = (const char *) ttyname (0);
+ fd = open (name, O_WRONLY);
+ ioctl (fd, TIOCLINUX, buf + sizeof (short) - 1);
+ close(fd);
+
+ term_mouse_movement (f, event);
+
+ /* If the contents of the global variable help_echo_string
+ has changed, generate a HELP_EVENT. */
+ if (!NILP (help_echo_string)
+ || !NILP (previous_help_echo_string))
+ do_help = 1;
+
+ goto done;
+ }
+ else {
+ f->mouse_moved = 0;
+ term_mouse_click (&ie, event, f);
+ //kbd_buffer_store_event_hold (&ie, hold_quit);
+ }
+
+ done:
+ if (ie.kind != NO_EVENT)
+ {
+ kbd_buffer_store_event_hold (&ie, hold_quit);
+ count++;
+ }
+
+ if (do_help
+ && !(hold_quit && hold_quit->kind != NO_EVENT))
+ {
+ Lisp_Object frame;
+
+ if (f)
+ XSETFRAME (frame, f);
+ else
+ frame = Qnil;
+
+ gen_help_event (help_echo_string, frame, help_echo_window,
+ help_echo_object, help_echo_pos);
+ count++;
+ }
+
+ return count;
+}
+
+DEFUN ("term-open-connection", Fterm_open_connection, Sterm_open_connection,
+ 0, 0, 0,
+ doc: /* Open a connection to Gpm. */)
+ ()
+{
+ Gpm_Connect connection;
+
+ connection.eventMask = ~0;
+ connection.defaultMask = ~GPM_HARD;
+ connection.maxMod = ~0;
+ connection.minMod = 0;
+
+ if (Gpm_Open (&connection, 0) < 0)
+ return Qnil;
+ else
+ {
+ term_gpm = 1;
+ reset_sys_modes ();
+ init_sys_modes ();
+ add_gpm_wait_descriptor (gpm_fd);
+ return Qt;
+ }
+}
+
+DEFUN ("term-close-connection", Fterm_close_connection, Sterm_close_connection,
+ 0, 0, 0,
+ doc: /* Close a connection to Gpm. */)
+ ()
+{
+ delete_gpm_wait_descriptor (gpm_fd);
+ while (Gpm_Close()); /* close all the stack */
+ term_gpm = 0;
+ return Qnil;
+}
+#endif /* HAVE_GPM_H */
+
\f
/***********************************************************************
Initialization
encode_terminal_bufsize = 0;
+#ifdef HAVE_GPM_H
+ /* TODO: Can't get Gpm_Snapshot in term_mouse_position to work: test with
+ (mouse-position). Also set-mouse-position won't work as is. */
+ /* mouse_position_hook = term_mouse_position; */
+
+ mouse_face_window = Qnil;
+#endif
+
#ifdef WINDOWSNT
initialize_w32_display ();
defsubr (&Stty_display_color_p);
defsubr (&Stty_display_color_cells);
defsubr (&Stty_no_underline);
+#ifdef HAVE_GPM_H
+ defsubr (&Sterm_open_connection);
+ defsubr (&Sterm_close_connection);
+#endif /* HAVE_GPM_H */
fullscreen_hook = NULL;
}
projects / emacs.git / commitdiff