gdkkeyboard-fb.c

linux下电话本所依赖的一些图形库

  {0, 0, 0},
  {0, 0, 0},
  {GDK_Home, 0, 0},
  {GDK_Up, 0, 0},
  {GDK_Page_Up, 0, 0},
  {GDK_Left, 0, 0},
  {GDK_Right, 0, 0},
  {GDK_End, 0, 0},
  {GDK_Down, 0, 0},
  {GDK_Page_Down, 0, 0},
  {GDK_Insert, 0, 0},
  {GDK_Delete, 0, 0},

	/* 0x70 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0x80 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0x90 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xA0 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xB0 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xC0 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {GDK_Up, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {GDK_Left, 0, 0},
  {0, 0, 0},
  {GDK_Right, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xD0 */
  {GDK_Down, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xE0 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},

	/* 0xF0 */
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
};

static gboolean
raw_io (GIOChannel *gioc,
	GIOCondition cond,
	gpointer data)
{
  GdkFBKeyboard *k = data;
  guchar buf[128];
  int i, n;

  n = read (k->fd, buf, sizeof(buf));
  if (n <= 0)
    g_error("Nothing from keyboard!");

  for (i = 0; i < n; i++)
    {
      guchar keycode;
      gboolean key_up;
      char dummy[2];
      int len;
      int mod;
      guint keyval;

      keycode = buf[i] & 0x7F;
      key_up = buf[i] & 0x80;

      if (keycode > G_N_ELEMENTS (trans_table))
	{
	  g_warning ("Unknown keycode");
	  continue;
	}

      if ( (keycode == 0x1D) /* left Ctrl */
	   || (keycode == 0x9D) /* right Ctrl */
	   || (keycode == 0x38) /* left Alt */
	   || (keycode == 0xB8) /* right Alt */
	   || (keycode == 0x2A) /* left Shift */
	   || (keycode == 0x36) /* right Shift */)
	{
	  switch (keycode)
	    {
	    case 0x1D: /* Left Ctrl */
	    case 0x9D: /* Right Ctrl */
	      if (key_up)
		k->modifier_state &= ~GDK_CONTROL_MASK;
	      else
		k->modifier_state |= GDK_CONTROL_MASK;
	      break;
	    case 0x38: /* Left Alt */
	    case 0xB8: /* Right Alt */
	      if (key_up)
		k->modifier_state &= ~GDK_MOD1_MASK;
	      else
		k->modifier_state |= GDK_MOD1_MASK;
	      break;
	    case 0x2A: /* Left Shift */
	    case 0x36: /* Right Shift */
	      if (key_up)
		k->modifier_state &= ~GDK_SHIFT_MASK;
	      else
		k->modifier_state |= GDK_SHIFT_MASK;
	      break;
	    }
	  continue; /* Don't generate events for modifiers */
	}

      if (keycode == 0x3A /* Caps lock */)
	{
	  if (!key_up)
	    k->caps_lock = !k->caps_lock;
	  
	  ioctl (k->fd, KDSETLED, k->caps_lock ? LED_CAP : 0);
	  continue;
	}

      if (trans_table[keycode][0] >= GDK_F1 &&
	  trans_table[keycode][0] <= GDK_F35 &&
	  (k->modifier_state & GDK_MOD1_MASK))
	{
	  if (key_up) /* Only switch on release */
	    {
	      gint vtnum = trans_table[keycode][0] - GDK_F1 + 1;

	      /* Do the whole funky VT switch thing */
	      ioctl (gdk_display->console_fd, VT_ACTIVATE, vtnum);
	    }

	  continue;
	}

      keyval = 0;
      mod = 0;
      if (k->modifier_state & GDK_CONTROL_MASK)
	mod = 2;
      else if (k->modifier_state & GDK_SHIFT_MASK)
	mod = 1;
      do {
	keyval = trans_table[keycode][mod--];
      } while (!keyval && (mod >= 0));

      if (k->caps_lock && (keyval >= 'a') && (keyval <= 'z'))
	keyval = toupper (keyval);

      if (!keyval)
	continue;

      len = isprint (keyval) ? 1 : 0;
      dummy[0] = keyval;
      dummy[1] = 0;

      gdk_fb_handle_key (keycode,
			 keyval,
			 k->modifier_state,
			 0,
			 (len)?g_strdup(dummy):NULL,
			 len,
			 key_up);
    }

  return TRUE;
}

static gboolean
raw_open (GdkFBKeyboard *kb)
{
  const char cursoroff_str[] = "\033[?1;0;0c";
  struct termios ts;
  
  tcgetattr (gdk_display->tty_fd, &ts);
  ts.c_cc[VTIME] = 0;
  ts.c_cc[VMIN] = 1;
  ts.c_lflag &= ~(ICANON|ECHO|ISIG);
  ts.c_iflag = 0;
  tcsetattr (gdk_display->tty_fd, TCSAFLUSH, &ts);

  tcsetpgrp (gdk_display->tty_fd, getpgrp());

  write_string (gdk_display->tty_fd, cursoroff_str);
  
  if (ioctl (gdk_display->tty_fd, KDSKBMODE, K_MEDIUMRAW) < 0)
    {
      g_warning ("setting tty to K_MEDIUMRAW failed (are you root?)");
      return FALSE;
    }

  kb->fd = gdk_display->tty_fd;
  kb->io = g_io_channel_unix_new (kb->fd);
  kb->io_tag = g_io_add_watch (kb->io,
			       G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
			       raw_io,
			       kb);
  
  return TRUE;
}

static void
raw_close (GdkFBKeyboard *kb)
{
  struct termios ts;
  const char cursoron_str[] = "\033c";

  write_string (gdk_display->tty_fd, cursoron_str);

  tcgetattr (gdk_display->tty_fd, &ts);
  ts.c_lflag |= (ICANON|ECHO|ISIG);
  tcsetattr (gdk_display->tty_fd, TCSAFLUSH, &ts);
  
  ioctl (gdk_display->tty_fd, KDSKBMODE, K_XLATE);

  g_source_remove (kb->io_tag);
  g_io_channel_unref (kb->io);
  /* don't close kb->fd, it is the tty from gdk_display */
}

static guint
raw_lookup (GdkFBKeyboard       *kb,
	    const GdkKeymapKey  *key)
{
  if (key->group != 0)
    return 0;
  if ((key->keycode < 0) || (key->keycode >= 256))
    return 0;
  if ((key->level < 0) || (key->level >= 3))
    return 0;
  return trans_table[key->keycode][key->level];
}

static gboolean
raw_translate (GdkFBKeyboard       *kb,
	       guint                hardware_keycode,
	       GdkModifierType      state,
	       gint                 group,
	       guint               *keyval,
	       gint                *effective_group,
	       gint                *level,
	       GdkModifierType     *consumed_modifiers)
{
  guint tmp_keyval;
  gint tmp_level;

  if (keyval)
    *keyval = 0;
  if (effective_group)
    *effective_group = 0;
  if (level)
    *level = 0;
  if (consumed_modifiers)
    *consumed_modifiers = 0;

  if ((hardware_keycode < 0) || (hardware_keycode >= 256))
    return FALSE;

  if (group != 0)
    return FALSE;

  if (state & GDK_CONTROL_MASK)
    tmp_level = 2;
  else if (state & GDK_SHIFT_MASK)
    tmp_level = 1;
  else
    tmp_level = 0;

  do {
    tmp_keyval = trans_table[hardware_keycode][tmp_level --];
  } while (!tmp_keyval && (tmp_level >= 0));

  if (keyval)
    *keyval = tmp_keyval;
  if (level)
    *level = tmp_level;

  return TRUE;
}

static gboolean
raw_get_for_keyval (GdkFBKeyboard       *kb,
		    guint                keyval,
		    GdkKeymapKey       **keys,
		    gint                *n_keys)
{
  GArray *retval;
  int i, j;

  retval = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));

  for (i = 0; i < 256; i++)
    for (j = 0; j < 3; j++)
      if (trans_table[i][j] == keyval)
	{
	  GdkKeymapKey key;

	  key.keycode = i;
	  key.group = 0;
	  key.level = j;

	  g_array_append_val (retval, key);
	}

  if (retval->len > 0)
    {
      *keys = (GdkKeymapKey*) retval->data;
      *n_keys = retval->len;
    }
  else
    {
      *keys = NULL;
      *n_keys = 0;
    }

  g_array_free (retval, retval->len > 0 ? FALSE : TRUE);

  return *n_keys > 0;
}

static gboolean
raw_get_for_keycode (GdkFBKeyboard       *kb,
		     guint                hardware_keycode,
		     GdkKeymapKey       **keys,
		     guint              **keyvals,
		     gint                *n_entries)
{
  GArray *key_array;
  GArray *keyval_array;
  int i;

  if (hardware_keycode <= 0 ||
      hardware_keycode >= 256)
    { 
      if (keys)
        *keys = NULL;
      if (keyvals)
        *keyvals = NULL;

      *n_entries = 0;
      return FALSE;
    }

  if (keys)
    key_array = g_array_new (FALSE, FALSE, sizeof (GdkKeymapKey));
  else
    key_array = NULL;

  if (keyvals)
    keyval_array = g_array_new (FALSE, FALSE, sizeof (guint));
  else
    keyval_array = NULL;

  for (i = 0; i < 3; i++)
    {
      if (key_array)
	{
	  GdkKeymapKey key;

	  key.keycode = hardware_keycode;
	  key.group = 0;
	  key.level = i;

	  g_array_append_val (key_array, key);
	}

      if (keyval_array)
	{
	  g_array_append_val (keyval_array, trans_table[hardware_keycode][i]);
	}
    }

  if ((key_array && key_array->len > 0) ||
      (keyval_array && keyval_array->len > 0))
    { 
      if (keys)
        *keys = (GdkKeymapKey*) key_array->data;

      if (keyvals)
        *keyvals = (guint*) keyval_array->data;

      if (key_array)
        *n_entries = key_array->len;
      else
        *n_entries = keyval_array->len;
    }
  else
    { 
      if (keys)
        *keys = NULL;

      if (keyvals)
        *keyvals = NULL;

      *n_entries = 0;
    }

  if (key_array)
    g_array_free (key_array, key_array->len > 0 ? FALSE : TRUE);
  if (keyval_array)
    g_array_free (keyval_array, keyval_array->len > 0 ? FALSE : TRUE);

  return *n_entries > 0;
}