Subversion Repositories freemyipod

//

//

//    Copyright 2010 TheSeven

//

//

//    This file is part of emCORE.

//

//    emCORE 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.

//

//    emCORE 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.

//

//    You should have received a copy of the GNU General Public License along

//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.

//

//

#include "global.h"

#include "button.h"

#include "thread.h"

static struct button_hook_entry* head_button_hook IBSS_ATTR;

static struct mutex button_mutex;

void button_init()

{

    head_button_hook = NULL;

    mutex_init(&button_mutex);

}

struct button_hook_entry* button_register_handler(void (*handler)(void*, enum button_event,

                                                                  int, int),

                                                  void* user)

{

    struct button_hook_entry* hook;

    hook = (struct button_hook_entry*)malloc(sizeof(struct button_hook_entry));

    if (!hook) return NULL;

    hook->owner = current_thread;

    hook->handler = handler;

    hook->user = user;

    mutex_lock(&button_mutex, TIMEOUT_BLOCK);

    hook->next = head_button_hook;

    head_button_hook = hook;

    mutex_unlock(&button_mutex);

    return hook;

}

int button_unregister_handler(struct button_hook_entry* hook)

{

    struct button_hook_entry* h;

    int result = -1;

    mutex_lock(&button_mutex, TIMEOUT_BLOCK);

    if (head_button_hook == hook)

    {

        head_button_hook = head_button_hook->next;

        free(hook);

        result = 0;

    }

    else

    {

        for (h = head_button_hook; h && h->next; h = h->next);

            if (h->next == hook)

            {

                h->next = h->next->next;

                free(hook);

                result = 0;

            }

    }

    mutex_unlock(&button_mutex);

    return result;

}

void button_send_event(enum button_event eventtype, int which, int value)

{

    DEBUGF("Sending button event: %d, %02X, %02X", eventtype, which, value);

    struct button_hook_entry* h;

    mutex_lock(&button_mutex, TIMEOUT_BLOCK);

    for (h = head_button_hook; h; h = h->next)

        h->handler(h->user, eventtype, which, value);

    mutex_unlock(&button_mutex);

}

void button_unregister_all_of_thread(struct scheduler_thread* process)

{

    struct button_hook_entry* h;

    struct button_hook_entry* prev;

    mutex_lock(&button_mutex, TIMEOUT_BLOCK);

    while (head_button_hook && head_button_hook->owner == process)

    {

        prev = head_button_hook;

        head_button_hook = head_button_hook->next;

        free(prev);

    }

    for (h = head_button_hook; h; h = h->next)

        while (h->next && h->next->owner == process)

        {

            prev = h->next;

            h->next = h->next->next;

            free(prev);

        }

    mutex_unlock(&button_mutex);

}