Momentum-Apps/input_event.c

#include "input_event.h"

uint8_t get_field(uint8_t patternx)
{
	uint8_t field = 0;

	if(patternx <= 1) field = 0;
	if(patternx == 2) field = 1;
	if(patternx == 3) field = 2;
	if(patternx > 3) field = 3;

	return field;
}

void edit_note(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step, int8_t delta) //here we need data about last note if we place a new note
{
	int16_t note = tracker_engine_get_note(step);

	if(note == MUS_NOTE_NONE)
	{
		note = tracker->current_note; //remember which note we entered earlier and use it as reference
	}

	clamp(note, delta, 0, MAX_NOTE);

	set_note(step, (uint8_t)note);

	tracker->current_note = (uint8_t)note;
}

void edit_instrument(TrackerSongPatternStep* step, int8_t delta)
{
	int16_t inst = tracker_engine_get_instrument(step);

	if(inst == MUS_NOTE_INSTRUMENT_NONE)
	{
		if(delta > 0)
		{
			inst = 0;
		}

		else
		{
			inst = MUS_NOTE_INSTRUMENT_NONE - 1;
		}
	}

	clamp(inst, delta, 0, MUS_NOTE_INSTRUMENT_NONE - 1);

	set_instrument(step, (uint8_t)inst);
}

void edit_volume(TrackerSongPatternStep* step, int8_t delta)
{
	int16_t vol = tracker_engine_get_volume(step);

	if(vol == MUS_NOTE_VOLUME_NONE)
	{
		if(delta > 0)
		{
			vol = 0;
		}

		else
		{
			vol = MUS_NOTE_VOLUME_NONE - 1;
		}
	}

	clamp(vol, delta, 0, MUS_NOTE_VOLUME_NONE - 1);

	set_volume(step, (uint8_t)vol);
}

void edit_command(TrackerSongPatternStep* step, uint8_t digit, int8_t delta)
{
	int32_t command = tracker_engine_get_command(step);

	switch(digit)
	{
		case 0: //upper 7 bits
		{
			int16_t fx_name = ((command & 0x7f00) >> 8);

			if(fx_name + delta > 35) //loop
			{                        //0-9 and then A-Z
				fx_name = 0;
			}

			else if(fx_name + delta < 0)
			{
				fx_name = 35;
			}

			else
			{
				fx_name += delta;
			}

			command &= 0x00ff;

			command |= (fx_name << 8);

			set_command(step, (uint16_t)command);

			break;
		}

		case 1: //upper digit of command param
		{
			int8_t upper_digit = ((command & 0x00f0) >> 4);

			if(upper_digit + delta > 0xf) //loop
			{
				upper_digit = 0;
			}

			else if(upper_digit + delta < 0)
			{
				upper_digit = 0xf;
			}

			else
			{
				upper_digit += delta;
			}

			command &= 0xff0f;

			command |= (upper_digit << 4);

			set_command(step, (uint16_t)command);

			break;
		}

		case 2: //lower digit of command param
		{
			int8_t lower_digit = (command & 0x000f);

			if(lower_digit + delta > 0xf) //loop
			{
				lower_digit = 0;
			}

			else if(lower_digit + delta < 0)
			{
				lower_digit = 0xf;
			}

			else
			{
				lower_digit += delta;
			}

			command &= 0xfff0;

			command |= lower_digit;

			set_command(step, (uint16_t)command);

			break;
		}

		default: break;
	}
}

void delete_field(TrackerSongPatternStep* step, uint8_t field)
{
	switch(field)
	{
		case 0: //note
		{
			set_note(step, MUS_NOTE_NONE);
			break;
		}

		case 1: //instrument
		{
			set_instrument(step, MUS_NOTE_INSTRUMENT_NONE);
			break;
		}

		case 2: //volume
		{
			set_volume(step, MUS_NOTE_VOLUME_NONE);
			break;
		}

		case 3: //command
		{
			set_command(step, 0);
			break;
		}

		default: break;
	}
}

void edit_pattern_step(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step, int8_t delta)
{
	switch(get_field(tracker->patternx))
	{
		case 0: //note
		{
			if(tracker->patternx) //editing octave
			{
				edit_note(tracker, step, 12 * delta);
			}

			else //editing note
			{
				edit_note(tracker, step, delta);
			}

			break;
		}

		case 1: //instrument
		{
			edit_instrument(step, delta);
			break;
		}

		case 2: //volume
		{
			edit_volume(step, delta);
			break;
		}

		case 3: //command
		{
			uint8_t digit = 0;
			if(tracker->patternx == 4) digit = 0;
			if(tracker->patternx == 5) digit = 1;
			if(tracker->patternx == 6) digit = 2;
			edit_command(step, digit, delta);
			break;
		}

		default: break;
	}
}

void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
{
	uint8_t sequence_position = tracker->tracker_engine.sequence_position;
	uint8_t current_pattern = tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
	uint8_t pattern_step = tracker->tracker_engine.pattern_position;

	uint8_t pattern_length = tracker->tracker_engine.song->pattern_length;

	TrackerSongPattern* pattern = &tracker->tracker_engine.song->pattern[current_pattern];

	TrackerSongPatternStep* step = NULL;

	if(pattern_step < pattern_length)
	{
		step = &pattern->step[pattern_step];
	}

	if(!(step)) return;

	if(event->input.key == InputKeyOk && event->input.type == InputTypeShort)
	{
		tracker->editing = !tracker->editing;
	}

	if(event->input.key == InputKeyOk && event->input.type == InputTypeLong)
	{
		if(tracker->tracker_engine.playing)
		{
			stop_song(tracker);
		}

		else
		{
			play_song(tracker, true);
		}
	}

	if(event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
	{
		tracker->patternx++;

		if(tracker->patternx > MAX_PATTERNX - 1)
		{
			tracker->current_channel++;

			tracker->patternx = 0;

			if(tracker->current_channel > SONG_MAX_CHANNELS - 1)
			{
				tracker->current_channel = 0;
			}
		}
	}

	if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
	{
		tracker->patternx--;

		if(tracker->patternx > MAX_PATTERNX - 1) //unsigned int overflow
		{
			tracker->current_channel--;

			tracker->patternx = MAX_PATTERNX - 1;

			if(tracker->current_channel > SONG_MAX_CHANNELS - 1) //unsigned int overflow
			{
				tracker->current_channel = SONG_MAX_CHANNELS - 1;
			}
		}
	}

	if(event->input.key == InputKeyDown && event->input.type == InputTypeShort)
	{
		if(!(tracker->editing))
		{
			tracker->tracker_engine.pattern_position++;

			if(tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1 && tracker->tracker_engine.sequence_position < tracker->tracker_engine.song->num_sequence_steps - 1)
			{
				tracker->tracker_engine.pattern_position = 0;
				tracker->tracker_engine.sequence_position++;
			}

			else if(tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1)
			{
				tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
			}
		}

		if(tracker->editing)
		{
			edit_pattern_step(tracker, step, -1);
		}
	}

	if(event->input.key == InputKeyUp && event->input.type == InputTypeShort)
	{
		if(!(tracker->editing))
		{
			int16_t temp_pattern_position = tracker->tracker_engine.pattern_position - 1;

			if(temp_pattern_position < 0)
			{
				if(tracker->tracker_engine.sequence_position > 0)
				{
					tracker->tracker_engine.sequence_position--;
					tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
				}
			}

			else
			{
				tracker->tracker_engine.pattern_position--;
			}
		}

		if(tracker->editing)
		{
			edit_pattern_step(tracker, step, 1);
		}
	}

	if(event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->editing)
	{
		uint8_t field = get_field(tracker->patternx);

		delete_field(step, field);
	}
}

void process_input_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
{
	if(event->input.key == InputKeyBack && event->input.type == InputTypeShort && event->period > 0 && event->period < 200) 
	{
		//TODO: add cycle focus
	}

	// Если нажата кнопка "назад", то выходим из цикла, а следовательно и из приложения
	if(event->input.key == InputKeyBack && event->input.type == InputTypeLong) 
	{
		tracker->quit = true;
		return;
	}

	switch(tracker->focus)
	{
		case EDIT_PATTERN:
		{
			pattern_edit_event(tracker, event);
			break;
		}

		default: break;
	}
}