SDL_eventmap.cpp

#include <SDL/SDL_endian.h>
#include "SDL_eventmap.h"
#include "SDL_eventmap_internal.h"
#include <map>
using namespace std;

#define SDL_EM map<Uint32, int>

void SDLH_Clear(SDL_EventMap *emap)
{
  SDL_EM *em=(SDL_EM *)emap;

  if(em==NULL) return;

  em->clear();
}

int SDLH_RemoveID(SDL_EventMap *emap, int id)
{
  SDL_EM *em=(SDL_EM *)emap;
  int removed=0;

  if((em==NULL)||(id<0))
    return(-1);

  SDL_EM::iterator i=em->begin();

  while(i!=em->end())
  {
    SDL_EM::iterator next=i;
    ++next;

    if((i->second)==(id+1))
    {
      em->erase(i);
      removed++;
    }
    i=next;
  }

  return(removed);
}

Uint32 SDLH_Learn(SDL_EventMap *emap, int id, Uint32 flag)
{
  int running=1;
  SDL_Event event;
  if((emap==NULL)||(id<0))
    return(0);

  while(running)
  {
    while(SDL_PollEvent(&event))
    {
      Uint32 hash=0;
      switch(event.type)
      {    
      case SDL_QUIT:
        return(0);

      default:
        hash=SDLH_HashEvent(&event,flag);
        break;
      }

      if(hash!=0)
      {
        if(SDLH_AddHashEvent(emap,hash,id)<0)
          return(0);
        else
          return(hash);
      }
    }

    SDL_Delay(10);
  }
  return(0);
}

SDL_EventMap *SDLH_Load(SDL_RWops *stream)
{
  SDL_EM *em=NULL;
  Uint32 maps=0;
  int n=0;

  if(stream==NULL)
    return(NULL);

  if(SDL_RWread(stream,&maps,sizeof(Uint32),1)<=0)
    return(NULL);

  maps=SDL_SwapLE32(maps);

  em=new SDL_EM;

  for(n=0; n<maps; n++)
  {
    Uint32 hash;
    int    id;

    if(SDL_RWread(stream,&hash,sizeof(Uint32),1)<=0)
    {
      delete em;
      return(NULL);
    }
    else if(SDL_RWread(stream,&id,sizeof(int),1)<=0)
    {
      delete em;
      return(NULL);
    }

    hash=SDL_SwapLE32(hash);
    id=SDL_SwapLE32(id);

    (*em)[hash]=id;
  }

  return((SDL_EventMap *)em);
}

int SDLH_Save(SDL_EventMap *emap, SDL_RWops *stream)
{
  SDL_EM *em=(SDL_EM *)emap;

  if((stream==NULL)||(stream==NULL))
    return(-1);
  else if(em->size()==0)
    return(-1);

  if(SDL_WriteLE32(stream,em->size())<0)
    return(-1);

  SDL_EM::iterator i=em->begin();
  while(i!=em->end())
  {
    if(SDL_WriteLE32(stream,i->first)<0)
      return(-1);
    if(SDL_WriteLE32(stream,i->second)<0)
      return(-1);

    i++;
  }

  return(0);
}

int SDLH_RemoveEvent(SDL_EventMap *eventmap, Uint32 hash)
{
  SDL_EM *em=(SDL_EM *)eventmap;

  if((em==NULL)||(hash==0))
    return(-1);

  SDL_EM::iterator i=em->begin();

  while(i!=em->end())
  {
    if(i->first==hash)
    {
      em->erase(i);
      return(0);
    }

    i++;
  }

  return(-1);
}

int SDLH_AddEvent(SDL_EventMap *eventmap, SDL_Event *event, int id, Uint32 flag)
{
  Uint32 hash=SDLH_HashEvent(event,flag);

  return(SDLH_AddHashEvent(eventmap,hash,id));
}


int SDLH_AddHashEvent(SDL_EventMap *eventmap, Uint32 hash, int id)
{
  SDL_EM *em=(SDL_EM *)eventmap;

  if((eventmap==NULL)||(id<0)||(hash==0))
    return(-1);

  (*em)[hash]=(id+1);

  return(0);
}

int SDLH_TranslateEvent(SDL_EventMap *emap, SDL_Event *event, Uint32 flag)
{
  int hash;
  SDL_EM *em=(SDL_EM *)emap;

  if((emap==NULL)||(event==NULL))
    return(-1);

  hash=SDLH_HashEvent(event,flag);
  if(hash==0)
    return(-1);

  if(!(*em)[hash])
    return(-1);
  else
  {
    SDL_Event uevent;
    uevent.type=SDL_USEREVENT;
    uevent.user.code=(*em)[hash]-1;
    uevent.user.data1=(void *)(long int)hash;
    uevent.user.data2=NULL;
    SDL_PushEvent(&uevent);
    return(0);
  }
}

SDL_EventMap *SDLH_Create()
{
  return((SDL_EventMap *)(new SDL_EM));
}

void SDLH_Free(SDL_EventMap *eventmap)
{
  if(eventmap!=NULL)
  {
    delete ((SDL_EM *)eventmap);
  }
}

---