_glut.C

Ir a la documentación de este archivo.

//===========================================================================
//= _glut.cc                                             Septiembre de 1999 =
//=-------------------------------------------------------------------------=
//= Definicion de elementos GUI especificos a GLUT                          =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "jed_defs.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "jed_gl.h"
#include "framework/gui/_glut.h"
#include "lista.cc"

#ifdef GLUT_ENABLED
    #include <GL/glut.h>
#endif

//===========================================================================
//= Chequeo de activacion de esta interfaz                                  =
//===========================================================================

#ifndef GLUT_ENABLED

JED_GUI_CLASE_NULA(JED_GLUT_INTERFACE, "JED_GLUT_INTERFACE",
    "GLUT", "glut", "GLUT_ENABLED");

#endif

#ifdef GLUT_ENABLED

//===========================================================================
//= CLASES UTILITARIAS GLUT                                                 =
//===========================================================================

class VENTANA_GLUT {
  private:
    int id;
    int status;
    BOOLEAN por_pintar;
  public:
    VENTANA_GLUT();

    friend class JED_GLUT_INTERFACE;
    friend void glut_draw_callback(void);
    friend void glut_wstatus_callback(int wstatus);
};

static BOOLEAN CON_glide = FALSE;

VENTANA_GLUT::VENTANA_GLUT()
{
    status = -1;
    id = -1;
    por_pintar = FALSE;
}

//===========================================================================
//= Variables globales                                                      =
//===========================================================================

static EVENTO_GUI EVENTO_glut;     // Esto es para que funcione EVNT_EVENTO_GUI
static int PETICIONES_pendientes = 0; // # de ventanas con que inicia esta GUI
static BOOLEAN GUI_creada = FALSE;    // TRUE cuando ya esta lista la GUI
static int QUIERO_pintarme = 0;      // EL SUPER-CANDADO!
static LISTA<VENTANA_GLUT *> LAS_ventanas;
static int X_mouse = 320;
static int Y_mouse = 240;
static int X_tam = 320;
static int Y_tam = 240;

// Manejadores de las funciones callback de aplicacion (apuntadores a funcion)
static int  (*GLUTGUI_ejecutor_callback)(int idc, int context_id);
static void (*GLUTGUI_draw_callback)(int);
static int  (*GLUTGUI_tick_callback)(int);
static void (*GLUTGUI_resize_callback)(int x_tam, int y_tam, int);
static int  (*GLUTGUI_keyboard_callback)(EVENTO_GUI *e, int);
static int  (*GLUTGUI_mouse_callback)(EVENTO_GUI *e, int);
static void (*GLUTGUI_multiview_callback)(int operacion, int id_vista,
             char *detalles, char *menu, char *botonera);

//===========================================================================
//= Prototipos                                                              =
//===========================================================================

// Funciones callback internas para glut
static void glut_idle_callback(void);
static void glut_menu_callback(int param);
static void glut_resize_callback(int x, int y);
static void glut_mouseentry_callback(int estado);
static void glut_mousestate_callback(int button, int state, int x, int y);
static void glut_mousemove_callback(int x, int y);
static void
       glut_keyboard1_callback(unsigned char tecla, int /*x*/, int /*y*/);
static void
       glut_keyboard2_callback(int tecla, int /*x*/, int /*y*/);
void glut_draw_callback(void);
void glut_wstatus_callback(int wstatus);

//===========================================================================
//= Constantes y macros                                                     =
//===========================================================================

#define MANEJO_DE_MOUSE_GLUT() \
    EVNT_EVENTO_GUI->mouse_old_x = EVNT_EVENTO_GUI->mouse_x;\
    EVNT_EVENTO_GUI->mouse_old_y = EVNT_EVENTO_GUI->mouse_y;\
    EVNT_EVENTO_GUI->mouse_x = X_mouse = x;\
    EVNT_EVENTO_GUI->mouse_y = Y_mouse = y;\
    EVNT_EVENTO_GUI->mouse_delta_x=x-EVNT_EVENTO_GUI->mouse_old_x;\
    EVNT_EVENTO_GUI->mouse_delta_y=y-EVNT_EVENTO_GUI->mouse_old_y;\
    int cod=GLUTGUI_mouse_callback(EVNT_EVENTO_GUI, glutGetWindow());\
    if ( CON_glide && \
         (EVNT_EVENTO_GUI->mouse_delta_x || \
          EVNT_EVENTO_GUI->mouse_delta_y) ) QUIERO_pintarme = 1; \
    if ( cod != 0 ) {\
        QUIERO_pintarme = cod; \
    }

#define VERIFICAR(o)                                                    \
    if ( !(o) ) {                                                       \
        fprintf(stderr, "<GLUT> - ERROR FATAL: No hay memoria!\n");     \
        fflush(stderr);                                                 \
        exit(-1);                                                       \
    }

//===========================================================================
//= Funciones que definen el comportamiento por defecto                     =
//===========================================================================

static void quit_callback(int /*param*/) { exit(1); }
static void pintar_nulo(int /*context_id*/) { ; }
static void resize_nulo(int /*x*/, int /*y*/, int /*context_id*/) { ; }
static void idle_nulo(void) {
 if (QUIERO_pintarme!=0 && !CON_glide) glut_draw_callback(); }
static int  evento_nulo(EVENTO_GUI * /*e*/, int /*context_id*/) { return 0; }

//===========================================================================
//= Funciones callback para GLUT                                            =
//===========================================================================

static void
glut_keyboard1_callback(unsigned char tecla, int /*x*/, int /*y*/)
{
    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_KEY_DOWN;
    GLUTkeycode2JEDkeycode(EVNT_EVENTO_GUI, (int)tecla);
    EVNT_EVENTO_GUI->key_mask = 0x00;

    //if ( mask && GLUT_SHIFT ) EVNT_EVENTO_GUI->key_mask += EKEY_SHIFT;
    //if ( mask && GLUT_CONTROL ) EVNT_EVENTO_GUI->key_mask += EKEY_CTRL;
    
    int cod=GLUTGUI_keyboard_callback(EVNT_EVENTO_GUI, glutGetWindow());
    if ( cod != 0 ) {
        QUIERO_pintarme = cod;
        return; //return GL_FALSE;
    }
    return; // GL_FALSE;
}

static void
glut_keyboard2_callback(int tecla, int /*x*/, int /*y*/)
{
    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_KEY_DOWN;
    GLUTkeycode2JEDkeycodeB(EVNT_EVENTO_GUI, tecla);
    EVNT_EVENTO_GUI->key_mask = 0x00;

    //if ( mask && GLUT_SHIFT ) EVNT_EVENTO_GUI->key_mask += EKEY_SHIFT;
    //if ( mask && GLUT_CONTROL ) EVNT_EVENTO_GUI->key_mask += EKEY_CTRL;

    //printf(".");  fflush(stdout);
    
    int cod=GLUTGUI_keyboard_callback(EVNT_EVENTO_GUI, glutGetWindow());
    if ( cod != 0 ) {
        QUIERO_pintarme = cod;
        return; //return GL_FALSE;
    }
    return; // GL_FALSE;
}

static void
glut_mouseentry_callback(int /*estado*/)
{
    ;
}

static void
glut_mousestate_callback(int button, int state, int x, int y)
{
    if ( state ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_UP;
        EVNT_EVENTO_GUI->mouse_button_mask &= ~(0x01 << button);
      }
      else {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_DOWN;
        EVNT_EVENTO_GUI->mouse_button_mask |= 0x01 << button;
    }
    MANEJO_DE_MOUSE_GLUT();
}

static void
glut_mousemove_callback(int x, int y)
{
    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_MOUSE_MOVE;
    MANEJO_DE_MOUSE_GLUT();
}

static void
glut_idle_callback(void)
{
    int cod = GLUTGUI_tick_callback(glutGetWindow());
    if ( cod != 0 ) { QUIERO_pintarme = cod; }

    if ( QUIERO_pintarme != 0 && !CON_glide ) glut_draw_callback();
}

static void
glut_resize_callback(int x, int y)
{
    X_tam = x;
    Y_tam = y;
    GLUTGUI_resize_callback(x, y, glutGetWindow());
    QUIERO_pintarme = 1;
}

static void
glut_menu_callback(int param)
{
    if ( !GLUTGUI_ejecutor_callback ) return;
    int cod = GLUTGUI_ejecutor_callback(param, glutGetWindow());
    if ( cod != 0 ) QUIERO_pintarme = cod;
}

static void
extra_cursor(void)
{
    if ( !CON_glide ) return;

    glViewport(0, 0, X_tam, Y_tam);

    float x, y;

    x = 2*(float)X_mouse/(float)X_tam - 1;
    y = 2*(float)(Y_tam - Y_mouse)/(float)Y_tam - 1;

    glMatrixMode(GL_PROJECTION);   glPushMatrix(); glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);    glPushMatrix(); glLoadIdentity();
    glDisable(GL_LIGHTING);        glDisable(GL_DEPTH_TEST);
    glDisable(GL_TEXTURE_2D);      glDisable(GL_FOG);
    glDisable(GL_ALPHA_TEST);

    glColor4d(0, 1, 0, 0.4);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glTranslated(x, y, 0);
    glScaled(0.04, 0.04, 0.04);
    glTranslated(1, -1, 0);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glBegin(GL_TRIANGLES);
        glVertex2d(1, 0.5);    
        glVertex2d(-1, 1);    
        glVertex2d(0, 0.2);    

        glVertex2d(0, 0.2);    
        glVertex2d(-1, 1);    
        glVertex2d(0, -1);    
    glEnd();
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);   glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glDisable(GL_BLEND);
}

void
glut_draw_callback(void)
{
    int i, b;

    b = glutGetWindow();
    switch ( QUIERO_pintarme ) {
      case -1:
        for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
            glutSetWindow(LAS_ventanas[i]->id);
            GLUTGUI_draw_callback(LAS_ventanas[i]->id);
            glFlush(); glFinish();
        }
        for ( i = 0; BUFFER_doble && i < LAS_ventanas.tam(); i++ ) {
            glutSetWindow(LAS_ventanas[i]->id);
            extra_cursor();
            glutSwapBuffers();
        }
        glutSetWindow(b);
        break;
      case 1:
        for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
            if ( LAS_ventanas[i]->por_pintar ||
                 LAS_ventanas[i]->id == b ) {
                glutSetWindow(LAS_ventanas[i]->id);
                GLUTGUI_draw_callback(LAS_ventanas[i]->id);
                glFlush(); glFinish();
            }
        }
        for ( i = 0; BUFFER_doble && i < LAS_ventanas.tam(); i++ ) {
            if ( LAS_ventanas[i]->por_pintar ||
                 LAS_ventanas[i]->id == b ) {
                glutSetWindow(LAS_ventanas[i]->id);
                extra_cursor();
                glutSwapBuffers();
                LAS_ventanas[i]->por_pintar = FALSE;
            }
        }
        glutSetWindow(b);
        break;
      case 0: default:
        break;
    }

    QUIERO_pintarme = 0;
}

//===========================================================================
//= Clase JED_GLUT_INTERFACE                                                =
//===========================================================================

JED_GLUT_INTERFACE::JED_GLUT_INTERFACE()
{
    BUFFER_doble = TRUE;

    GLUTGUI_draw_callback = pintar_nulo;
    GLUTGUI_tick_callback = NULL;
    GLUTGUI_mouse_callback = evento_nulo;
    GLUTGUI_keyboard_callback = evento_nulo;
    GLUTGUI_resize_callback = resize_nulo;
    GLUTGUI_multiview_callback = NULL;
    GLUTGUI_ejecutor_callback = NULL;

    _xtam = 320;
    _ytam = 240;
    _nombre = NULL;
}

JED_GLUT_INTERFACE::~JED_GLUT_INTERFACE()
{
    ;
}

void JED_GLUT_INTERFACE::solicitar_repintado(void){;}

void JED_GLUT_INTERFACE::set_draw_callback( void (*p)(int context_id) )
{ GLUTGUI_draw_callback = p; }

void JED_GLUT_INTERFACE::set_tick_callback( int (*p)(int context_id) )
{ GLUTGUI_tick_callback = p; }

void JED_GLUT_INTERFACE::set_keyboard_callback( 
 int (*p)(EVENTO_GUI *e, int context_id) )
{ GLUTGUI_keyboard_callback = p; }

void JED_GLUT_INTERFACE::set_mouse_callback( 
     int (*p)(EVENTO_GUI *e, int context_id) )
{ GLUTGUI_mouse_callback = p; }

void JED_GLUT_INTERFACE::set_resize_callback(
 void (*p)(int x_tam, int y_tam, int context_id) )
{ GLUTGUI_resize_callback = p; }

void JED_GLUT_INTERFACE::set_ejecutor( int (*p)(int idc, int context_id) )
{ GLUTGUI_ejecutor_callback = p; }

void JED_GLUT_INTERFACE::set_multiview_callback(void (*p)(int operacion, 
    int id_vista, char *detalles, char *menu, char *botonera) )
{ GLUTGUI_multiview_callback = p; }

BOOLEAN
JED_GLUT_INTERFACE::crear(int * Argc, char *argv[], int x_tam, int y_tam, char *nombre)
{
    EVNT_EVENTO_GUI = &EVENTO_glut;

    if ( getenv("MESA_GLX_FX") ) CON_glide = TRUE;

    //- Inicializacion glut ------------------------------------------------
    glutInit(Argc, argv);
    _xtam = x_tam;
    _ytam = y_tam;
    _nombre = new char [strlen(nombre) + 1];
    strcpy(_nombre, nombre);

    //----------------------------------------------------------------------
    leer_gui("etc/spanish.gui");

    return TRUE;
}

#ifdef NONONO
void
tmp_visibility_callback(int i)
{
    printf("<GLUT/VISIBILITY>[%d] = %d\n", glutGetWindow(), i);
    fflush(stdout);
}
#endif

void
glut_wstatus_callback(int wstatus)
{
    int i, id;
    VENTANA_GLUT *V = NULL;

    //----------------------------------------------------------------------
    id = glutGetWindow();
    for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
        if ( LAS_ventanas[i]->id == id ) {
            V = LAS_ventanas[i];
            break;
        }
    }
    if ( !V ) return;

    //----------------------------------------------------------------------
    if ( V->status >= 0 && wstatus != V->status && wstatus > 0 ) {
        if ( !QUIERO_pintarme ) QUIERO_pintarme = 1;
        V->por_pintar = TRUE;
    }
    else QUIERO_pintarme = 0;
    V->status = wstatus;
}

void
glut_draw1_callback(void)
{
    GLUTGUI_draw_callback(1);
    extra_cursor();
    glFlush(); glFinish();
    glutSwapBuffers();
    glutPostRedisplay();
}

void
JED_GLUT_INTERFACE::crear_ventana_glut(void)
{
    //- Crea la nueva ventana ----------------------------------------------
    VENTANA_GLUT *Nueva_ventana;
    int tipo;

    Nueva_ventana = new VENTANA_GLUT();
    VERIFICAR(Nueva_ventana);

    tipo = GLUT_DEPTH | GLUT_RGBA;
    tipo |= (BUFFER_doble) ? GLUT_DOUBLE : GLUT_SINGLE;
    glutInitWindowSize(_xtam, _ytam);
    glutInitDisplayMode((GLenum)tipo);
    Nueva_ventana->id = glutCreateWindow(_nombre);
    if ( Nueva_ventana->id < 1 ) {
        delete Nueva_ventana;
        return;
    }

    //- Configura la nueva ventana -----------------------------------------
    glutReshapeFunc(glut_resize_callback);
//    glutWindowStatusFunc(glut_wstatus_callback);
    glutKeyboardFunc(glut_keyboard1_callback);      // Para el teclado
    glutSpecialFunc(glut_keyboard2_callback);
    glutEntryFunc(glut_mouseentry_callback);        // Para el mouse
    glutMouseFunc(glut_mousestate_callback);
    glutMotionFunc(glut_mousemove_callback);
    glutPassiveMotionFunc(glut_mousemove_callback);
    //glutVisibilityFunc(tmp_visibility_callback);

    //---
    if ( CON_glide ) glutDisplayFunc(glut_draw1_callback);
    else glutDisplayFunc(glut_draw_callback);
    //---

    //- Pregunta informacion a la aplicacion --------------------------------
    char menu[1024];
    char botonera[1024]; // Esta vaina se ignora en GLUT!

    if ( GLUTGUI_multiview_callback ) {
        GLUTGUI_multiview_callback(GUI_CREAR_VISTA, Nueva_ventana->id,
            "default", menu, botonera);
        // Saludable para cuando se inicia en modo PLAY_state activado
        GLUTGUI_resize_callback(_xtam, _ytam, Nueva_ventana->id);
    }
    if ( LAS_ventanas.tam() < 1 ) strcpy(menu, "GLOBAL");

    //- Arma y asocia un menu para la ventana -------------------------------
    GUI_MENU *Global = resolver_menu(menu);
    int menu_glut;

    if ( lista_menus.tam() > 0 && Global ) {
        menu_glut = Global->crear_glut(glut_menu_callback);
      }
      else {
        menu_glut = glutCreateMenu(quit_callback);
        glutSetMenu(menu_glut);
        glutAddMenuEntry("Salir", 666);
    }

    glutSetMenu(menu_glut);
    glutSetWindow(Nueva_ventana->id);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    //- Anexa la ventana a la lista de ventanas ----------------------------
    LAS_ventanas.anx(Nueva_ventana);
    glutSetWindow(Nueva_ventana->id);
}

void
JED_GLUT_INTERFACE::ejecutar(void)
{
    if ( GLUTGUI_tick_callback ) glutIdleFunc(glut_idle_callback);
    else glutIdleFunc(idle_nulo);

    //- Creacion de las ventanas solicitadas en la inicializacion ----------
    for ( ; PETICIONES_pendientes > 0; PETICIONES_pendientes-- ) {
        crear_ventana_glut();
    }
    GUI_creada = TRUE;

    //-----------------------------------------------------------------------
    glutMainLoop();
}

void
JED_GLUT_INTERFACE::finalizar(void)
{
    int i;

    for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
        glutSetWindow(LAS_ventanas[i]->id);
        glutIdleFunc(NULL);
        glutDestroyWindow(LAS_ventanas[i]->id);
        delete LAS_ventanas[i];
    }
    LAS_ventanas.elim();
    //printf("Gracias por usar AQUYNZA!\n");
    //fflush(stdout);
    // OJO: Dado que glutMainLoop es un ciclo infinito, esto no se puede
    //      terminar de una manera elegante!
    exit(1);
}

void
JED_GLUT_INTERFACE::solicitar_nueva_ventana(void)
{
    if ( GUI_creada ) {
        crear_ventana_glut();
      }
      else {
        PETICIONES_pendientes++;
    }
}

BOOLEAN
JED_GLUT_INTERFACE::anexar_controles(LISTA <CONTROL_GUI *> * /*Controles*/, 
                             REPOSITORIO_DE_ENTIDADES * /*Repositorio*/)
{
    fprintf(stderr, "<JED_INTERFACE> ERROR: Los controles GUI no estan\n"
        "    implemetados en la interface actual.  Intente Motif.\n");
    fflush(stderr);
    return FALSE;
}

#endif // GLUT_ENABLED

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.