Re: [Bug-xnee] Update on bug 8138

[Henrik Sandklef]

Hi!

I have tested both solution. Both have drawbacks :(

With my solution we have to create an event to lookup what keysym will be
generated with keycode+komdifier(s).

With your solution we have to create a table with mappings such as
  "slash" <----> "/"

Correct me if I am wrong!!!!!!!!!!!!!!!!




My testcode (not very nice or "fail safe", I know). To use it add
arguments such as "\" (really you need to type "\\") "/" "@" ....only the
first arg is used :(


#include <stdio.h>
#include <Xlib.h>
#include <X.h>
#include <Xutil.h>
#include <keysym.h>
#include <keysymdef.h>

static XModifierKeymap *map = NULL;
  int masks[] =
    {
      0,
      ShiftMask,
      ControlMask,
      LockMask,
      Mod1Mask,
      Mod2Mask,
      Mod3Mask,
      Mod4Mask,
      Mod5Mask,
      -1
    } ;


  char *mask_names[] =
    {
      "none" ,
      "shift",
      "control",
      "lock",
      "mod1",
      "mod2",
      "mod3",
      "mod4",
      "mod5",
      "-1",
      "-1"
    };


void
key_to_ascii (Display *dpy,
              KeySym *keysym,
              int keycode,
              int mod_state,
              char *string,
              char *pretty)
{
  XEvent event;
  int size;
  int i ;
  char *p = pretty ;

  event.xkey.type = KeyPress;
  event.xkey.display = dpy ;
  event.xkey.time = CurrentTime;
  event.xkey.x = event.xkey.y = 0;
  event.xkey.x_root = event.xkey.y_root = 0;
  event.xkey.state = mod_state;
  event.xkey.keycode = keycode;

  size = XLookupString ((XKeyEvent *) &event, string, 50, keysym, 0);
  string [size] = 0;
  for (i = 0; i < size; i++)
    {
      unsigned char c = (unsigned char) string [i];
      unsigned char hic = 0;


      if (c >= 0200)
        {
          *p++ = 'M';
          *p++ = '-';
          hic = c;
          c -= 0200;
        }

      if (c < 040)
        {
          *p++ = '^';
          *p++ = c + ('A'-1);
          if (! hic) hic = c;
        }
      else if (c == 0177)
        {
          *p++ = '^';
          *p++ = '?';
          if (! hic) hic = c;
        }
      else
        *p++ = c;
    }
  *p = 0;
}

int
joe(Display *dpy, KeySym req_keysym, char *keystring)
{
  int index;
  int return_value;
  char *check_string;
  KeyCode check_keycode;
  KeySym check_keysym;
  KeyCode keycode;

  index = 1;
  keycode = XKeysymToKeycode(dpy,req_keysym);
  printf ("J keycode = %d \n", keycode);
  for (index=0;index<8;index++)
    {
      check_keysym = XKeycodeToKeysym(dpy, keycode, index);
      check_string = XKeysymToString(check_keysym);
      if (check_string!=NULL)
        {
          printf ("........ is  '%s' == '%s'  ?????\n", check_string, 
keystring);
          if (strcmp(check_string, keystring ) == 0 )
            {
              printf ("........ the power of equality '%s' '%s'  :)\n",
check_string, keystring);
              break;
            }
        }
    }
  printf (" modifier index=%d\n", index);
  return return_value;
}


int
hesa(Display *dpy, KeySym req_keysym, char *keyname)
{
  KeySym ksym ;
  int ks_per_kc;
  int i ;
  int j ;
  int k ;
  int keycode = 0;
  char buf[50];
  char buf2[50];
  int mod_index = 0;



  keycode = XKeysymToKeycode(dpy,req_keysym);
  printf ("H keycode = %d \n", keycode);


  for (i=0;masks[i]!=-1;i++)
    {
      key_to_ascii (dpy, &ksym, keycode, masks[i],
                    buf, buf2);
/*        printf ("keycode=%d i=%d   argv=%s  mask=%d    '%s'   '%s' \n", 
 */
/*                keycode, i,keyname,  */
/*                masks[i], buf, buf2);  */

      if (strcmp(keyname,buf)==0)
        {
          break;
        }
    }

  if ( i == 0 )
    {
      printf ("H modifier = 0\n");
    }
  else if ( masks[i] == -1 )
    {
      printf (" error when finding mods\n");
    }
  else
    {
      KeySym ks ;
      char *nm ;
      k = (i-1)*map->max_keypermod ;
      ks = XKeycodeToKeysym(dpy,
                            map->modifiermap[k],
                            0);
      nm = XKeysymToString(ks);



      printf ("H keycode = %d ",map->modifiermap[k]);
      printf ("\n");
    }


}

int main(int argc, char **argv)
{
  char *ks ;
  Display *dpy = XOpenDisplay(NULL);

  int TEST_KEYSYM ;
  int k =0;

  map = XGetModifierMapping(dpy);

  if (argc==1)
    TEST_KEYSYM = XK_slash;
  else
    {
      if (strncmp(argv[1],"amp",3)==0)
        {
          TEST_KEYSYM = XK_ampersand;
        }
      else if (strncmp(argv[1],"que",3)==0)
        {
          TEST_KEYSYM = XK_question;
        }
      else if (strncmp(argv[1],"back",4)==0)
        {
          TEST_KEYSYM = XK_backslash;
        }
      else if (strncmp(argv[1],"\\",4)==0)
        {
          TEST_KEYSYM = XK_backslash;
        }
      else if (strncmp(argv[1],"/",4)==0)
        {
          TEST_KEYSYM = XK_slash;
        }
      else if (strncmp(argv[1],"a",1)==0)
        {
          TEST_KEYSYM = XK_a;
        }
      else if (strncmp(argv[1],"@",1)==0)
        {
          TEST_KEYSYM = XK_at;
        }
      else if (strncmp(argv[1],"shiftl",6)==0)
        {
          TEST_KEYSYM = XK_Shift_L;
        }
      else if (strncmp(argv[1],"shiftr",6)==0)
        {
          TEST_KEYSYM = XK_Shift_R;
        }
      else if (strncmp(argv[1],"plus",4)==0)
        {
          TEST_KEYSYM = XK_plus;
        }
      else
        {
          TEST_KEYSYM = XStringToKeysym(argv[1]);
        }
    }



  hesa(dpy, TEST_KEYSYM, argv[1]);
  joe(dpy, TEST_KEYSYM, argv[1]);

  XCloseDisplay(dpy);

}







> Henrik -
>
> As I wrote in my previous email, I have only tested this concept with
> regular keys and key with the SHIFT modifier. If expanded to work with
> all modifiers (which I can't test since my keyboards don't require the
> use of other modifiers in their standard configuration) my idea is
> remarkably similar to yours.
>
> 0. Create a modifier map with XGetModifierMapping.
> 1. Read a character from a file and get it's keysym string. ("slash",
> "question", "space" , etc.)
> 2. Get the keycode based on the keysym obtained in step 1.
> 3. Start with a modifier index of 0 (which will be a key without
> modifiers).
> 4. Perform a XKeycodeToKeysym on the keycode obtained in step 2 and the
> modifier index.
> 5. Perform a XKeysymToString on the keysym obtained in step 4.
> 6. If the keysym obtained in step 5 is the same as the keysym obtained
> in step 1, then we have a match. If not (and we still have more
> modifiers to check), increment the modifier index and go back to step 4.
> 7. If step 6 found a match, we now have the keysym and the modifier and
> are ready to generate a fake key event.
>
> My solution attempts to avoid generating events and the interpreting
> them. Even though my solution has more steps, I think would actually be
> simpler to implement. I don't claim that what I am attempting will work
> for anything other than standard keys and ones that require pressing the
> SHIFT key.
>
> Here is the test code that I wrote. It only checks for the results of
> the SHIFT key modifier. If it doesn't find a match, it assumes a key
> with no modifiers. Obviously, the real world is more complicated.
> Nevertheless, if the concepts behind my solution are correct, you should
> have no problem changing the code to check all modifiers.
>
> int
> xnee_shiftkeysetting(xnee_data *xd, char *keystring, xnee_key_code *kc)
> {
>
>   int index;
>   int return_value;
>   char *check_string;
>   KeyCode check_keycode;
>   KeySym check_keysym;
>
>   index = 1;
>   check_keysym = XKeycodeToKeysym(xd->fake, kc->kc, index);
>   check_string = XKeysymToString(check_keysym);
>   xnee_verbose ((xd, "The character to check is %s\n", keystring));
>   xnee_verbose ((xd, "The shifted version is %s\n", check_string));
>   if (strcmp(check_string, keystring ) == 0 )
>     {
>     return_value = 1;
>     xnee_verbose ((xd, "The character to retype is shifted!\n"));
>     }
>   else
>     {
>     return_value = 0;
>     xnee_verbose ((xd, "The character to retype is NOT shifted!\n"));
>     }
>     return return_value;
> }
>
> Here is a sample call of that routine from a modified version of
> xnee_char2keycode. I am sure you will recognize the code segment despite
> my changes.
>
>     case '/':
>       /* kc->shift_press=1; */
>       kc->kc = xnee_str2keycode(xd,"slash");
>       kc->shift_press = xnee_shiftkeysetting(xd, "slash", kc);
>       break;
>
> In theory, this should work on any keyboard that doesn't require XIM.
>
> So, what do you think? Is this a viable solution or did I just wander
> down a dead end?
>
> Also, thank you for the output of xmodmap. It gave me a little more
> insight into the relationship between keysyms and keycodes.
>
> - Joe
>
>
>>
>>
>
>


-- 
"There is no system but Gnu and Linux is one of its kernels"
   - rms -