Subversion Repositories freemyipod

//
//
//    Copyright 2011 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 "emcorelib.h"
#include "libui.h"
#include "chooser.h"
#include "chooser_action_handler_wheel.h"


static int chooser_action_handler_wheel_init(struct chooser_data* data)
{
    const struct chooser_action_handler_wheel_params* params;
    params = (const struct chooser_action_handler_wheel_params*)(data->info->actionhandlerparams);
    if (params->version != CHOOSER_ACTION_HANDLER_WHEEL_PARAMS_VERSION) return -1;
    data->actionhandlerdata = malloc(sizeof(struct chooser_action_handler_wheel_data));
    if (!data->actionhandlerdata) return -2;
    struct chooser_action_handler_wheel_data* adata;
    adata = (struct chooser_action_handler_wheel_data*)(data->actionhandlerdata);
    adata->timeout_remaining = params->timeout_initial;
    adata->lasttick = USEC_TIMER;
    return 0;
}

static enum chooser_result chooser_action_handler_wheel_handleevent(struct chooser_data* data,
                                                                    enum button_event event,
                                                                    int which, int value)
{
    const struct chooser_action_handler_wheel_params* params;
    params = (const struct chooser_action_handler_wheel_params*)(data->info->actionhandlerparams);
    struct chooser_action_handler_wheel_data* adata;
    adata = (struct chooser_action_handler_wheel_data*)(data->actionhandlerdata);
    if (params->eventfilter && params->eventfilter(data, event, which, value))
        return CHOOSER_RESULT_OK;
    adata->timeout_remaining = params->timeout_idle;
    int spi = params->stepsperitem;
    switch (event)
    {
        case BUTTON_PRESS:
            if (which < params->buttoncount)
                switch (params->buttonmap[which])
                {
                    case CHOOSER_ACTION_HANDLER_WHEEL_ACTION_PREV:
                        mutex_lock(&data->statemutex, TIMEOUT_BLOCK);
                        data->position = MIN(data->info->itemcount * spi,
                                             MAX(spi, data->position & ~(spi - 1))) - spi / 2;
                        data->selected = &data->info->items[data->position / spi];
                        mutex_unlock(&data->statemutex);
                        return CHOOSER_RESULT_REDRAW;
                    case CHOOSER_ACTION_HANDLER_WHEEL_ACTION_NEXT:
                        mutex_lock(&data->statemutex, TIMEOUT_BLOCK);
                        data->position = MIN(data->info->itemcount * spi,
                                             MAX(spi, (data->position & ~(spi - 1)) + 2 * spi))
                                                    - spi / 2;
                        data->selected = &data->info->items[data->position / spi];
                        mutex_unlock(&data->statemutex);
                        return CHOOSER_RESULT_REDRAW;
                    case CHOOSER_ACTION_HANDLER_WHEEL_ACTION_SELECT:
                        return CHOOSER_RESULT_FINISHED;
                    case CHOOSER_ACTION_HANDLER_WHEEL_ACTION_CANCEL:
                        return CHOOSER_RESULT_CANCEL;
                }
        case WHEEL_MOVED_ACCEL:
            mutex_lock(&data->statemutex, TIMEOUT_BLOCK);
            data->position = MIN(data->info->itemcount * spi - 1, MAX(0, data->position + value));
            data->selected = &data->info->items[data->position / spi];
            mutex_unlock(&data->statemutex);
            return CHOOSER_RESULT_REDRAW;
    }
    return CHOOSER_RESULT_OK;
}

static enum chooser_result chooser_action_handler_wheel_handletick(struct chooser_data* data)
{
    const struct chooser_action_handler_wheel_params* params;
    params = (const struct chooser_action_handler_wheel_params*)(data->info->actionhandlerparams);
    struct chooser_action_handler_wheel_data* adata;
    adata = (struct chooser_action_handler_wheel_data*)(data->actionhandlerdata);
    if (adata->timeout_remaining == TIMEOUT_BLOCK) return CHOOSER_RESULT_OK;
    long time = USEC_TIMER;
    adata->timeout_remaining -= time - adata->lasttick;
    adata->lasttick = time;
    if (adata->timeout_remaining < 0)
    {
        if (params->timeout_item == CHOOSER_ACTION_HANDLER_WHEEL_TIMEOUT_ITEM_NULL)
            return CHOOSER_RESULT_CANCEL;
        else if (params->timeout_item != CHOOSER_ACTION_HANDLER_WHEEL_TIMEOUT_ITEM_KEEP)
            data->selected = &data->info->items[params->timeout_item];
        return CHOOSER_RESULT_FINISHED;
    }
    if (params->tick_force_redraw) return CHOOSER_RESULT_REDRAW;
    return CHOOSER_RESULT_OK;
}

static int chooser_action_handler_wheel_stepsperitem(struct chooser_data* data)
{
    const struct chooser_action_handler_wheel_params* params;
    params = (const struct chooser_action_handler_wheel_params*)(data->info->actionhandlerparams);
    return params->stepsperitem;
}

static void chooser_action_handler_wheel_destroy(struct chooser_data* data)
{
    free(data->actionhandlerdata);
}


const struct chooser_action_handler chooser_action_handler_wheel =
{
    .version = CHOOSER_ACTION_HANDLER_VERSION,
    .init = chooser_action_handler_wheel_init,
    .handleevent = chooser_action_handler_wheel_handleevent,
    .handletick = chooser_action_handler_wheel_handletick,
    .stepsperitem = chooser_action_handler_wheel_stepsperitem,
    .destroy = chooser_action_handler_wheel_destroy
};