/xkbdata.c

/*  xkbdata.c -- Manage XKB datastructures.

    Copyright (C) 2003  Marco Gerards
   
    Written by Marco Gerards <marco@student.han.nl>
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
  
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.  */

/* Generate a key for the string S.  XXX: The are many more effecient
   algoritms, this one should be replaced by one of those.  */

#include <stdlib.h>
#include <string.h>
#include <hurd/ihash.h>
#include "xkb.h"

static int
name_hash (char *s)
{
  int i = 0;
  while (*s)
      i += *(s++);
  return i;
}


/* A keyname with a keycode and realmodifier bound to it.  */
struct keyname
{
  int keycode;
  int rmods;
};

static struct hurd_ihash kn_mapping;

/* Initialize the keyname hashtable.  */
static void
keyname_init ()
{
  hurd_ihash_init (&kn_mapping, HURD_IHASH_NO_LOCP);
  debug_printf ("Kn_mapping init");
  /* XXX: error.  */
}

static inline int
keyname_hash(char *keyname)
{
  char tmp[4] = { 0 };
  strncpy(tmp, keyname, sizeof tmp);
  return tmp[0] + (tmp[1] << 8) + (tmp[2] << 16) + (tmp[3] << 24);
}

/* Assign the name KEYNAME to the keycode KEYCODE.  */
error_t
keyname_add (char *keyname, int keycode)
{
  struct keyname *kn;
  int kn_int;

  kn = malloc (sizeof (struct keyname));
  if (!kn)
    return ENOMEM;

  /* XXX: 4 characters can be mapped into a int, it is safe to assume
     this will not be changed.  */
  if (strlen (keyname) > 4)
    {
      debug_printf ("The keyname `%s' consist of more than 4 characters;"
		    " 4 characters is the maximum.\n", keyname);
      /* XXX: Abort?  */
      return 0;
    }
  
  kn->keycode = keycode;
  kn->rmods = 0;

  kn_int = keyname_hash(keyname);
  debug_printf ("add key %s(%d) hash: %d\n", keyname, keycode, kn_int);
  hurd_ihash_add (&kn_mapping, kn_int, kn);

  return 0;
}

/* Find the numberic representation of the keycode with the name
   KEYNAME.  */
int
keyname_find (char *keyname)
{
  struct keyname *kn;
  int kn_int;

  /* XXX: 4 characters can be mapped into a int, it is safe to assume
     this will not be changed.  */
  if (strlen (keyname) > 4)
    {
      debug_printf ("The keyname `%s' consist of more than 4 characters;"
		    " 4 characters is the maximum.\n", keyname);
      /* XXX: Abort?  */
      return 0;
    } 
  kn_int = keyname_hash(keyname);

  kn = hurd_ihash_find (&kn_mapping, kn_int);
  if (kn)
    return kn->keycode;
/*   int h = name_hash (keyname); */
/*   struct keyname *kn; */
/*   for (kn = knhash[KNHASH(h)]; kn; kn = kn->hnext) */
/*     { */
/*       if (strcmp (kn->keyname, keyname)) */
/* 	continue; */
      
/*       return kn->keycode; */
/*     } */

  /* XXX: Is 0 an invalid keycode?  */
  return 0;
}


/* Keytypes and keytype maps.  */

/* The dummy gets used when the original may not be overwritten.  */
static struct keytype dummy_keytype;

#define	KTHSZ	16
#if	((KTHSZ&(KTHSZ-1)) == 0)
#define	KTHASH(ktttl)	((ktttl)&(KTHSZ-1))
#else
#define	KTHASH(ktttl)	(((unsigned)(kt))%KTHSZ)
#endif

/* All keytypes.  */
struct keytype *kthash[KTHSZ];

/* Initialize the keytypes hashtable.  */
static void
keytype_init ()
{
  int n;
  for (n = 0; n < KTHSZ; n++)
    kthash[n] = 0;
}

/* Search the keytype with the name NAME.  */
struct keytype *
keytype_find (char *name)
{
  int nhash = name_hash (name);
  struct keytype *kt;

  for (kt = kthash[KTHASH(nhash)]; kt; kt = kt->hnext)
    if (!strcmp (name, kt->name))
      return kt;
  return NULL;
}

/* Remove the keytype KT.  */
void
keytype_delete (struct keytype *kt)
{
  struct typemap *map;


  *kt->prevp = kt->hnext;
  if (kt->hnext)
    kt->hnext->prevp = kt->prevp;
      
  map = kt->maps;
  while (map)
    {
      struct typemap *nextmap = map->next;
      free (map);
      map = nextmap;
    }
  
}

/* Create a new keytype with the name NAME.  */
error_t
keytype_new (char *name, struct keytype **new_kt)
{
  struct keytype *kt;
  struct keytype *ktlist;
  int nhash;
  
  nhash = name_hash (name);
  debug_printf ("New: %s\n", name);

  kt = keytype_find (name);

  if (kt)
    {
      /* If the merge mode is augement don't replace it.  */
      if (merge_mode == augment)
	{
	  *new_kt = &dummy_keytype;
	  return 0;
	}
      else /* This keytype should replace the old one, remove the old one.  */
	keytype_delete (kt);
    }

  ktlist = kthash[KTHASH(nhash)];
  kt = calloc (1, sizeof (struct keytype));
  if (kt == NULL)
    return ENOMEM;

  kt->hnext = ktlist;
  kt->name = strdup (name);
  kt->prevp = &kthash[KTHASH(nhash)];
  kt->maps = NULL;
  if (kthash[KTHASH(nhash)])
    kthash[KTHASH(nhash)]->prevp = &(kt->hnext);
  kthash[KTHASH(nhash)] = kt;

  *new_kt = kt;
  return 0;
}

/* Add a level (LEVEL) to modifiers (MODS) mapping to the current
   keytype.  */
error_t
keytype_mapadd (struct keytype *kt, modmap_t mods, int level)
{
  struct typemap *map;
  modmap_t nulmap = {0, 0};

  map = malloc (sizeof (struct typemap));
  if (!map)
    return ENOMEM;

  map->level = level;
  map->mods = mods;
  map->preserve = nulmap;
  /* By default modifiers shouldn't be preserved.  */
  map->next = kt->maps;
  
  kt->maps = map;

  return 0;
}

/* For the current keytype the modifiers PRESERVE should be preserved
   when the modifiers MODS are pressed.  */
error_t
keytype_preserve_add (struct keytype *kt, modmap_t mods, modmap_t preserve)
{
  error_t err;
  struct typemap *map;

  map = kt->maps;
  while (map)
    {
      if (mods.rmods == map->mods.rmods && mods.vmods == map->mods.vmods)
	{
	  map->preserve = preserve;
	  return 0;
	}
      map = map->next;
    }

  /* No map has been found, add the default map.  */
  err = keytype_mapadd (kt, mods, 0);
  if (err)
    return err;

  keytype_preserve_add (kt, mods, preserve);

  return 0;
}


/* Interpretations.  */

struct xkb_interpret *last_interp;
struct xkb_interpret default_interpretation;


/* Add a new interpretation.  */
error_t
interpret_new (xkb_interpret_t **new_interpret, symbol ks)
{
  struct xkb_interpret *new_interp;

  new_interp = malloc (sizeof (struct xkb_interpret));
  if (!new_interp)
    return ENOMEM;

  memcpy (new_interp, &default_interpretation, sizeof (struct xkb_interpret));
  new_interp->symbol = ks;

  if (ks)
    {
      new_interp->next = interpretations;
      interpretations = new_interp;

      if (!last_interp)
	last_interp = new_interp;
    }
  else
    {
      if (last_interp)
	last_interp->next = new_interp;
      
      last_interp = new_interp;
      
      if (!interpretations)
	interpretations = new_interp; 
    }

  *new_interpret = new_interp;

  return 0;
}


/* XXX: Dead code!?  */
/* Virtual modifiers name to number mapping.  */
/* Last number assigned to a virtual modifier.  */
static int lastvmod = 0;

/* One virtual modifiername -> vmod number mapping.  */
struct vmodname
{
  char *name;
  struct vmodname *next;
};

/* A list of virtualmodifier names and its numberic representation.  */
static struct vmodname *vmodnamel;

/* Get the number assigned to the virtualmodifier with the name
   VMODNAME.  */
int
vmod_find (char *vmodname)
{
  int i = 0;
  struct vmodname *vmn = vmodnamel;

  while (vmn)
    {
      if (!strcmp (vmn->name, vmodname))
	return (lastvmod - i);
      vmn = vmn->next;
      i++;
    }

  return 0;
}

/* Give the virtualmodifier VMODNAME a number and add it to the
   hashtable.  */
error_t
vmod_add (char *vmodname)
{
  struct vmodname *vmn;

  if (vmod_find (vmodname))
    return 0;

  vmn = malloc (sizeof (struct vmodname));
  if (vmn == NULL)
    return ENOMEM;

  vmn->name = vmodname;
  vmn->next = vmodnamel;
  vmodnamel = vmn;

  lastvmod++;
  if (lastvmod > 16)
	  debug_printf("warning: only sixteen virtual modifiers are supported, %s will not be functional.\n", vmodname);

  return 0;
}


/* XXX: Use this, no pointers.  */
struct ksrm
{
  symbol ks;

  int rmods;
};
static struct hurd_ihash ksrm_mapping;

/* Initialize the list for keysyms to realmodifiers mappings.  */
void
ksrm_init ()
{
  hurd_ihash_init (&ksrm_mapping, HURD_IHASH_NO_LOCP);
  debug_printf ("KSRM MAP IHASH CREATED \n");
}

/* Add keysym to realmodifier mapping.  */
error_t
ksrm_add (symbol ks, int rmod)
{
  hurd_ihash_add (&ksrm_mapping, ks, (void *) rmod);

  return 0;
}

/* Apply the rkms (realmods to keysyms) table to all keysyms.  */
void
ksrm_apply (void)
{
  keycode_t kc;
  for (kc = 0; kc < max_keys; kc++)
    {
      int group;
      for (group = 0; group < 4; group++)
	{
	  int cursym;
	  for (cursym = 0; cursym < keys[kc].groups[group].width; cursym++)
	    {
	      symbol ks = keys[kc].groups[group].symbols[cursym];
	      int rmods = (int) hurd_ihash_find (&ksrm_mapping, ks);

		if (rmods)
		  {
		    keys[kc].mods.rmods = rmods;
		  }
	    }
	}
    }
}


/* void */
/* indicator_new (xkb_indicator_t **,  */


/* Keycode to realmodifier mapping.  */

/* Set the current rmod for the key with keyname KEYNAME.  */
/* XXX: It shouldn't be applied immediatly because the key can be
   replaced.  */
void
set_rmod_keycode (char *keyname, int rmod)
{
  keycode_t kc = keyname_find (keyname);
  keys[kc].mods.rmods = rmod;
  debug_printf ("%s (kc %d) rmod: %d\n", keyname, kc, rmod);
}

/* Initialize XKB data structures.  */
error_t
xkb_data_init (void)
{
  keyname_init ();
  keytype_init ();
  ksrm_init ();

  return 0;
}