sources/events.c

Go to the documentation of this file.

/*
** Copyright 2009-2011, helixis.org
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without modification, are permitted provided
** that the following conditions are met:
**
** Redistributions of source code must retain the above copyright notice, this list of conditions and the
** following disclaimer.
**
** Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
** the following disclaimer in the documentation and/or other materials provided with the distribution.
**
** Neither the name of the helixis.org nor the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
** PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
** TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
** POSSIBILITY OF SUCH DAMAGE.
*/

/*
** INCLUDES
*/

#include "hlx/core.h"
#include "helixis_internal.h"

#ifdef __cplusplus
extern "C"      {
#endif

/*
** EXTERNALS
*/

extern hlx_api gl_api;

/*
** GLOBALS
*/

static hlx_event_manager*       gl_event_manager = 0;

/*
** FUNCTIONS
*/

void _hlx_event_delete_callback(void *data, void *state)
{
        _hlx_event_callback*    callback;

        (void)state;
        callback = (_hlx_event_callback*)data;
        gl_api.free_entry(callback);
}

void _hlx_event_default_manager_destroy(void)
{
        if (gl_event_manager != 0)
                gl_api.free_entry(gl_event_manager);
        gl_event_manager = 0;
}

hlx_event_manager*              hlx_event_get_default_manager()
{
        if (gl_event_manager == 0)
                gl_event_manager = hlx_event_manager_create();
        return (gl_event_manager);
}

hlx_event_errors                hlx_event_handler_create(hlx_event_manager* public_manager, unsigned long id, unsigned int size)
{
        return (_hlx_event_handler_create_by_hash((_hlx_event_manager*)public_manager, id, size));
}

hlx_event_errors                hlx_event_handler_destroy(hlx_event_manager* public_manager, unsigned long id)
{
        _hlx_event_handler*     handler;

        if ((handler = _hlx_event_return_handler((_hlx_event_manager*)public_manager, id)) == 0)
                return (EV_ERROR_UNDEFINED);
        _hlx_event_handler_destroy(handler);
        return (EV_ERROR_SUCCESS);
}

hlx_event_errors                        hlx_event_register_callback_func_with_group(hlx_event_manager* public_manager, unsigned long id, hlx_event_user_callback user_callback, void* user_data, hlx_group_id group_id)
{
        _hlx_event_manager*             manager;
        _hlx_event_handler*             handler;
        _hlx_event_callback*    callback;

        manager = (_hlx_event_manager*)public_manager;
        if ((handler = _hlx_event_return_handler(manager, id)) == 0)
                return (EV_ERROR_UNDEFINED);
        if ((callback = gl_api.malloc_entry(sizeof(*callback))) == 0)
                return (EV_ERROR_MEMORY_EXHAUSTED);
        callback->func = user_callback;
        callback->params.callback = 0;
        callback->params.user_data = user_data;
        callback->task = 0;
        return (_hlx_event_register_callback_with_group(manager, handler, id, callback, group_id));
}

hlx_event_errors                        hlx_event_register_callback_func(hlx_event_manager* public_manager, unsigned long id, hlx_event_user_callback user_callback, void* user_data)
{
        return hlx_event_register_callback_func_with_group(public_manager, id, user_callback, user_data, 0);
}

hlx_event_errors                        _hlx_event_register_callback_task_with_callback_and_group(hlx_event_manager* public_manager, unsigned long id, hlx_task_func user_callback, void* user_data, hlx_task_callback task_callback, hlx_group_id group_id)
{
        _hlx_event_manager*             manager;
        _hlx_event_handler*             handler;
        _hlx_event_callback*    callback;

        manager = (_hlx_event_manager*)public_manager;
        if ((handler = _hlx_event_return_handler(manager, id)) == 0)
                return (EV_ERROR_UNDEFINED);
        if ((callback = gl_api.malloc_entry(sizeof(*callback))) == 0)
                return (EV_ERROR_MEMORY_EXHAUSTED);
        callback->task = user_callback;
        callback->params.callback = task_callback;
        callback->params.user_data = user_data;
        callback->func = 0;
        return (_hlx_event_register_callback_with_group(manager, handler, id, callback, group_id));
}

hlx_event_errors                        _hlx_event_register_callback_task_with_callback(hlx_event_manager* public_manager, unsigned long id, hlx_task_func task, void* user_data, hlx_task_callback task_callback)
{
        return _hlx_event_register_callback_task_with_callback_and_group(public_manager, id, task, user_data, task_callback, 0);
}

hlx_event_errors                        hlx_event_register_callback_task_with_group(hlx_event_manager* public_manager, unsigned long id, hlx_task_func user_callback, void* user_data, hlx_group_id group_id)
{
        return _hlx_event_register_callback_task_with_callback_and_group(public_manager, id, user_callback, user_data, 0, group_id);
}

hlx_event_errors                        hlx_event_register_callback_task(hlx_event_manager* public_manager, unsigned long id, hlx_task_func user_callback, void* user_data)
{
        return _hlx_event_register_callback_task_with_callback_and_group(public_manager, id, user_callback, user_data, 0, 0);
}

_hlx_event_handler*                     _hlx_event_return_handler(_hlx_event_manager* manager, unsigned long id)
{
        return (_hlx_event_return_handler_by_hash(manager, id));
}

void                                            _hlx_event_task_callback(void* param, hlx_group_id group_id, int status)
{
        hlx_event_args* args;

        args = (hlx_event_args*)param;
        if (args->callback)
                args->callback(param, group_id, status);
        if (args->event_data)
                gl_api.free_entry(args->event_data);
        gl_api.free_entry(args);
}

#ifdef __cplusplus
}
#endif

/*
** END OF FILE
*/