eventhandler.hcc

Go to the documentation of this file.

/******** System Includes *************/
#include <stdlib.hch>

#include "pal_master.hch"

/******** Application Includes ********/
#include "configuration.hch"
#include "audio.hch"
#include "mouse_shared.hch"
#include "eventhandler_shared.hch"
#include "eventhandler.hch"
#include "events.hch"
#include "display_shared.hch"
#include "display.hch"

#if HAVE_DEBUG
        #include "debug.hch"
#endif



/*
 */
extern chan unsigned 1 maskupdate_notification;



void eventhandler_main(audiodata_t *audiodata, events_t *events, mousedata_t *mousedata) {
        mpram {
                ram unsigned 4 write[768];      
                rom unsigned 4 read[768];       
        } equalizer_levels with { block = "BlockRAM"};

        unsigned 10 preset_offset;
        unsigned 10 reference_point, reference_point_right;
        unsigned 5 volume_left;
        unsigned 4 index_offset, index_end;
        unsigned 4 equalizer_mode_local;
        unsigned 1 newmaskupdate;

        load_preset(LOAD_PRESET_RESET, equalizer_levels.write);
        reload_equalizer(events, &equalizer_levels.write[preset_offset]);

        while (TRUE) {
                maskupdate_notification ? newmaskupdate;

                /*
                 * First we determine what mousestate we currently have. Then
                 * we check where we are to decide what to do.
                 */
                switch (mousedata->state) {
                        case MOUSE_STATE_ON_PRESS:
                                /*
                                 * If we are displaying the graphic visual,
                                 * any press returns to the application.
                                 */
                                if (MODE_GRAPH == events->mode) {
                                        events->mode = MODE_SKIN;
                                        events->mask = 0;
                                } else {
                                        delay;
                                }

                                /*
                                 */
                                if (BUTTON_MODE == events->mask) {
                                        if (MODE_GRAPH == events->mode) {
                                                events->mode = MODE_SKIN;
                                        } else {
                                                events->mode = MODE_GRAPH;
                                        }
                                } else {
                                        delay;
                                }

                                /*
                                 * If the current mask equals the help button
                                 * we set display mode to help.
                                 */
                                if (BUTTON_HELP == events->mask) {
                                        /*
                                         * Change the mode to help if it's
                                         * currently not set, otherwise go back
                                         * to skin mode.
                                         */
                                        if (MODE_HELP == events->mode) {
                                                events->mode = MODE_SKIN;
                                        } else {
                                                events->mode = MODE_HELP;
                                        }
                                } else {
                                        delay;
                                }

                                /*
                                 * The Preset buttons span from 1 to 6 so if
                                 * the mask one of those, we'll change the
                                 * pointer to point to the current preset.
                                 */
                                if ((BUTTON_PRESET_1 <= events->mask) && (events->mask <= BUTTON_PRESET_6)) {
                                        /*
                                         * The active preset is determined by
                                         * the mask minus an offset. Hence
                                         * ranging our active preset from 0 to
                                         * 6.
                                         */
                                        events->active_preset = 0 @ (events->mask -BUTTON_PRESET_1);
                                        /*
                                         * Each equalizer is 128 bands wide,
                                         * thus we need to add 128 * the preset
                                         * for each different preset. This
                                         * offset is calculated here.
                                         */
                                        preset_offset = events->active_preset << 7;
                                        /*
                                         * We set the pointer to the active
                                         * part of the array by using the
                                         * preset offset as our index. Hence
                                         * depending on the selected preset
                                         * we point to 0, 128, 256, 384, 512
                                         * or 640.
                                         */
                                        audiodata->equalizer_levels_ptr = &equalizer_levels.read[preset_offset];
                                        /*
                                         * Finally update the equalizer bars
                                         * that are drawn by the display.
                                         */
                                        reload_equalizer(events, &equalizer_levels.write[preset_offset]);
                                } else {
                                        delay;
                                }

                                if ((BUTTON_PRECISE <= events->mask) && (events->mask <= BUTTON_CONVEX_FULL)) {
                                        events->equalizer_mode = (events->mask -BUTTON_PRECISE) <-4;
                                } else {
                                        delay;
                                }

                                /*
                                 * If the demo button was pressed load the
                                 * demo preset values into the presets.
                                 */
                                if (BUTTON_DEMO == events->mask) {
                                        load_preset(LOAD_PRESET_DEMO, equalizer_levels.write);
                                        reload_equalizer(events, &equalizer_levels.write[preset_offset]);
                                }

                                /*
                                 * If the reset button was pressed load the
                                 * reset values into the presets.
                                 */
                                if (BUTTON_RESET == events->mask) {
                                        load_preset(LOAD_PRESET_RESET, equalizer_levels.write);
                                        reload_equalizer(events, &equalizer_levels.write[preset_offset]);
                                }

                                /*
                                 * If the current mask equals the log button,
                                 * we flip the display_log bit.
                                 */
                                if (BUTTON_LOG == events->mask) {
                                        audiodata->display_log = !audiodata->display_log;
                                } else {
                                        delay;
                                }

                                break;

                        case MOUSE_STATE_DOWN:
                                /*
                                 * If we are in the volume area we update the
                                 * volume level for both channels.
                                 */
                                if (AREA_VOLUME_YAXIS == events->mask) {
                                        /*
                                         * Copy the current Y cursor position
                                         * to the events struct. This we then
                                         * later use for drawing purposes.
                                         */
                                        events->volume_position = 0 @ mousedata->y;
                                        /*
                                         * Look the relative y-coordinate up in
                                         * the volumecontrol lookup table. We
                                         * make a local copy here because the
                                         * RC200 call doesn't behave nicely
                                         * when passing anything else.
                                         */
                                        volume_left = volumecontrol_table[((mousedata->y) -65) <- 6];
                                        /*
                                         * We feel that volume gets softer the
                                         * closer it gets to the 0, and louder
                                         * as it approaches 0x1f. The SetVolume
                                         * RC200 call does this in an unnatural
                                         * reverse way. Therefor we fix it.
                                         */
                                        RC200AudioOutSetVolume(!volume_left, 0x1f -volume_left, 0x1f -volume_left);
                                } else {
                                        delay;
                                }

                                if ((AREA_EQUALIZER_MIN <= events->mask) && (events->mask <= AREA_EQUALIZER_MAX)) {

                                        if (EQUALIZERMODE_PRECISE == events->equalizer_mode) {
                                                events->locked_display = TRUE;
                                                equalizer_levels.write[preset_offset +(0 @ events->mask) -AREA_EQUALIZER_MIN] = equalizer_table[mousedata->y -382];
                                                events->equalizer_display[(events->mask -AREA_EQUALIZER_MIN) <- 7] = mousedata->y;
                                                events->locked_display = FALSE;
                                        } else {
                                                
                                                equalizer_mode_local = events->equalizer_mode +1;

                                                events->locked_display = TRUE;
                                                index_offset = ((equalizer_mode_local << 1)); /* delay; */

                                                if (events->mask < (AREA_EQUALIZER_MIN +(0 @ equalizer_mode_local))) {
                                                        reference_point = events->equalizer_display[AREA_EQUALIZER_MIN -AREA_EQUALIZER_MIN];
                                                        index_offset -= (((0 @ equalizer_mode_local) -(events->mask -AREA_EQUALIZER_MIN)) <- 4);
                                                } else {
                                                        reference_point = events->equalizer_display[(events->mask - (0 @ equalizer_mode_local) -AREA_EQUALIZER_MIN) <- 7];
                                                        index_offset -= 1;
                                                }

                                                if (events->mask > (AREA_EQUALIZER_MAX -(0 @ equalizer_mode_local))) {
                                                        reference_point_right = events->equalizer_display[AREA_EQUALIZER_MAX -AREA_EQUALIZER_MIN];
                                                        index_end = (((0 @ equalizer_mode_local) -(AREA_EQUALIZER_MAX -events->mask)) <- 4) -1;
                                                } else {
                                                        reference_point_right = events->equalizer_display[(events->mask + (0 @ equalizer_mode_local) -AREA_EQUALIZER_MIN) <- 7];
                                                        index_end = 0;
                                                }
                                                events->locked_display = FALSE;

                                                for (; index_offset != index_end; index_offset--) {
                                                        unsigned 10 average_bar;
                                                        unsigned 7 equalizer_index;
                                                        unsigned 4 bar_index;
                                                        
                                                        if (index_offset == equalizer_mode_local) {
                                                                reference_point = reference_point_right;
                                                        } else {
                                                                delay;
                                                        }

                                                        if (index_offset > equalizer_mode_local) 
                                                        {
                                                                bar_index = (index_offset -equalizer_mode_local);                       
                                                                equalizer_index = ((events->mask -(0 @ bar_index) -AREA_EQUALIZER_MIN) <- 7);
                                                        } else 
                                                        {
                                                                bar_index = (equalizer_mode_local -index_offset);
                                                                equalizer_index = ((events->mask +(0 @ bar_index) -AREA_EQUALIZER_MIN) <- 7);   
                                                        }

                                                        if (reference_point > mousedata->y) {
                                                                average_bar = mousedata->y +((reference_point -mousedata->y) >> (equalizer_mode_local -bar_index));
                                                        } else {
                                                                average_bar = mousedata->y -((mousedata->y -reference_point) >> (equalizer_mode_local -bar_index));
                                                        }
                                                                                                        
                                                        events->locked_display = TRUE;
                                                        equalizer_levels.write[preset_offset +(0 @ equalizer_index)] = equalizer_table[average_bar -382];
                                                        events->equalizer_display[equalizer_index] = average_bar;
                                                        events->locked_display = FALSE;                                         
                                                }
                                        }
                                } else {
                                        delay;
                                }

                                break;

                        default:
                                break;
                }
        }
} /* --- eventhandler_main() --- */



/*
 * Volume Control lookuptable.
 * TODO: This table is now hardcoded. To ensure full skinability this table
 * should be dynamically loaded.
 */
rom unsigned 5 volumecontrol_table[46] = {31, 31, 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24,  24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0};

---