matchbox-keyboard-key.c.svn-base

螢幕小鍵盤,可在Windows/linux上或其他嵌入式系統如手機上使用

			     MBKeyboardKeyStateType   state,
			     KeySym                   keysym)
{
  if (key->states[state] == NULL)
    _mb_kbd_key_init_state(key, state);

  key->states[state]->action.type = MBKeyboardKeyActionXKeySym;
  key->states[state]->action.u.keysym = keysym;
}

KeySym
mb_kbd_key_get_keysym_action(MBKeyboardKey           *key,
			     MBKeyboardKeyStateType   state)
{
  if (key->states[state] 
      && key->states[state]->action.type == MBKeyboardKeyActionXKeySym)
    return key->states[state]->action.u.keysym;

  return None;
}


void
mb_kbd_key_set_modifer_action(MBKeyboardKey          *key,
			      MBKeyboardKeyStateType  state,
			      MBKeyboardKeyModType    type)
{
  if (key->states[state] == NULL)
    _mb_kbd_key_init_state(key, state);

  key->states[state]->action.type = MBKeyboardKeyActionModifier;
  key->states[state]->action.u.type   = type;
}

MBKeyboardKeyModType 
mb_kbd_key_get_modifer_action(MBKeyboardKey          *key,
			      MBKeyboardKeyStateType  state)
{
  if (key->states[state] 
      && key->states[state]->action.type == MBKeyboardKeyActionModifier)
    return key->states[state]->action.u.type;

  return 0;
}

/* Changer action */
void
mb_kbd_key_set_changer_action(MBKeyboardKey          *key,
                              MBKeyboardKeyStateType  state,
                              MBKeyboardLayoutType    type)
{
  if (key->states[state] == NULL)
    _mb_kbd_key_init_state(key, state);

  key->states[state]->action.type = MBKeyboardKeyActionLayoutChanger;
  key->states[state]->action.u.layout_type   = type;
}

MBKeyboardLayoutType
mb_kbd_get_changer_action(MBKeyboardKey          *key,
                          MBKeyboardKeyStateType  state)
{
  if (key->states[state]
      && key->states[state]->action.type == MBKeyboardKeyActionLayoutChanger)
    return key->states[state]->action.u.layout_type;

  return 0;
}

MBKeyboardKeyFaceType
mb_kbd_key_get_face_type(MBKeyboardKey           *key,
			 MBKeyboardKeyStateType   state)
{
  if (key->states[state]) 
    return key->states[state]->face.type;

  return 0;
}


MBKeyboardKeyActionType
mb_kbd_key_get_action_type(MBKeyboardKey           *key,
			   MBKeyboardKeyStateType   state)
{
  if (key->states[state]) 
    return key->states[state]->action.type;

  return 0;
}


void
mb_kbd_key_press(MBKeyboardKey *key)
{
  /* XXX what about state handling XXX */
  MBKeyboardKeyStateType state;
  int                    flags = 0;
  boolean                queue_full_kbd_redraw = False;

  if (mb_kbd_key_is_blank(key))
    return;

  state = mb_kbd_keys_current_state(key->kbd);

  if (mb_kbd_has_state(key->kbd, MBKeyboardStateCaps)
      && mb_kbd_key_get_obey_caps(key))
    state = MBKeyboardKeyStateShifted;

  /* XXX below fakekey mods probably better in ui */

  if (state == MBKeyboardKeyStateShifted)
    flags |= FAKEKEYMOD_SHIFT; 	/* does fakekey actually need this ? */

  if (mb_kbd_has_state(key->kbd, MBKeyboardStateControl))
    flags |= FAKEKEYMOD_CONTROL;

  if (mb_kbd_has_state(key->kbd, MBKeyboardStateAlt))
    flags |= FAKEKEYMOD_ALT;

  if (!mb_kdb_key_has_state(key, state))
    {
      if (state == MBKeyboardKeyStateNormal)
	return;  /* keys should at least have a normal state */
      else
        state = MBKeyboardKeyStateNormal;
    }

  switch (mb_kbd_key_get_action_type(key, state))
    {
    case MBKeyboardKeyActionGlyph:
      {
	const char *key_char;

	if ((key_char = mb_kbd_key_get_char_action(key, state)) != NULL)
	  {
	    mb_kbd_ui_send_press(key->kbd->ui, key_char, flags);
	    mb_kbd_set_held_key(key->kbd, key);
	  }
	break;


      }
    case MBKeyboardKeyActionXKeySym:
      {
	KeySym ks;
	if ((ks = mb_kbd_key_get_keysym_action(key, state)) != None)
	  {
	    mb_kbd_ui_send_keysym_press(key->kbd->ui, ks, flags);
	    mb_kbd_set_held_key(key->kbd, key);
	  }
	break;
      }
    case MBKeyboardKeyActionModifier:
      {
	
	switch ( mb_kbd_key_get_modifer_action(key, state) )
	  {
	  case MBKeyboardKeyModShift:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateShifted);
	    queue_full_kbd_redraw = True;
	    break;
	  case MBKeyboardKeyModMod1:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateMod1);
	    queue_full_kbd_redraw = True;
	    break;
	  case MBKeyboardKeyModMod2:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateMod2);
	    queue_full_kbd_redraw = True;
	    break;
	  case MBKeyboardKeyModMod3:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateMod3);
	    queue_full_kbd_redraw = True;
	    break;
	  case MBKeyboardKeyModCaps:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateCaps);
	    queue_full_kbd_redraw = True;
	    break;
          case MBKeyboardKeyModControl:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateControl);
	    break;
	  case MBKeyboardKeyModAlt:
	    mb_kbd_toggle_state(key->kbd, MBKeyboardStateAlt);
	    break;
	  default:
	    DBG("unknown modifier action");
	    break;
	  }

	/* we dont actually have to send a key sym here - but should we ? 
         *
         * Also we dont set a held key, as we've changed the keyboard 
         * state instead.
	*/
	break;
      }
    /* If the key is a layout changer key */
    case MBKeyboardKeyActionLayoutChanger:
      {
        MBKeyboardLayoutType  type;

        type = mb_kbd_get_changer_action(key, state);
        if (type == mb_kbd_layout_get_type(key->kbd->selected_layout))
          break;

        if (mb_kbd_change_layout(key->kbd, type))
          queue_full_kbd_redraw = True;
        break;
      }

    default:
      break;
    }  
  
  if (queue_full_kbd_redraw)
    mb_kbd_redraw(key->kbd);
  else
    mb_kbd_redraw_key(key->kbd, key);
}

boolean 
mb_kbd_key_is_held(MBKeyboard *kbd, MBKeyboardKey *key)
{
  MBKeyboardKeyStateType  state;

  if (mb_kbd_get_held_key(key->kbd) ==  key)
    return True;

  /* XXX below should probably go into own func */

  state = mb_kbd_keys_current_state(kbd); 

  if (!mb_kdb_key_has_state(key, state))
    {
      if (state == MBKeyboardKeyStateNormal)
	return False;  /* keys should at least have a normal state */
      else
        state = MBKeyboardKeyStateNormal;
    }

  if (mb_kbd_key_get_action_type(key, state) == MBKeyboardKeyActionModifier)
    {
	switch ( mb_kbd_key_get_modifer_action(key, state) )
	  {
	  case MBKeyboardKeyModShift:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateShifted))
	      return True;
	    break;
	  case MBKeyboardKeyModMod1:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateMod1))
	      return True;
	    break;
	  case MBKeyboardKeyModMod2:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateMod2))
	      return True;
	    break;
	  case MBKeyboardKeyModMod3:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateMod3))
	      return True;
	    break;
	  case MBKeyboardKeyModCaps:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateCaps))
	      return True;
	    break;
          case MBKeyboardKeyModControl:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateControl))
	      return True;
	    break;
	  case MBKeyboardKeyModAlt:
	    if (mb_kbd_has_state(kbd, MBKeyboardStateAlt))
	      return True;
	    break;
	  default:
	    DBG("unknown modifier action");
	    break;
	  }
    }
  else if (mb_kbd_key_get_action_type(key, state) == MBKeyboardKeyActionLayoutChanger)
    {
      if(mb_kbd_get_changer_action(key, state) == mb_kbd_layout_get_type(kbd->selected_layout))
        return True;

      return False;
    }

  return False;
}

void
mb_kbd_key_release(MBKeyboard *kbd)
{
  MBKeyboardKey *key = mb_kbd_get_held_key(kbd);

  mb_kbd_set_held_key(kbd, NULL);

  if (key)
    {
      boolean queue_full_kbd_redraw = False;

      if (mb_kbd_key_get_action_type(key, MBKeyboardKeyStateNormal) != MBKeyboardKeyActionModifier)
	{
	  if (mb_kbd_has_any_state(kbd))
	    {
	      mb_kbd_remove_state(kbd, (MBKeyboardStateShifted|
					MBKeyboardStateMod1|
					MBKeyboardStateMod2|
					MBKeyboardStateMod3|
					MBKeyboardStateControl|
					MBKeyboardStateAlt));
	      queue_full_kbd_redraw = True;
	    }
	}

      if (queue_full_kbd_redraw)
	mb_kbd_redraw(key->kbd);
      else
	mb_kbd_redraw_key(key->kbd, key);

      mb_kbd_ui_send_release(kbd->ui);
    }
}

void
mb_kbd_key_dump_key(MBKeyboardKey *key)
{
  int i;

  char state_lookup[][32] =
    {
      /* MBKeyboardKeyStateNormal  */ "Normal",
      /* MBKeyboardKeyStateShifted */ "Shifted" ,
      /* MBKeyboardKeyStateMod1,    */ "Mod1" ,
      /* MBKeyboardKeyStateMod2,    */ "Mod2" ,
      /* MBKeyboardKeyStateMod3,    */ "Mod3" 
    };

  fprintf(stderr, "-------------------------------\n");
  fprintf(stderr, "Dumping info for key at %p\n", key);

  for (i = 0; i < N_MBKeyboardKeyStateTypes; i++)
    {
      if (mb_kdb_key_has_state(key, i))
	{
	  fprintf(stderr, "state : %s\n", state_lookup[i]);
	  fprintf(stderr, "\tface type %i", mb_kbd_key_get_face_type(key, i));

	  if (mb_kbd_key_get_face_type(key, i) == MBKeyboardKeyFaceGlyph)
	    {
	      fprintf(stderr, ", showing '%s'", 
		      mb_kbd_key_get_glyph_face(key , i));
	    }

	  fprintf(stderr, "\n");

	  fprintf(stderr, "\taction type %i\n", 
		  mb_kbd_key_get_action_type(key, i));

	}
    }

  fprintf(stderr, "-------------------------------\n");

}