jed_menu.C

Ir a la documentación de este archivo.

//===========================================================================
//= jed_menu.h                                              Octubre de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de las clases de administracion de GUI_MENU's y GUI_COMANDO's      =
//=-------------------------------------------------------------------------=
//= 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 "framework/gui/jed_menu.h"
#include "lista.cc"

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

#ifdef MOTIF_ENABLED
    #include <Xm/Xm.h>
    #include <Xm/CascadeB.h>
    #include <Xm/MenuShell.h>
    #include <Xm/PushB.h>
    #include <Xm/RowColumnP.h>
    #include <Xm/Separator.h>
    #include <Xm/ToggleB.h>
    #include <Xm/ToggleBG.h>

    #include "framework/gui/_motifcb.h"
#endif

#ifdef WXWINDOWS_ENABLED
    #include "framework/gui/_wxwindows.h"
#endif

// OJO: Si estas macros se organizan ya no compila!

#define ESPERO(tipo, msg) if ( tipo_token != (tipo) ) {  fprintf(stderr,"<GUI_COMANDO> ERROR: Esperaba %s y recibi [%s].\n", (msg), cad); fflush(stderr);  return FALSE;  }

#define ESPERO_MENU(tipo, msg) if ( tipo_token != (tipo) ) {  fprintf(stderr,"<GUI_MENU> ERROR: Esperaba %s y recibi [%s].\n",  (msg), cad); fflush(stderr);  return FALSE; }

#define CARGAR_CADENA(destino, origen)    if ( (destino) ) delete (destino);    des_comille((origen));    (destino) = new char[strlen((origen))+1];    if ( !(destino) ) {      fprintf(stderr, "<GUI_COMANDO>-ERROR: No hay memoria para una cadenita!");     fflush(stderr);        return FALSE;    } strcpy((destino), (origen));

//===========================================================================
//= CLASE GUI_COMANDO                                                           =
//===========================================================================

GUI_COMANDO::GUI_COMANDO()
{
    _id = -666;
    _nombre = NULL;
    resumen = NULL;
    ayuda = NULL;
    _archivo_icono = NULL;
}

GUI_COMANDO::~GUI_COMANDO()
{
    ;
}

int
GUI_COMANDO::id(void)
{
    return _id;
}

char *
GUI_COMANDO::nombre(void)
{
    return _nombre;
}

char *
GUI_COMANDO::archivo_icono(void)
{
    return _archivo_icono;
}

BOOLEAN
GUI_COMANDO::concatenar_ayuda(char *cola)
{
    char *nueva;

    des_comille(cola);

    if ( ayuda ) {
        nueva = new char[strlen(ayuda) + strlen(cola) + 1];
      }
      else {
        nueva = new char[strlen(cola) + 1];
    }

    if ( !nueva ) return FALSE;

    if ( !ayuda ) {
        ayuda = nueva;
        strcpy(ayuda, cola);
        return TRUE;
    }

    sprintf(nueva, "%s%s", ayuda, cola);
    delete ayuda;
    ayuda = nueva;

    return TRUE;
}

void
GUI_COMANDO::imprimir(void)
{
    printf("<GUI_COMANDO> Reporte para \"%s\":\n", _nombre);
    printf("  - Identificador: %d\n", _id);
    printf("  - Resumen: \"%s\"\n", resumen);
    printf("  - Icono: \"%s\"\n", _archivo_icono);
    printf("  - AYUDA:\n%s\n-- Fin de comando --\n", ayuda);
}

BOOLEAN
GUI_COMANDO::leer(TOKENIZADOR *Sabiondo, LISTA<GUI_CONSTANTE_ENTERA *> *Tabla_idcs)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos, i;

    pos = 0;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
            case 0:
              ESPERO(TK_IDENTIFICADOR, "una constante textual");
              //- Ya que tengo nombre, sabre quien soy! ------------------
              for ( i = 0; i < Tabla_idcs->tam(); i++ ) {
                  if ( strcmp((*Tabla_idcs)[i]->nombre, cad) == 0 ) {
                      _id = (*Tabla_idcs)[i]->valor;
                      break;
                  }
              }

              if ( i >= Tabla_idcs->tam() ) {
                  fprintf(stderr, "<GUI_COMANDO> - Warning: "
                      "la constante %s no esta definida.\n", cad);
                  fflush(stderr);
              }
              pos++;
              break;
            case 1:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
            default:
              if ( tipo_token == TK_CERRAR ) break;
              ESPERO(TK_IDENTIFICADOR, "un identificador (1)");
              if ( strstr(cad, "nombre") ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_CADENA, "una cadena con un nombre");
                  CARGAR_CADENA(_nombre, cad);
                }
                else if ( strstr(cad, "resumen") ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_CADENA, "una cadena con un resumen");
                  CARGAR_CADENA(resumen, cad);
                }
                else if ( strstr(cad, "ayuda") ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_CADENA, "una cadena con ayuda");
                  if ( !concatenar_ayuda(cad) ) return FALSE;
                }
                else if ( strstr(cad, "icono") ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_CADENA, "una cadena con un archivo de icono");
                  CARGAR_CADENA(_archivo_icono, cad);
                }
                else {
                  fprintf(stderr,
                      "<GUI_COMANDO> - Warning: Tipo \"%s\" desconocido.\n", cad);
                  fflush(stderr);
                }

              ;
              break;
        }
    }

    return TRUE;
}

//===========================================================================
//= CLASE GUI_ELEMENTO                                                      =
//===========================================================================

static int nivel = 0;

GUI_ELEMENTO::~GUI_ELEMENTO()
{
    ;
}

//===========================================================================
//= CLASE REFERENCIA_GUI                                                    =
//===========================================================================

REFERENCIA_GUI::REFERENCIA_GUI(char *n, JED_INTERFACE *i)
{
    nombre = new char[strlen(n) + 1];
    if ( !nombre ) {
        return;
    }
    strcpy(nombre, n);

    Ref = NULL;
    Interface = i;
}

REFERENCIA_GUI::~REFERENCIA_GUI()
{
    if ( nombre ) delete nombre;
}

void
REFERENCIA_GUI::imprimir(void)
{
    int i;

    for ( i = 0; i < nivel+1; i++ ) printf("  ");
    printf("{Referencia al menu %s}\n", nombre);
}

#ifdef GLUT_ENABLED
void
REFERENCIA_GUI::crear_glut(int padre)
{
    if ( !Ref ) {
        Ref = Interface->resolver_menu(nombre);
    }

    if ( !Ref ) {
        glutSetMenu(padre);
        glutAddMenuEntry("<Mala Referencia!>", -666);
    }
    Ref->insertar_glut(padre);
}
#endif

#ifdef MOTIF_ENABLED

Widget
REFERENCIA_GUI::crear_motif(Widget padre, int /*tipo_menu*/)
{
    if ( !Ref ) {
        Ref = Interface->resolver_menu(nombre);
    }

    if ( !Ref ) {
        return XtVaCreateManagedWidget("[INCLUDE MALITO!]",
            xmPushButtonWidgetClass, padre, NULL);
    }
    Ref->insertar_motif(padre);
    return padre;
}

Widget
REFERENCIA_GUI::crear_motif(Widget padre)
{
    return crear_motif(padre, TM_PULLDOWN);
}

#endif // MOTIF_ENABLED

#if PLATAFORMA == i386_WIN32_VC

BOOLEAN
REFERENCIA_GUI::crear_mswin32sdk(HMENU padre)
{
    char cad[200] = "[INCLUDE MALITO!]";
    MENUITEMINFO opcion = {
            sizeof(MENUITEMINFO), // Siempre es esto!
            // Identifica los valores a cuadrar aqui
            MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_TYPE, 
            MFT_STRING, // Tipo de opcion
            MFS_ENABLED, // Atributos de la opcion
            666, // Identificador de comando 
            NULL, // HMENU   hSubMenu; 
            NULL, // HBITMAP hbmpChecked; 
            NULL, // HBITMAP hbmpUnchecked; 
            666, // DWORD   dwItemData; (puede ser usado por la aplicacion)
            cad, // Datos de opcion (dependiente de su tipo)
            strlen(cad) // Datos de opcion (dependiente de su tipo)
        };

    if ( !Ref ) Ref = Interface->resolver_menu(nombre);

    if ( !Ref ) {
        if ( !padre || !InsertMenuItem(padre, 0, TRUE, &opcion) ) {
            return FALSE;
        }
      }
      else {
        return Ref->insertar_mswin32sdk(padre);
    }
    return TRUE;
}

#endif // i386_WIN32_VC

#ifdef WXWINDOWS_ENABLED
wxMenu *
REFERENCIA_GUI::crear_wxw(wxMenu *Padre, int /*tipo_menu*/)
{
    if ( !Ref ) {
        Ref = Interface->resolver_menu(nombre);
    }

    if ( Ref ) {
        Ref->crear_wxw(Padre, TM_PULLDOWN);
    }

    return NULL;
}

#endif

//===========================================================================
//= CLASE SEPARADOR                                                         =
//===========================================================================

SEPARADOR::~SEPARADOR()
{
    ;
}

void
SEPARADOR::imprimir(void)
{
    int i;

    for ( i = 0; i < nivel+1; i++ ) printf("  ");
    printf("------------\n");
}

#ifdef GLUT_ENABLED
void
SEPARADOR::crear_glut(int padre)
{
    glutSetMenu(padre);
    glutAddMenuEntry("--------", -666);
}
#endif

#ifdef MOTIF_ENABLED
Widget
SEPARADOR::crear_motif(Widget padre)
{
    return XtVaCreateManagedWidget("--------", xmSeparatorWidgetClass, padre,
               XmNorientation, XmHORIZONTAL,
               XmNbottomAttachment, XmATTACH_FORM, XmNbottomOffset, 2,
               XmNrightAttachment, XmATTACH_FORM, XmNrightOffset, 2, 
               XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 2,
               NULL);
}
#endif

#if PLATAFORMA == i386_WIN32_VC

BOOLEAN
SEPARADOR::crear_mswin32sdk(HMENU padre)
{
    char cad[200] = "<SEPARADOR>";

    MENUITEMINFO opcion = {
        sizeof(MENUITEMINFO), // Siempre es esto!
        // Identifica los valores a cuadrar aqui
        MIIM_DATA | MIIM_ID | MIIM_STATE | MIIM_TYPE, 
        MFT_SEPARATOR, // Tipo de opcion
        MFS_ENABLED, // Atributos de la opcion
        666, // Identificador de comando 
        NULL, // HMENU   hSubMenu; 
        NULL, // HBITMAP hbmpChecked; 
        NULL, // HBITMAP hbmpUnchecked; 
        666, // DWORD   dwItemData; (puede ser usado por la aplicacion)
        cad, // Datos de opcion (dependiente de su tipo)
        strlen(cad) // Datos de opcion (dependiente de su tipo)
    };

    if ( !padre || !InsertMenuItem(padre, 0, TRUE, &opcion) ) {
        return FALSE;
    }
    return TRUE;
}

#endif // i386_WIN32_VC

#ifdef WXWINDOWS_ENABLED
wxMenu *
SEPARADOR::crear_wxw(wxMenu *Padre, int /*tipo_menu*/)
{
    Padre->AppendSeparator();
    return NULL;
}

#endif

//===========================================================================
//= CLASE OPCION                                                            =
//===========================================================================

OPCION::OPCION(char *name, int id)
{
    flags = 0x00;
    idc = id;
    nombre = new char[strlen(name) + 1];
    if ( !nombre ) return;
    strcpy(nombre, name);
}

OPCION::~OPCION()
{
    if ( nombre ) delete nombre;
}

void
OPCION::check(void)
{
    flags |= OF_CHECKED;
    flags |= OF_BINARY;
}

void
OPCION::uncheck(void)
{
    flags &= ~OF_CHECKED;
    flags |= OF_BINARY;
}

void
OPCION::enable(void)
{
    flags &= ~OF_GRAYED;
}

void
OPCION::disable(void)
{
    flags |= OF_GRAYED;
}

void
OPCION::imprimir(void)
{
    int i;

    for ( i = 0; i < nivel+1; i++ ) printf("  ");
    printf("- %s, IDC = %d ", nombre, idc);

    // OJO: Esta condicion es siempre constante?
    if ( flags & OF_CHECKED ) {
        printf("<C> ");
      }
      else {
        printf("<UC> ");
    }

    // OJO: Esta condicion es siempre constante?
    if ( flags & OF_GRAYED ) {
        printf("<G> ");
      }
      else {
        printf("<UG> ");
    }
    printf("\n");
}

int
OPCION::id(void)
{
    return idc;
}

#ifdef GLUT_ENABLED

void
procesar_nombre_glut(char *nuevo_nombre, char *nombre)
{
    char *ptr;

    strcpy(nuevo_nombre, nombre);

    //- Busqueda del identificador de menu ayuda o acelerador ---------------
    ptr = strchr(nuevo_nombre, '\\');
    if ( ptr && ptr[1] == 't' ) ptr[0] = '\0';
    for ( ptr = strchr(nuevo_nombre, '\\'); ptr;
          ptr = strchr(nuevo_nombre, '\\') ) {
        for ( ; ptr != NULL && ptr[2]; ptr++ ) ptr[0] = ptr[2];
        ptr[0] = '\0';
    }

    ptr = strchr(nuevo_nombre, '&');
    if ( ptr ) {
        for ( ;  ptr != NULL && ptr[1]; ptr++ ) ptr[0] = ptr[1];
        ptr[0] = '\0';
    }
}

void
OPCION::crear_glut(int padre)
{
    char *nuevo_nombre = new char[strlen(nombre)+1];

    if ( !nuevo_nombre ) {
        glutSetMenu(padre);
        glutAddMenuEntry("<ERROR!>", idc);
        return;
    }

    procesar_nombre_glut(nuevo_nombre, nombre);

    glutSetMenu(padre);
    glutAddMenuEntry(nuevo_nombre, idc);
}
#endif

#ifdef MOTIF_ENABLED

char ACCEL_x[20] = "";
char ACCEL_name[20] = "<Alt>-C";
BOOLEAN SOY_ayuda = FALSE;

void
procesar_acelerador_Xt(char *cad)
{
    char tecla[2] = "\0";
    BOOLEAN p = FALSE; // Ya estaba el primero
    char *ptr;

    strcpy(ACCEL_name, cad);

    if ( strstr(cad, "ESC") ) {
        sprintf(ACCEL_x, "<Key>Escape");
        return;
    }

    if ( strlen(cad) <= 1 ) {
        tecla[0] = cad[0];
      }
      else {
        ptr = strchr(cad, '+');
        if ( ptr ) tecla[0] = *(ptr+1);
    }

    ACCEL_x[0] = '\0';
    if ( strstr(cad, "Alt ") ) { strcat(ACCEL_x, "Alt"); p = TRUE; }
    if ( strstr(cad, "Ctrl ") ) {
        if ( p ) strcat(ACCEL_x, " + ");
        strcat(ACCEL_x, "Ctrl");
        p = TRUE;
    }

    strcat(ACCEL_x, "<Key> ");
    strcat(ACCEL_x, tecla);
}

BOOLEAN
procese_nombre_gui(char *nombre, char *Mnemonico, char *nuevo_nombre)
{
    unsigned i;
    char *ptr;
    BOOLEAN r = FALSE;

    strcpy(nuevo_nombre, nombre);

    //- Busqueda del identificador de menu ayuda o acelerador ---------------
    ptr = strchr(nuevo_nombre, '\\');
    if ( ptr && ptr[1] == 'a' ) {
        (*Mnemonico) = ptr[1];
        // Equivalente a quite(nuevo_nombre, "\\a"), que no se hizo
        for ( i = 0; i < strlen(nuevo_nombre) && ptr != NULL; i++,ptr++ ) {
            ptr[0] = ptr[2];
        }
        SOY_ayuda = TRUE;
      }
      else if ( ptr && ptr[1] == 't' ) {
        // Separe la informacion de acelerador
        ptr[0] = '\0';
        r = TRUE;
        procesar_acelerador_Xt(&ptr[2]);
    }

    //- Busqueda del Mnemonico ----------------------------------------------
    ptr = strchr(nuevo_nombre, '&');
    if ( ptr ) {
        (*Mnemonico) = ptr[1];
        // Equivalente a quite_caracter(nuevo_nombre, '&'), que no se hizo
        for ( i = 0; i < strlen(nuevo_nombre) && ptr != NULL; i++,ptr++ ) {
            ptr[0] = ptr[1];
        }
      }
      else {
        (*Mnemonico) = '\0';
    }

    return r;
}

Widget
OPCION::crear_motif(Widget padre)
{
    Widget opcion;
    char mnemonico = '\0';
    char nombre_motif[80];
    BOOLEAN tengo_acelerador = FALSE;
    XmString xmstr;

    tengo_acelerador = procese_nombre_gui(nombre, &mnemonico, nombre_motif);

    if ( !(flags & OF_BINARY) ) {
        opcion = XtVaCreateManagedWidget(nombre_motif,xmPushButtonWidgetClass,
            padre, XmNshadowThickness, 2, XmNmnemonic, mnemonico, NULL);
        XtAddCallback(opcion, XmNactivateCallback, 
            motif_ejecutor, (void *)&(this->idc));
      }
      else {
        //XtVaSetValues(padre, XmNradioBehavior, True, NULL);
        opcion = XtVaCreateManagedWidget(nombre_motif, 
            xmToggleButtonGadgetClass, padre, XmNmnemonic, mnemonico, 
            /*XmNshadowThickness,2,XmNfillOnArm,True,*/
            XmNvisibleWhenOff, True, NULL);
        XtAddCallback(opcion, XmNvalueChangedCallback, 
            motif_ejecutor, (void *)&(this->idc));
        XtManageChild(opcion);
        if ( flags & OF_CHECKED ) {
            XmToggleButtonSetState(opcion, True, False);
          }
          else {
            XmToggleButtonSetState(opcion, False, False);
        }
    }

    if ( tengo_acelerador ) {
        if ( strlen(ACCEL_x) > 0 ) {
            printf("<OPCION::crear_motif> Acelerador \"%s\"\n", ACCEL_x); 
            fflush(stdout);
            xmstr = XmStringCreateLocalized(ACCEL_x);
            // OJO: Aqui se esta produciendo un Warning Xt/Motif!
            //XtVaSetValues(opcion, XmNaccelerator, xmstr, NULL);
            XmStringFree(xmstr);
            ACCEL_x[0] = '\0';
        }
        xmstr = XmStringCreateLocalized(ACCEL_name);
        XtVaSetValues(opcion, XmNacceleratorText, xmstr, NULL);
        XmStringFree(xmstr);
    }

    return opcion;
}

#endif // MOTIF_ENABLED

#if PLATAFORMA == i386_WIN32_VC

BOOLEAN
OPCION::crear_mswin32sdk(HMENU padre)
{
    char cad[200];

    strcpy(cad, nombre);

    //- Procesamiento del nombre de opcion para formato WINDOWS
    int i, j;
    for ( i = 0; cad[i]; i++ ) {
        if ( cad[i] == '\\' && cad[i+1] == 't' ) {
            cad[i] = '\t';
            i++;
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+1];
            }
        }
        if ( cad[i] == '\\' && cad[i+1] == 'a' ) {
            cad[i] = '\a';
            i++;
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+1];
            }
        }
    }

    MENUITEMINFO opcion = {
        sizeof(MENUITEMINFO), // Siempre es esto!
        // Identifica los valores a cuadrar aqui
        MIIM_TYPE | MIIM_STATE | MIIM_ID | MIIM_DATA, 
        MFT_STRING, // Tipo de opcion
        MFS_ENABLED, // Atributos de la opcion
        idc, // Identificador de comando 
        NULL, // HMENU   hSubMenu; 
        NULL, // HBITMAP hbmpChecked; 
        NULL, // HBITMAP hbmpUnchecked; 
        666, // DWORD   dwItemData; (puede ser usado por la aplicacion)
        cad, // Datos de opcion (dependiente de su tipo)
        strlen(cad) // Datos de opcion (dependiente de su tipo)
    };

    if ( !padre || !InsertMenuItem(padre, 0, TRUE, &opcion) ) {
        return FALSE;
    }
    return TRUE;
}

#endif // i386_WIN32_VC

#ifdef WXWINDOWS_ENABLED
wxMenu *
OPCION::crear_wxw(wxMenu *Padre, int tipo_menu)
{
    char cad[200];

    strcpy(cad, nombre);

    //- Procesamiento del nombre de opcion para formato WINDOWS
    int i, j;
    for ( i = 0; cad[i]; i++ ) {
        if ( cad[i] == '\\' && cad[i+1] == 't' ) {
            cad[i] = '\t';
            i++;
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+1];
            }
        }
        if ( cad[i] == '\\' && cad[i+1] == 'a' ) {
            cad[i] = '\a';
            i++;
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+1];
            }
        }
    }

    Padre->Append(idc, cad);

    return NULL;
}

#endif

//===========================================================================
//= CLASE GUI_MENU                                                              =
//===========================================================================

GUI_MENU::GUI_MENU(LISTA<GUI_CONSTANTE_ENTERA *> *tabla_constantes)
{
    Tabla_idcs = tabla_constantes;
    _nombre = NULL;
}

GUI_MENU::~GUI_MENU()
{
    if ( _nombre ) delete _nombre;
}

char *
GUI_MENU::nombre(void)
{
    return _nombre;
}

void
GUI_MENU::imprimir(void)
{
    int i;

    for ( i = 0; i < nivel+1; i++ ) printf("  ");
    printf("[%s]:\n", _nombre);

    nivel++;
    for ( i = 0; i < lista_hijos.tam(); i++ ) {
        lista_hijos[i]->imprimir();
    }
    nivel--;
}

BOOLEAN
GUI_MENU::leer(TOKENIZADOR *Sabiondo, JED_INTERFACE *I)
{
    char cad[1000], nombre_opcion[1000];
    int tipo_token = TK_DESCONOCIDO, pos, i, idc = -666;
    OPCION *Opcion = NULL;
    GUI_MENU *Menu;
    SEPARADOR *Separador;
    REFERENCIA_GUI *Referencia;

    pos = 1;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
          case 1:
            ESPERO_MENU(TK_CADENA, "Un nombre de menu");  pos++;
            des_comille(cad);
            _nombre = new char[strlen(cad) + 1];
            if ( !_nombre ) {
                fprintf(stderr, "<GUI_MENU> - ERROR: No hay memoria para "
                                "crear una cadenita!\n");
                fflush(stderr);
                return FALSE;
            }
            strcpy(_nombre, cad);
            break;
          case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
          default:
            if ( tipo_token == TK_CERRAR ) break;
            ESPERO_MENU(TK_IDENTIFICADOR, "un submenu, opcion o separador");
            if ( strcmp(cad, "MENU") == 0 || strcmp(cad, "POPUP") == 0 ) {
                Menu = new GUI_MENU(Tabla_idcs);
                if ( !Menu ) {
                    fprintf(stderr, "<GUI_MENU> - ERROR: No hay memoria para "
                                    "crear un sub-menu!\n");
                    fflush(stderr);
                    return FALSE;
                }
                Menu->leer(Sabiondo, I);
                lista_hijos.anx(Menu);
              }
              else if ( strcmp(cad, "MENUITEM") == 0 ) {
                tipo_token = Sabiondo->siguiente_token(cad);
                if ( strcmp(cad, "SEPARATOR") == 0 ) {
                    Separador = new SEPARADOR;
                    if ( !Separador ) {
                        fprintf(stderr, "<GUI_MENU> - ERROR: No hay memoria para "
                                        "crear un separadorcito!\n");
                        fflush(stderr);
                        return FALSE;
                    }
                    lista_hijos.anx(Separador);
                  }
                  else {
                    ESPERO_MENU(TK_CADENA, "un nombre de opcion");
                    strcpy(nombre_opcion, cad);
                    des_comille(nombre_opcion);

                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO_MENU(TK_IDENTIFICADOR, "una constante");
                    //printf(", %s\n", cad);
                    for ( i = 0; i < Tabla_idcs->tam(); i++ ) {
                        if ( strcmp(cad, (*Tabla_idcs)[i]->nombre) == 0 ) {
                            idc = (*Tabla_idcs)[i]->valor;
                            break;
                        }
                    }
                    if ( i >= Tabla_idcs->tam() ) {
                      /*
                        fprintf(stderr, "<GUI_MENU> - Warning: la constante %s no "
                                        "esta definida!\n", cad);
                        fflush(stderr);*/
                        idc = 666;
                    }

                    Opcion = new OPCION(nombre_opcion, idc);

                    if ( !Opcion ) {
                        fprintf(stderr, "<GUI_MENU> - ERROR: No hay memoria para "
                                        "crear una opcion!\n");
                        fflush(stderr);
                        return FALSE;
                    }

                    lista_hijos.anx(Opcion);

                    // OJO: Si hay tokens adicionales para esta opcion, tendran
                    // que procesarse a posteriori y aplicarse a ESTA opcion.
                }
              }
              else if ( strcmp(cad, "CHECKED") == 0 ) {
                Opcion->check();
              }
              else if ( strcmp(cad, "UNCHECKED") == 0 ) {
                Opcion->uncheck();
              }
              else if ( strcmp(cad, "GRAYED") == 0 ) {
                Opcion->disable();
              }
              else if ( strcmp(cad, "INCLUDE") == 0 ) {
                tipo_token = Sabiondo->siguiente_token(cad);
                ESPERO_MENU(TK_CADENA, "una referencia a sub-menu");
                des_comille(cad);
                Referencia = new REFERENCIA_GUI(cad, I);
                if ( !Referencia ) {
                    fprintf(stderr, "<GUI_MENU> - ERROR: No hay memoria para "
                                    "crear una referencia!\n");
                    fflush(stderr);
                    return FALSE;
                }
                lista_hijos.anx(Referencia);
              }
              else {
                fprintf(stderr,
                    "<GUI_MENU> - Error de sintaxis leyendo %s\n",cad);
                fflush(stderr);
                return FALSE;
            }
        }
    }

    return TRUE;
}

#ifdef GLUT_ENABLED

void (*LAST_callback)(int);

int
GUI_MENU::crear_glut( void (*menu_callback)(int param) )
{
    int menu;
    int i;

    LAST_callback = menu_callback;

    menu = glutCreateMenu(menu_callback);
    glutSetMenu(menu);

    for ( i = 0; i < lista_hijos.tam(); i++ ) {
        lista_hijos[i]->crear_glut(menu);
    }

    return menu;
}

void
GUI_MENU::crear_glut(int padre)
{
    char *nuevo_nombre = new char[strlen(_nombre)+1];
    int popup;

    if ( !nuevo_nombre ) return;
    procesar_nombre_glut(nuevo_nombre, _nombre);

    popup = glutCreateMenu(LAST_callback);
    insertar_glut(popup);
    glutSetMenu(padre);
    glutAddSubMenu(nuevo_nombre, popup);
}

void
GUI_MENU::insertar_glut(int padre)
{
    int i;

    for ( i = 0; i < lista_hijos.tam(); i++ ) lista_hijos[i]->crear_glut(padre);
}

#endif

#ifdef MOTIF_ENABLED

Widget
GUI_MENU::crear_motif(Widget padre)
{
    return crear_motif(padre, TM_PULLDOWN);
}

void
GUI_MENU::insertar_motif(Widget padre)
{
    int i;

    for ( i = 0; i < lista_hijos.tam(); i++ ) lista_hijos[i]->crear_motif(padre);
}

Widget
GUI_MENU::crear_motif(Widget padre, int tipo_menu)
{
    Widget menu = NULL, opcion = NULL;
    Arg arg_arr[10];
    int arg_tam;
    char nombre_motif[80], mnemonico;

    if ( lista_hijos.tam() < 1 ) {
        return XtVaCreateManagedWidget("<no tengo hijos!>",
            xmPushButtonWidgetClass, padre,
            NULL);
    }

    switch ( tipo_menu ) {
      case TM_MENUBAR:
        menu = XmCreateMenuBar(padre, "[MENUBAR]", NULL, 0);
        XtManageChild(menu);
        insertar_motif(menu);
        break;
      case TM_PULLDOWN: default:
        arg_tam = 0;
        XtSetArg(arg_arr[arg_tam], XmNtearOffModel, XmTEAR_OFF_ENABLED);
        arg_tam++;
        menu = XmCreatePulldownMenu(padre, "[PD_MENU]", arg_arr, arg_tam);
        XtManageChild(menu);
        insertar_motif(menu);
        procese_nombre_gui(_nombre, &mnemonico, nombre_motif);
        opcion=XtVaCreateManagedWidget(nombre_motif,xmCascadeButtonWidgetClass,
            padre, XmNsubMenuId, menu, XmNmnemonic, mnemonico, NULL);
        if ( SOY_ayuda ) {
            XtVaSetValues(padre, XmNmenuHelpWidget, opcion, NULL);
            SOY_ayuda = FALSE;
        }
        break;
    }

    return menu;
}

#endif // MOTIF_ENABLED

#if PLATAFORMA == i386_WIN32_VC

BOOLEAN
GUI_MENU::crear_mswin32sdk(HMENU padre)
{
    return crear_mswin32sdk(padre, TM_PULLDOWN);
}

BOOLEAN
GUI_MENU::insertar_mswin32sdk(HMENU padre)
{
    int i;

    for ( i = lista_hijos.tam() - 1; i >= 0; i-- ) {
        if ( !lista_hijos[i]->crear_mswin32sdk(padre) ) return FALSE;
    }
    return TRUE;
}

BOOLEAN
GUI_MENU::crear_mswin32sdk(HMENU padre, int tipo_menu)
{
    char cad[200];

    popup_id = CreatePopupMenu();
    strcpy(cad, _nombre);

    //- Procesamiento del nombre de opcion para formato WINDOWS
    int i, j;
    for ( i = 0; cad[i]; i++ ) {
        if ( cad[i] == '\\' && cad[i+1] == 't' ) {
            cad[i] = '\t';
            i++;
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+1];
            }
        }
        // OJO: No hay alguna manera de decirle a Windows que este item
        //      es el de ayuda?
        if ( cad[i] == '\\' && cad[i+1] == 'a' ) {
            for ( j = i; cad[j]; j++ ) {
                cad[j] = cad[j+2];
            }
            i+=2;
        }
    }

    if ( tipo_menu == TM_PULLDOWN ) {
        MENUITEMINFO menucito = {
            sizeof(MENUITEMINFO), // Siempre es esto!
            // Identifica los valores a cuadrar aqui
            MIIM_SUBMENU | MIIM_DATA | MIIM_STATE | MIIM_TYPE, 
            MFT_STRING, // Tipo de opcion
            MFS_ENABLED, // Atributos de la opcion
            666, // Identificador de comando 
            popup_id, // HMENU   SubMenu; 
            NULL,  // HBITMAP bmpChecked; 
            NULL,  // HBITMAP bmpUnchecked; 
            666,   // DWORD   Data; (puede ser usado por la aplicacion)
            cad, // Datos de opcion (dependiente de su tipo)
            strlen(cad) // Datos de opcion (dependiente de su tipo)
        };
    
        if ( !padre || !InsertMenuItem(padre, 0, TRUE, &menucito) ) {
            return FALSE;
        }

        if ( !insertar_mswin32sdk(popup_id) ) return FALSE;
      }
      else {
        if ( !insertar_mswin32sdk(padre) ) return FALSE;
    }

    return TRUE;
}

#endif // i386_WIN32_VC

#ifdef WXWINDOWS_ENABLED
wxMenuBar *
GUI_MENU::crear_wxw_barra(_WXWINDOWS_WINDOW *Ventana)
{
    wxMenuBar *Menubar = NULL;

    Menubar = Ventana->GetMenuBar();
    if ( !Menubar ) {
        Menubar = new wxMenuBar;
    }

    int i;

    for ( i = 0; i < lista_hijos.tam(); i++ ) {
        lista_hijos[i]->crear_wxw((wxMenu *)Menubar, TM_MENUBAR);
    }

    return Menubar;
}

wxMenu *
GUI_MENU::crear_wxw(wxMenu *Padre, int tipo_menu)
{
    wxMenu *Popup;
    char cad[200];

    if ( tipo_menu != TM_PULLDOWN ) {
        Popup = new wxMenu("", wxMENU_TEAROFF);

        strcpy(cad, _nombre);

        //- Procesamiento del nombre de opcion para formato WINDOWS
        int i, j;
        for ( i = 0; cad[i]; i++ ) {
            if ( cad[i] == '\\' && cad[i+1] == 't' ) {
                cad[i] = '\t';
                i++;
                for ( j = i; cad[j]; j++ ) {
                    cad[j] = cad[j+1];
                }
            }
            // OJO: No hay alguna manera de decirle a WXWindows que este item
            //      es el de ayuda?
            if ( cad[i] == '\\' && cad[i+1] == 'a' ) {
                for ( j = i; cad[j]; j++ ) {
                    cad[j] = cad[j+2];
                }
                i+=2;
            }
        }

      }
      else {
        Popup = Padre;
    }

    if ( tipo_menu == TM_MENUBAR ) {
        ((wxMenuBar *)Padre)->Append(Popup, cad);
      }
      else if ( tipo_menu == TM_POPUP ) {
        Padre->Append(1, cad, Popup);
    }

    int i;

    for ( i = 0; i < lista_hijos.tam(); i++ ) {
        lista_hijos[i]->crear_wxw(Popup, TM_POPUP);
    }

    return Popup;
}

#endif

//===========================================================================
//= 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.