jess_input.c

#include "jess_input.h"
#include "jess_config.h"
#include "jess_graphics.h"
#include "jess_audio.h"

void handle_events() {
    keyboard();
}

// Complete keyboard handler from original misc.c
void keyboard() {
    SDL_Event event;
    
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
            case SDL_QUIT:
                quit_app = 1;
                break;
                
            case SDL_KEYDOWN: {
                // Check for Shift/Ctrl modifiers
                SDL_Keymod mod = SDL_GetModState();
                int shift_pressed = (mod & KMOD_SHIFT) != 0;
                int ctrl_pressed = (mod & KMOD_CTRL) != 0;
                
                switch (event.key.keysym.sym) {
                    case SDLK_ESCAPE:
                    case SDLK_SPACE:
                        printf("Full Screen mode toggled\n");
                        conteur.fullscreen = 1 - conteur.fullscreen;
                        SDL_SetWindowFullscreen(window, conteur.fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
                        save_config();  // Save fullscreen state
                        break;
                        
                    // Resolution changes
                    case SDLK_c:
                        printf("Resolution key 320*180\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 320; resy = 180;
                        break;
                    case SDLK_v:
                        printf("Resolution key 512*200\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 512; resy = 200;
                        break;
                    case SDLK_b:
                        printf("Resolution key 640*480\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 640; resy = 480;
                        break;
                    case SDLK_n:
                        printf("Resolution key 800*400\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 800; resy = 400;
                        break;
                    case SDLK_COMMA:
                        printf("Resolution key 1024x768\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 1024; resy = 768;
                        break;
                    case SDLK_PERIOD:
                        printf("Resolution key 1920x1080 (Full HD)\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 1920; resy = 1080;
                        break;
                    case SDLK_SLASH:
                        printf("Resolution key 2560x1440 (2K QHD)\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 2560; resy = 1440;
                        break;
                    case SDLK_SEMICOLON:
                        printf("Resolution key 3840x2160 (4K UHD)\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        resx = 3840; resy = 2160;
                        break;
                        
                    // Video mode toggle
                    case SDLK_o:
                        printf("Toggle 32/8bits mode\n");
                        quit_renderer = 1;
                        resolution_change = 1;
                        video = (video == 8) ? 32 : 8;
                        break;
                        
                    // Control modes
                    case SDLK_d:
                        printf("Freeze Image\n");
                        conteur.freeze = 1 - conteur.freeze;
                        break;
                    case SDLK_f:
                        printf("Freeze mode\n");
                        conteur.freeze_mode = 1 - conteur.freeze_mode;
                        break;
                    case SDLK_p:
                        printf("Random palette\n");
                        random_palette();
                        break;
                    case SDLK_e:
                        printf("Enable/disable new colors\n");
                        conteur.psy = 1 - conteur.psy;
                        save_config();
                        break;
                    case SDLK_a:
                        printf("Enable/disable Energie analyser\n");
                        conteur.analyser = 1 - conteur.analyser;
                        save_config();
                        break;
                        
                    // Blur modes F1-F5
                    case SDLK_F1:
                        if (shift_pressed) {
                            toggle_blur_mode_enabled(0);
                        } else if (config.blur_modes_enabled[0]) {
                            printf("Blur mode 0\n");
                            conteur.blur_mode = 0;
                            save_config();
                        }
                        break;
                    case SDLK_F2:
                        if (shift_pressed) {
                            toggle_blur_mode_enabled(1);
                        } else if (config.blur_modes_enabled[1]) {
                            printf("Blur mode 1\n");
                            conteur.blur_mode = 1;
                            save_config();
                        }
                        break;
                    case SDLK_F3:
                        if (shift_pressed) {
                            toggle_blur_mode_enabled(2);
                        } else if (config.blur_modes_enabled[2]) {
                            printf("Blur mode 2\n");
                            conteur.blur_mode = 2;
                            save_config();
                        }
                        break;
                    case SDLK_F4:
                        if (shift_pressed) {
                            toggle_blur_mode_enabled(3);
                        } else if (config.blur_modes_enabled[3]) {
                            printf("Blur mode 3\n");
                            conteur.blur_mode = 3;
                            save_config();
                        }
                        break;
                    case SDLK_F5:
                        if (shift_pressed) {
                            toggle_blur_mode_enabled(4);
                        } else if (config.blur_modes_enabled[4]) {
                            printf("Blur mode 4\n");
                            conteur.blur_mode = 4;
                            save_config();
                        }
                        break;
                        
                    // Draw modes F6-F12
                    case SDLK_F6:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(6);
                        } else if (config.draw_modes_enabled[6]) {
                            printf("Draw mode 6\n");
                            conteur.draw_mode = 6;
                            save_config();
                        }
                        break;
                    case SDLK_F7:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(5);
                        } else if (config.draw_modes_enabled[5]) {
                            printf("Draw mode 5\n");
                            conteur.draw_mode = 5;
                            save_config();
                        }
                        break;
                    case SDLK_F8:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(4);
                        } else if (config.draw_modes_enabled[4]) {
                            printf("Draw mode 4\n");
                            conteur.draw_mode = 4;
                            save_config();
                        }
                        break;
                    case SDLK_F9:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(0);
                        } else if (config.draw_modes_enabled[0]) {
                            printf("Draw mode 0\n");
                            conteur.draw_mode = 0;
                            save_config();
                        }
                        break;
                    case SDLK_F10:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(1);
                        } else if (config.draw_modes_enabled[1]) {
                            printf("Draw mode 1\n");
                            conteur.draw_mode = 1;
                            save_config();
                        }
                        break;
                    case SDLK_F11:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(2);
                        } else if (config.draw_modes_enabled[2]) {
                            printf("Draw mode 2\n");
                            conteur.draw_mode = 2;
                            save_config();
                        }
                        break;
                    case SDLK_F12:
                        if (shift_pressed) {
                            toggle_draw_mode_enabled(3);
                        } else if (config.draw_modes_enabled[3]) {
                            printf("Draw mode 3\n");
                            conteur.draw_mode = 3;
                            save_config();
                        }
                        break;
                        
                    // Navigation keys for cycling through enabled modes
                    case SDLK_LEFT:
                        if (ctrl_pressed) {
                            // Cycle through blur modes
                            conteur.blur_mode = get_prev_enabled_blur_mode(conteur.blur_mode);
                            printf("Blur mode %d\n", conteur.blur_mode);
                            save_config();
                        } else {
                            // Cycle through draw modes
                            conteur.draw_mode = get_prev_enabled_draw_mode(conteur.draw_mode);
                            printf("Draw mode %d\n", conteur.draw_mode);
                            save_config();
                        }
                        break;
                        
                    case SDLK_RIGHT:
                        if (ctrl_pressed) {
                            // Cycle through blur modes
                            conteur.blur_mode = get_next_enabled_blur_mode(conteur.blur_mode);
                            printf("Blur mode %d\n", conteur.blur_mode);
                            save_config();
                        } else {
                            // Cycle through draw modes
                            conteur.draw_mode = get_next_enabled_draw_mode(conteur.draw_mode);
                            printf("Draw mode %d\n", conteur.draw_mode);
                            save_config();
                        }
                        break;
                        
                    case SDLK_u:
                        printf("Color mode : %i\n", conteur.triplet);
                        break;
                        
                    case SDLK_h:
                        // Help menu
                        printf("\n=== JESS Help ===\n");
                        printf("Q: Quit\n");
                        printf("SPACE/ESC: Toggle fullscreen\n");
                        printf("F1-F5: Select blur mode\n");
                        printf("Shift+F1-F5: Toggle blur mode enable/disable\n");
                        printf("F6-F12: Select draw mode\n");
                        printf("Shift+F6-F12: Toggle draw mode enable/disable\n");
                        printf("Left/Right: Cycle through enabled draw modes\n");
                        printf("Ctrl+Left/Right: Cycle through enabled blur modes\n");
                        printf("P: Random palette\n");
                        printf("E: Toggle psychedelic colors\n");
                        printf("A: Toggle analyzer display\n");
                        printf("D: Freeze image\n");
                        printf("F: Freeze mode\n");
                        printf("I: Show current configuration\n");
                        printf("===============\n");
                        break;
                        
                    case SDLK_i:
                        print_config();
                        break;
                        
                    case SDLK_q:
                        quit_app = 1;
                        break;
                }
                break;
            }
        }
    }
}

void ips() {
    conteur.dt = time_last(4, NON);
    conteur.fps = (int)(1.0 / time_last(4, REINIT));
    if (conteur.term_display == OUI) {
        printf("FPS :%i\r", conteur.fps);
        fflush(stdout);
    }
}