#include <stdio.h>
#include <gpm.h>
#include <pthread.h>


...

void* InputThread(void *arg)
{
    int gpm;
    Gpm_Connect gpm_connect;
    Gpm_Event gpm_event;

    gpm_connect.eventMask = GPM_MOVE | GPM_UP | GPM_DOWN;
    gpm_connect.defaultMask = 0;
    gpm_connect.minMod = 0;
    gpm_connect.maxMod = 0xFFFF;

    gpm = Gpm_Open(&gpm_connect, 0);

    if (gpm < 0) {
	printf("Unable to connect.\n");
	return 1;
    }

    while(1) {
        if (Gpm_GetEvent(&gpm_event) != 1) {
	    printf("Unable to read GPM event.\n");
	    continue;
	}

        // Here is where you can modify the mouse position, or 
        // queue a mouse event, etc.. Depends on how you write
        // your app.
        mouse_pos.x += gpm_event.dx
        mouse_pos.y += gpm_event.dy
        MyMouseHandler(mouse_pos);
    
        // Handle clicks with gpm_event.buttons
        MyMouseButtonHandler(mouse_pos, gpm_event.buttons);
    }
}

...

int main(void) 
{
    pthread_t input_thread;

    pthread_create( &input_thread, NULL, InputThread, 0);

    ...

    while(1) {
        HandleEventFromQueue();
        DoStuff();
    }
}

#include <stdio.h>
#include <errno.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h> 

#include <gpm.h>

int mouse_pos_x;
int mouse_pos_y;
unsigned char mouse_buttons;

int InitGPM()
{
    Gpm_Connect gpm_connect;

    gpm_connect.eventMask = GPM_MOVE | GPM_UP | GPM_DOWN;
    gpm_connect.defaultMask = 0;
    gpm_connect.minMod = 0;
    gpm_connect.maxMod = 0xFFFF;

    // Connect to Gpm
    return Gpm_Open(&gpm_connect, 0);
}

int main(void) 
{
    /* the gpm file descriptor */
    int gpm;

    /* holds a gpm event */
    Gpm_Event gpm_event;
    
    /* A list of file descriptors we want select() to wait for. */
    fd_set fds;

    int running = 1;
    int result;
    int c;
    struct timeval tv;
    
    /* I'm using these for animation */
    int anim_cnt = 1;

    mouse_pos_x = 0;
    mouse_pos_y = 0;
    mouse_buttons = 0x00;

    /* Initialize GPM */
    gpm = InitGPM();

    if (gpm < 0) {
        printf("Unable to connect to GPM.\n");
        return 1;
    }
 
    // Our main loop
    while(running) {
 
        /* Clear the file descriptor set. */
        FD_ZERO(&fds);
        /* Add GPM to the file descriptor set. */
        FD_SET(gpm, &fds);
        /* You could add other file descriptors you want to "grab".
         * Example: keyboard, serial mice, maybe some proc file, etc..  */

        /* Initialize the timeout.  If none of the file descriptors change
         * status within this period of time, then select will return anyways. */
        tv.tv_sec = 0;
        tv.tv_usec = 20000;

        /* Block until we receive input or until the timeout elapses. */
        result = select(gpm+1, &fds, NULL, NULL, &tv);
		
        if (result < 0) {
            /* Is something fubar'd? */
            if (errno == EINTR) 
                continue; /* no, but we need to wait again. */
    
            printf("select failed: %s\n", strerror(errno));
            break; /* yes, exit */
        }
    
        if (result > 0) {
            /* A mouse event is available, get it. */
            if (Gpm_GetEvent(&gpm_event) != 1) {
                printf("Unable to read an event.\n");
                break;
            }

            /* gpm_event has 5 members we are concerned about. 
             *  .x and .y  are the absolute positions (in character 
             * on the screen.  .dx and .dy are better for us, so we
             * can just keep track of absolute position ourselves.
             * The final parameter, .buttons, is a bitmask of which
             * buttons are pressed.  I'll just show a simplified solution
             * that uses a global mouse position.
             */
 
            mouse_pos_x += gpm_event.dx;
            mouse_pos_y += gpm_event.dy;
            mouse_buttons = gpm_event.buttons;

            /* You probably want to call some function to handle the mouse event */
            printf("x: %d  x: %d  dx: %d  dy: %d  Buttons: %X\n",
               gpm_event.x, gpm_event.y, gpm_event.dx, gpm_event.dy,
               gpm_event.buttons);

        } 
        else {
            /* No data is ready, so you can do something else. For example,
             * animate the screen, do some processing. We will just draw a
             * little ascii animation to get the point across. */
   
            printf("[");
            for(c = 0; c < abs(10-anim_cnt); c++)
                printf("-");
            printf("#");
            for(; c < 10; c++)
                printf("-");
            printf("]\r");
            
            if (++anim_cnt == 20) 
                anim_cnt = 0;
            fflush(stdout);
            
       }
    }
 
    return 0;
}