Mercurial > emacs

--- a/src/term.c	Sun May 20 02:26:33 2007 +0000
+++ b/src/term.c	Sun May 20 02:27:53 2007 +0000
@@ -144,25 +144,6 @@

 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,
@@ -413,6 +394,9 @@
 char *tparam ();

 extern char *tgetstr ();
+
+static void term_clear_mouse_face ();
+static void term_mouse_highlight (struct frame *f, int x, int y);


 #ifdef WINDOWSNT
@@ -426,6 +410,33 @@
 #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 ()
 {
@@ -1010,6 +1021,65 @@
   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
@@ -2308,6 +2378,656 @@


 /***********************************************************************
+			       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 */
+
+
+/***********************************************************************
 			    Initialization
  ***********************************************************************/

@@ -2325,6 +3045,14 @@

   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 ();

@@ -2772,6 +3500,10 @@
   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;
 }