OpenGLEAN 0.6 development - OpenGLEAN: CallbackMaker.c File Reference

#include <GL/openglean.h>

#include <stdio.h>
#include <stdlib.h>

static int sequence_number = 0;

int reshape_called = 0, key_called = 0,
    special_called = 0, visibility_called = 0,
    keyup_called = 0, specialup_called = 0,
    mouse_called = 0,
    mousewheel_called = 0, motion_called = 0,
    passivemotion_called = 0, entry_called = 0,
    close_called = 0;
int reshape_width = -1, reshape_height = -1, reshape_seq = -1;
int key_key = -1, key_x = -1, key_y = -1, key_seq = -1;
int special_key = -1, special_x = -1, special_y = -1, special_seq = -1;
int visibility_vis = -1, visibility_seq = -1;
int keyup_key = -1, keyup_x = -1, keyup_y = -1, keyup_seq = -1;
int specialup_key = -1, specialup_x = -1,
    specialup_y = -1, specialup_seq = -1;
int mouse_button = -1, mouse_updown = -1,
    mouse_x = -1, mouse_y = -1, mouse_seq = -1;
int mousewheel_number = -1, mousewheel_direction = -1,
    mousewheel_x = -1, mousewheel_y = -1, mousewheel_seq = -1;
int motion_x = -1, motion_y = -1, motion_seq = -1;
int passivemotion_x = -1, passivemotion_y = -1,
    passivemotion_seq = -1;

static void Display (void)
{
    char line [180];
    int window = glutGetWindow ();
    glClear (GL_COLOR_BUFFER_BIT);

    glDisable (GL_DEPTH_TEST);
    glMatrixMode (GL_PROJECTION);
    glPushMatrix ();
    glLoadIdentity ();
    glOrtho (
        0, glutGet( GLUT_WINDOW_WIDTH ),
        0, glutGet( GLUT_WINDOW_HEIGHT ),
        -1, 1
    );
    glMatrixMode (GL_MODELVIEW);
    glPushMatrix ();
    glLoadIdentity ();
    glColor3ub (0, 0, 0);
    glRasterPos2i (10, glutGet (GLUT_WINDOW_HEIGHT) - 10);

    if (reshape_called)
    {
        sprintf (
            line, "Reshape %d:  %d %d\n",
            reshape_seq, reshape_width, reshape_height
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (key_called)
    {
        sprintf (
            line, "Key %d:  %d(%c) %d %d\n",
            key_seq, key_key, key_key, key_x, key_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (special_called)
    {
        sprintf (
            line, "Special %d:  %d(%c) %d %d\n",
            special_seq, special_key, special_key, special_x, special_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (visibility_called)
    {
        sprintf (
            line, "Visibility %d:  %d\n",
            visibility_seq, visibility_vis
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (keyup_called)
    {
        sprintf (
            line, "Key Up %d:  %d(%c) %d %d\n",
            keyup_seq, keyup_key, keyup_key, keyup_x, keyup_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (specialup_called)
    {
        sprintf (
            line, "Special Up %d:  %d(%c) %d %d\n",
            specialup_seq, specialup_key, specialup_key,
            specialup_x, specialup_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (mouse_called)
    {
        sprintf (
            line, "Mouse %d:  %d %d %d %d\n",
            mouse_seq, mouse_button, mouse_updown, mouse_x, mouse_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (mousewheel_called)
    {
        sprintf (
            line, "Mouse Wheel %d:  %d %d %d %d\n",
            mousewheel_seq, mousewheel_number, mousewheel_direction,
            mousewheel_x, mousewheel_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (motion_called)
    {
        sprintf (
            line, "Motion %d:  %d %d\n", motion_seq, motion_x, motion_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    if (passivemotion_called)
    {
        sprintf (
            line, "Passive Motion %d:  %d %d\n",
            passivemotion_seq, passivemotion_x, passivemotion_y
        );
        glutBitmapString (GLUT_BITMAP_HELVETICA_12, (GLubyte *) line);
    }

    glMatrixMode (GL_PROJECTION);
    glPopMatrix ();
    glMatrixMode (GL_MODELVIEW);
    glPopMatrix ();
    glEnable (GL_DEPTH_TEST);

    printf ("%6d Window %d Display Callback\n", ++sequence_number, window);
    glutSwapBuffers ();
}

static void Reshape( int width, int height )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Reshape Callback:  %d %d\n",
        ++sequence_number, window, width, height
    );
    reshape_called = 1;
    reshape_width = width;
    reshape_height = height;
    reshape_seq = sequence_number;
    glutPostRedisplay( );
}

static void Key( unsigned char key, int x, int y )
{
    int window = glutGetWindow( );

    if( '\x1b' == key )         /* Esc to exit */
        glutLeaveMainLoop( );
    else
    {
        printf(
            "%6d Window %d Keyboard Callback:  %d %d %d\n",
            ++sequence_number, window, key, x, y
        );
        key_called = 1;
        key_key = key;
        key_x = x;
        key_y = y;
        key_seq = sequence_number;
        glutPostRedisplay( );
    }
}

static void Special( int key, int x, int y )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Special Key Callback:  %d %d %d\n",
        ++sequence_number, window, key, x, y
    );
    special_called = 1;
    special_key = key;
    special_x = x;
    special_y = y;
    special_seq = sequence_number;
    glutPostRedisplay( );
}

static void Visibility( int vis )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Visibility Callback:  %d\n",
        ++sequence_number, window, vis
    );
    visibility_called = 1;
    visibility_vis = vis;
    visibility_seq = sequence_number;
    glutPostRedisplay( );
}

static void KeyUp(unsigned char key, int x, int y)
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Key Release Callback:  %d %d %d\n",
        ++sequence_number, window, key, x, y
    );
    keyup_called = 1;
    keyup_key = key;
    keyup_x = x;
    keyup_y = y;
    keyup_seq = sequence_number;
    glutPostRedisplay( );
}

static void SpecialUp(int key, int x, int y)
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Special Key Release Callback:  %d %d %d\n",
        ++sequence_number, window, key, x, y
    );
    specialup_called = 1;
    specialup_key = key;
    specialup_x = x;
    specialup_y = y;
    specialup_seq = sequence_number;
    glutPostRedisplay( );
}

static void Mouse( int button, int updown, int x, int y )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Mouse Click Callback:  %d %d %d %d\n",
        ++sequence_number, window, button, updown, x, y
    );
    mouse_called = 1;
    mouse_button = button;
    mouse_updown = updown;
    mouse_x = x;
    mouse_y = y;
    mouse_seq = sequence_number;
    glutPostRedisplay( );
}

static void Motion( int x, int y )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Mouse Motion Callback:  %d %d\n",
        ++sequence_number, window, x, y
    );
    motion_called = 1;
    motion_x = x;
    motion_y = y;
    motion_seq = sequence_number;
    glutPostRedisplay( );
}

static void PassiveMotion( int x, int y )
{
    int window = glutGetWindow( );
    printf(
        "%6d Window %d Mouse Passive Motion Callback:  %d %d\n",
        ++sequence_number, window, x, y
    );
    passivemotion_called = 1;
    passivemotion_x = x;
    passivemotion_y = y;
    passivemotion_seq = sequence_number;
    glutPostRedisplay( );
}

static void Entry( int state )
{
    int window = glutGetWindow( );
    entry_called = 1;
    printf(
        "%6d Window %d Entry Callback:  %d\n", ++sequence_number, window, state
    );
    glutPostRedisplay( );
}

void timeOut( int i )
{
    printf( "Got a timer event, user-data: %d.\n", i );
    glutTimerFunc( i, timeOut, i );
}


int main( int argc, char **argv )
{
    int openglean_window, aux_window;

    glutInitWindowSize( 500, 250 );
    glutInitWindowPosition( 140, 140 );
    glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
    glutInit( &argc, argv );

    openglean_window = glutCreateWindow( "Callback Demo" );
    printf( "Creating window %d as 'Callback Demo'\n", openglean_window );

    glClearColor( 1, 1, 1, 1 );

    glutDisplayFunc( Display );
    glutReshapeFunc( Reshape );
    glutKeyboardFunc( Key );
    glutSpecialFunc( Special );
    glutWindowStatusFunc( Visibility );
    glutKeyboardUpFunc( KeyUp );
    glutSpecialUpFunc( SpecialUp );
    glutMouseFunc( Mouse );
    glutMotionFunc( Motion );
    glutPassiveMotionFunc( PassiveMotion );
    glutEntryFunc( Entry );

    glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
    aux_window = glutCreateWindow( "Second Window" );
    printf( "Creating window %d as 'Second Window'\n", aux_window );

    glClearColor( 1, 1, 1, 1 );

    glutDisplayFunc( Display );
    glutReshapeFunc( Reshape );
    glutKeyboardFunc( Key );
    glutSpecialFunc( Special );
    glutWindowStatusFunc( Visibility );
    glutKeyboardUpFunc( KeyUp );
    glutSpecialUpFunc( SpecialUp );
    glutMouseFunc( Mouse );
    glutMotionFunc( Motion );
    glutPassiveMotionFunc( PassiveMotion );
    glutEntryFunc( Entry );

    glutTimerFunc( 1000, timeOut, 1000 );

    glutMainLoop( );

    printf( "Back from the OpenGLEAN main loop\n" );
    return EXIT_SUCCESS;
}
CallbackMaker.c File Reference

Detailed Description
