Info
Get involved
Documentation

src/SAL_eventhandler.cpp

/*
    SAL - Simple Application Library
    Copyright (C) 2006-2006 Kronon

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Kronon
    kronon88@users.sourceforge.net
*/

//SAL event handling
//Created by Kronon

//Doxy gen information

#include "SAL_eventhandler.h"

//Local variables
SDL_Thread *keyboard_thread = NULL;
bool keyboard_active;

struct SAL_reg_key                                                      //A key that is registered to the event listener
{
        Uint16 unicode;                                                 
        SAL_gui_object * object;                                
};

salList<SAL_reg_key> registered_keys;

struct SAL_keyboard_item
{
        SDLKey key;                                                             
        SDLMod mod;                                                             
        Uint32 life;                                                    
        SAL_gui_object * selected;                              
};

salList<SAL_keyboard_item> pend_keys;
SDL_mutex *keyboard_mutex;                                      //Protects pend_keys list

struct SAL_keyboard_items
{
        int delay;                                                              
};
SAL_keyboard_items keyboard;

struct SAL_mouse_items
{
        SDL_Thread *thread;                                             
        bool active;                                                    
        char clicks;                                                    
        SAL_gui_object * selected;                              
        Uint16  x;                                                              
        Uint16 y;                                                               
        char button;                                                    
        int delay;                                                              
};
SAL_mouse_items mouse;

//In: Point to pend_key in array, Uint16 unicode char
//Out: Bool (match/no match)
//Action: Look if unicode char of keyboard_item and wanted unicode char match
bool remove_key(SAL_keyboard_item item, SAL_keyboard_item target)
{
        return (item.key == target.key);
}

//In: default mouse delay time, default keyboard delay time
//Out: Error_code
//Action: Start event listener thread
int SAL_start_event_listener(int & mouse_delay, int & keyboard_delay)
{
        //Delay times
        mouse.delay = mouse_delay;
        keyboard.delay = keyboard_delay;
        
        //Load the event listener
        SAL_struct.internal.event.thread = SDL_CreateThread(SAL_event_listener, NULL);
        if(SAL_struct.internal.event.thread == NULL)
        {
#ifdef SAL_DEBUG_ON
                salError("Error: Event handler thread couldn't start");
#endif
                return -1;
        }
        return 0;
}

//In: Nothing realy
//Out: Error_code
//Action: Listen to the sdl events, convert them to a more useable standard, call defined action handlers
int SAL_event_listener(void * unused)
{
        //Set some vars
        mouse.thread = NULL;
        mouse.active = false;
        keyboard_mutex = SDL_CreateMutex();
        keyboard_active = false;

#ifdef SAL_DEBUG_ON
        sleep(1);       //Debuger crashes in some case because it can't find the thread after termination
#endif
    
        SDL_Event event;
    //We want to know new events as long as we don't quit
    while(SAL_struct.internal.checks.alive)
    {
        //Check the next event
        SDL_WaitEvent(&event);
        switch (event.type) 
        {
                case SDL_MOUSEBUTTONDOWN:
                {
                                mouse.clicks++;
                }
                break;
                case SDL_MOUSEBUTTONUP:
                {
                        if(mouse.active)
                                mouse.clicks++; //Total clicks is mouse_clicks / 2
                                else
                                {
                                        mouse.clicks = 2;
                                                
                                        mouse.selected = NULL;
                                        SAL_search_object(event.button.x, event.button.y, mouse.selected);
                                                
                                        //We need to register amount of clicks
                                        mouse.x = event.button.x;
                                        mouse.y = event.button.y;
                                        mouse.button = event.button.button;
                                        
                                        mouse.active = true;
                                        SDL_WaitThread(mouse.thread, NULL);                                     //Free's memory and solves a bug
                                        mouse.thread = SDL_CreateThread(SAL_mouse_listener, NULL);
        
                                        if(mouse.thread == NULL)
                                        {
#ifdef SAL_DEBUG_ON
                                                        salError("Error: Mouse listener thread couldn't start");
#endif
                                                        return -1;
                                        }
                                        
                                        if(mouse.selected)
                                        {
                                                //Select object
                                                mouse.selected->func->pressed(mouse.selected);
                                        }
                        }
                }
                break;
                case SDL_KEYDOWN:
                {
                        //Add key to key list
                                SDL_mutexP(keyboard_mutex);
                                SAL_gui_object * selected = NULL;
#ifdef SAL_DEBUG_ON
                        printf("Key down = %i\n",event.key.keysym.sym);
#endif
                        SAL_search_object(event.key.keysym.unicode, selected);
                        SAL_keyboard_item key = {event.key.keysym.sym,event.key.keysym.mod, SDL_GetTicks() + keyboard.delay, selected};
                        
                        pend_keys.append(key);
                        
                                //Process event
                                if(SAL_struct.internal.event.active_object == NULL)
                                {
                                        if(SAL_struct.internal.event.action_handler.keyboard != NULL)
                                                SAL_struct.internal.event.action_handler.keyboard(key.key, key.mod);
                                }
                                else
                                        SAL_struct.internal.event.active_object->func->key_down(SAL_struct.internal.event.active_object,key.key, key.mod);
                                        
                                        if(!keyboard_active)
                                        {
                                                keyboard_active = true;
                                                SDL_WaitThread(keyboard_thread, NULL);                                  //Free's memory and solves a bug
                                                keyboard_thread = SDL_CreateThread(SAL_keyboard_listener, NULL);
                                        
                                                if(keyboard_thread == NULL)
                                                {
        #ifdef SAL_DEBUG_ON
                                                        salError("Error: Keyboard listener thread couldn't start");
        #endif
                                                        return -1;
                                                }
                                        }
                                SDL_mutexV(keyboard_mutex);
                        }
                break;
                case SDL_KEYUP:
                {
                        //Remove key from polled keys
#ifdef SAL_DEBUG_ON
                        printf("Key up   = %i\n",event.key.keysym.sym);
#endif
                        SDL_mutexP(keyboard_mutex);
                        pend_keys.funcRemove(remove_key,(SAL_keyboard_item){(SDLKey)event.key.keysym.sym,(SDLMod)NULL,0,NULL},-1);
                        SDL_mutexV(keyboard_mutex);
                }
                break;
                        case SDL_QUIT:
                        {
                                //SDL got an signal to quit, so lets exit the program the nice way
                                salStop();
                                break;
                        }
                }
    }
    SDL_mutexP(keyboard_mutex);                 //Protect pend_keys list
    pend_keys.clear();
    SDL_mutexV(keyboard_mutex);
    
    SDL_WaitThread(keyboard_thread, NULL);
    SDL_DestroyMutex(keyboard_mutex);
    return 0;
}

//In: None
//Out: Error_code
//Action: After some time this get the ammount of clicks and executes the user defined mouse handler
int SAL_mouse_listener(void * unused)
{
        //Wait
        SDL_Delay(mouse.delay);
        
        if(mouse.selected)
        {
                mouse.selected->func->released(mouse.selected);
                if(SAL_struct.internal.event.action_handler.action != NULL)
                        SAL_struct.internal.event.action_handler.action(mouse.selected->id);
        }
        else if(SAL_struct.internal.event.action_handler.mouse != NULL)
                SAL_struct.internal.event.action_handler.mouse(mouse.x, mouse.y, mouse.button, mouse.clicks);
        
        mouse.active = false;   //Safe?
        return 0;
}

//In: None
//Out: Error_code
//Action: Ass long as any button is pressed this thread generates "button presses(better name?)"
int SAL_keyboard_listener(void * unused)
{
        //pend_keys.setLoopBegin(); //Get the beginning of the array with pause times of keys with there corresponding key code
        SDL_mutexP(keyboard_mutex);                     //Protect pend_keys list
        while(!pend_keys.isEmpty()) //Only loop while there are keys
        {
                //Save all active keys to array
                //Check if all keys are still active in that array
                SDL_mutexV(keyboard_mutex);                     //Free acces to pend_keys
                SDL_Delay(keyboard.delay);                      //Key poll time
                SDL_mutexP(keyboard_mutex);                     //Protect pend_keys list
                
                for(pend_keys.setLoopBegin(); pend_keys.inLoop(); )
                {

//                              if(SAL_search_object(pend_keys.getLoopEntry(), object) != -1)
//                                      SAL_struct.internal.event.action_handler.action(object->id);
//                              else
                        if(pend_keys.getLoopEntry().life < SDL_GetTicks())                              //Key needs to be stroken for at least some time
                        {
                                if(SAL_struct.internal.event.active_object == NULL)
                                {
                                        if(SAL_struct.internal.event.action_handler.keyboard != NULL)
                                                SAL_struct.internal.event.action_handler.keyboard(pend_keys.getLoopEntry().key, pend_keys.getLoopEntry().mod);
                                }
                                else
                                                SAL_struct.internal.event.active_object->func->key_down(SAL_struct.internal.event.active_object,pend_keys.getLoopEntry().key, pend_keys.getLoopEntry().mod);
                        }
                }
        }
        keyboard_active = false;
        SDL_mutexV(keyboard_mutex);                             //Free acces ti pend_keys
        return 0;
}

//In: x coordinate, y coordinate, type of click, object id that is to be returned by this function
//Out: Error_code
//Action: Search corresponding block with x,y. Look if an object is located at the given coordinates and return it
inline int SAL_search_object(int x, int y, SAL_gui_object *& target)
{
        //Calcultate the ractangle the mouse is in and start searching from that rectangle
        //The window is devided in 5x5 rectangles
        //TODO: when the window resizes we need to change the contents of the blocks according to the new situation
        int blockX, blockY;
        blockX = x / (SAL_struct.internal.render.display->w / 5);
        blockY = y / (SAL_struct.internal.render.display->h / 5);
        
        //Open the block and search for objects
        for(SAL_struct.internal.event.select_matrix[blockX][blockY].setLoopBegin(); SAL_struct.internal.event.select_matrix[blockX][blockY].inLoop(); )
        {       
                //Check left border
                //Check Top border
                //Check Right border
                //Check bottom border
                if(SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->x <= x && 
                        SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->y <= y &&
                        (SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->surface->w +
                        SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->x) >= x &&
                        (SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->surface->h +
                        SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry()->y) >= y)
                {
                        target = SAL_struct.internal.event.select_matrix[blockX][blockY].getLoopEntry();        //Set object id
                        return 1;               //Found an object
                }
        }
        
        return 0;                               //Found no object
}

//In: Keyboard character, object that is to be returned
//Out: Error_code
//  0:  Normal
// -1:  No object registered with that code
//Action: Search object that is connected to the given char
int SAL_search_object(Uint16 unicode, SAL_gui_object *& target)
{
    //Search for an object with unicode as fast key and return that object
    for(registered_keys.setLoopBegin(); registered_keys.inLoop(); )
    {
        if(registered_keys.getLoopEntry().unicode == unicode)
        {
                target = registered_keys.getLoopEntry().object;
                return 0;       
        }
    }
        return -1;
} 

//In: pointer to user defined action handler
//Out: Error_code
//  0:  Normal
//Action: Connect user defined action handler to SAL library
int salSetActionHandler(int (*action)(int action_id))
{
        SAL_struct.internal.event.action_handler.action = action;
        return 0;
}


//In: pointer to user defined mouse handler
//Out: Error_code
//  0:  Normal
//Action: Connect user defined mouse handler to SAL library
int salSetMouseHandler(int (*mouse)(int x, int y, char button, char clicks))
{
        SAL_struct.internal.event.action_handler.mouse = mouse;
        return 0;
}

//In: pointer to user defined keyboard handler
//Out: Error_code
//  0:  Normal
//Action: Connect user defined keyboard handler to SAL library
int salSetKeyboardHandler(int (*keyboard)(SDLKey key, SDLMod mod))
{
        SAL_struct.internal.event.action_handler.keyboard = keyboard;
    return 0;
}