move_cursor_linux.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

int is_esc_pressed(Display *display, KeyCode esc_code) {
    char keys[32];
    XQueryKeymap(display, keys);
    return (keys[esc_code / 8] & (1 << (esc_code % 8))) != 0;
}

int is_mouse_clicked(Display *display, Window root, int *x_out, int *y_out) {
    Window root_ret, child_ret;
    int root_x, root_y, win_x, win_y;
    unsigned int mask;
    if (XQueryPointer(display, root, &root_ret, &child_ret, &root_x, &root_y, &win_x, &win_y, &mask)) {
        if (x_out) *x_out = root_x;
        if (y_out) *y_out = root_y;
        if (mask & (Button1Mask | Button2Mask | Button3Mask)) {
            return 1;
        }
    }
    return 0;
}

void get_cursor_pos(Display *display, Window root, int *x_out, int *y_out) {
    Window root_ret, child_ret;
    int root_x, root_y, win_x, win_y;
    unsigned int mask;
    if (XQueryPointer(display, root, &root_ret, &child_ret, &root_x, &root_y, &win_x, &win_y, &mask)) {
        if (x_out) *x_out = root_x;
        if (y_out) *y_out = root_y;
    }
}

static void* raise_zenity_topmost(void *arg) {
    usleep(150000); // Dar 150ms a Zenity para crear la ventana
    Display *display = XOpenDisplay(NULL);
    if (!display) return NULL;

    Window root = DefaultRootWindow(display);
    Atom net_client_list = XInternAtom(display, "_NET_CLIENT_LIST", True);
    Atom net_wm_state = XInternAtom(display, "_NET_WM_STATE", False);
    Atom net_wm_state_above = XInternAtom(display, "_NET_WM_STATE_ABOVE", False);
    Atom net_wm_state_modal = XInternAtom(display, "_NET_WM_STATE_MODAL", False);

    for (int retry = 0; retry < 15; retry++) {
        Atom type;
        int format;
        unsigned long nitems, bytes_after;
        unsigned char *prop = NULL;

        if (XGetWindowProperty(display, root, net_client_list, 0, 1024, False, XA_WINDOW,
                               &type, &format, &nitems, &bytes_after, &prop) == Success && prop) {
            Window *windows = (Window *)prop;
            for (unsigned long i = 0; i < nitems; i++) {
                char *name = NULL;
                if (XFetchName(display, windows[i], &name) && name) {
                    if (strstr(name, "IdleGuard")) {
                        XEvent xev = {0};
                        xev.type = ClientMessage;
                        xev.xclient.window = windows[i];
                        xev.xclient.message_type = net_wm_state;
                        xev.xclient.format = 32;
                        xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
                        xev.xclient.data.l[1] = net_wm_state_above;
                        xev.xclient.data.l[2] = net_wm_state_modal;
                        xev.xclient.data.l[3] = 1;

                        XSendEvent(display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
                        XRaiseWindow(display, windows[i]);
                        XSetInputFocus(display, windows[i], RevertToParent, CurrentTime);
                        XFlush(display);
                        XFree(name);
                        XFree(prop);
                        XCloseDisplay(display);
                        return NULL;
                    }
                    XFree(name);
                }
            }
            XFree(prop);
        }
        usleep(50000);
    }
    XCloseDisplay(display);
    return NULL;
}

int select_mode_dialog() {
    pthread_t thread;
    pthread_create(&thread, NULL, raise_zenity_topmost, NULL);
    pthread_detach(thread);

    FILE *fp = popen("zenity --question --modal --title='IdleGuard - Merke Software' "
                     "--window-icon=/home/perry/Desarrollo/mouse/icon.png "
                     "--width=620 --height=350 "
                     "--text='<b>Selecciona el modo de funcionamiento de IdleGuard:</b>\n\n"
                     "<b>1. Modo Giratorio</b>\n"
                     "   Movimiento circular continuo alrededor del clic.\n"
                     "   <i>(Se detiene haciendo Clic o presionando la tecla ESC)</i>\n\n"
                     "<b>2. Modo Inactividad (Segundo Plano)</b>\n"
                     "   Micro-movimiento sutil tras 15 segundos inactivo.\n"
                     "   <i>(Se detiene únicamente presionando la tecla ESC)</i>' "
                     "--ok-label='1. Modo Giratorio' "
                     "--extra-button='2. Modo Inactividad' "
                     "--cancel-label='Cancelar' 2>/dev/null", "r");
    if (!fp) return 0;

    char buffer[64] = {0};
    char *res = fgets(buffer, sizeof(buffer), fp);
    int status = pclose(fp);

    if (res && strstr(buffer, "2. Modo Inactividad")) {
        return 2;
    }
    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
        return 1;
    }

    return 0;
}

int sleep_check_esc(Display *display, KeyCode esc_code, int ms) {
    for (int i = 0; i < ms / 10; i++) {
        if (is_esc_pressed(display, esc_code)) return 1;
        usleep(10000);
    }
    return 0;
}

int main() {
    // 1. Desvincular de la terminal como primera instrucción
    if (daemon(1, 0) != 0) {
        int devnull = open("/dev/null", O_RDWR);
        if (devnull != -1) {
            dup2(devnull, STDIN_FILENO);
            dup2(devnull, STDOUT_FILENO);
            dup2(devnull, STDERR_FILENO);
            close(devnull);
        }
    }

    // 2. Diálogo modal sin ventana de consola de fondo
    int mode = select_mode_dialog();
    if (mode == 0) {
        return 0;
    }

    Display *display = XOpenDisplay(NULL);
    if (!display) {
        return 1;
    }

    Window root = DefaultRootWindow(display);
    KeyCode esc_code = XKeysymToKeycode(display, XK_Escape);

    if (mode == 1) {
        // MODO 1: GIRATORIO
        system("notify-send 'IdleGuard' 'Modo Giratorio: Haz clic en la pantalla para tomar la posición inicial.' -i /home/perry/Desarrollo/mouse/icon.png >/dev/null 2>&1 &");
        usleep(250000);

        int click_x = 0, click_y = 0;

        while (1) {
            if (is_esc_pressed(display, esc_code)) {
                XCloseDisplay(display);
                return 0;
            }
            if (is_mouse_clicked(display, root, &click_x, &click_y)) {
                break;
            }
            usleep(15000);
        }

        while (is_mouse_clicked(display, root, NULL, NULL)) {
            usleep(20000);
        }
        usleep(100000);

        system("notify-send 'IdleGuard' 'Girando... Haz clic o presiona ESC para detener.' -i /home/perry/Desarrollo/mouse/icon.png >/dev/null 2>&1 &");

        int radius = 100;
        int steps = 120;
        useconds_t interval = 25000;

        while (1) {
            for (int step = 0; step < steps; step++) {
                if (is_esc_pressed(display, esc_code) || is_mouse_clicked(display, root, NULL, NULL)) {
                    goto cleanup;
                }

                double angle = step * 2.0 * M_PI / steps;
                int x = (int)(click_x + radius * cos(angle));
                int y = (int)(click_y + radius * sin(angle));

                XWarpPointer(display, None, root, 0, 0, 0, 0, x, y);
                XFlush(display);
                usleep(interval);
            }
        }
    } else if (mode == 2) {
        // MODO 2: INACTIVIDAD (SEGUNDO PLANO)
        system("notify-send 'IdleGuard' 'Modo Inactividad activo. Micro-movimiento en inactividad (Detener con ESC).' -i /home/perry/Desarrollo/mouse/icon.png >/dev/null 2>&1 &");
        usleep(250000);

        int last_x = -1, last_y = -1;
        int idle_seconds = 0;

        while (1) {
            if (is_esc_pressed(display, esc_code)) goto cleanup;

            int cur_x = 0, cur_y = 0;
            get_cursor_pos(display, root, &cur_x, &cur_y);

            if (cur_x != last_x || cur_y != last_y) {
                last_x = cur_x;
                last_y = cur_y;
                idle_seconds = 0;
            } else {
                idle_seconds++;
            }

            if (idle_seconds >= 15) {
                XWarpPointer(display, None, root, 0, 0, 0, 0, cur_x + 1, cur_y);
                XFlush(display);
                if (sleep_check_esc(display, esc_code, 50)) goto cleanup;

                XWarpPointer(display, None, root, 0, 0, 0, 0, cur_x, cur_y);
                XFlush(display);

                get_cursor_pos(display, root, &last_x, &last_y);
                idle_seconds = 0;
            }

            if (sleep_check_esc(display, esc_code, 1000)) goto cleanup;
        }
    }

cleanup:
    system("notify-send 'IdleGuard' 'Movimiento detenido.' -i /home/perry/Desarrollo/mouse/icon.png >/dev/null 2>&1 &");
    XCloseDisplay(display);
    return 0;
}