_wxwindows.C

Ir a la documentación de este archivo.

//===========================================================================
//= _wxwindows.C                                               Mayo de 2002 =
//=-------------------------------------------------------------------------=
//= Definicion de elementos GUI especificos a WXWINDOWS                     =
//=-------------------------------------------------------------------------=
//= 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/_wxwindows.h"
#include "lista.cc"
#include "toolkits/entorno/jed_evnt.h"

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

#ifndef WXWINDOWS_ENABLED

JED_GUI_CLASE_NULA(JED_WXWINDOWS_INTERFACE, "JED_WXWINDOWS_INTERFACE",
    "WXWINDOWS", "wxwindows", "WXWINDOWS_ENABLED");

#endif

#ifdef WXWINDOWS_ENABLED
//#define DEBUG_WXWINDOWS 1

#define TIMER_ID 1

//===========================================================================
//= CONSTANTES Y MACROS                                                     =
//===========================================================================

#define ID_NEW_WINDOW 10000

//===========================================================================
//= VARIABLES GLOBALES (INCLUYE LA INICIALIZACION DE ATRIBUTOS ESTATICOS)   =
//===========================================================================

static JED_WXWINDOWS_INTERFACE *LA_Gui = NULL;
static int GLOBAL_glwidget_id = 1; // Estos dos deben ser iguales!
static int GLOBAL_widget_id = 1;
static int X_mouse = 320;
static int Y_mouse = 240;
static int QUIERO_pintarme = 0;      // EL SUPER-CANDADO!

//---------------------------------------------------------------------------

BEGIN_EVENT_TABLE(_WXWINDOWS_GLWIDGET, wxGLCanvas)
    EVT_SIZE(_WXWINDOWS_GLWIDGET::OnSize)
    EVT_PAINT(_WXWINDOWS_GLWIDGET::OnPaint)
    EVT_ERASE_BACKGROUND(_WXWINDOWS_GLWIDGET::OnEraseBackground)
    EVT_CHAR(_WXWINDOWS_GLWIDGET::OnChar)
    EVT_KEY_DOWN(_WXWINDOWS_GLWIDGET::OnKeyDown )
    EVT_KEY_UP(_WXWINDOWS_GLWIDGET::OnKeyUp )
    EVT_MOTION(_WXWINDOWS_GLWIDGET::OnMotion )
    EVT_LEFT_DOWN(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_MIDDLE_DOWN(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_RIGHT_DOWN(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_LEFT_UP(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_MIDDLE_UP(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_RIGHT_UP(_WXWINDOWS_GLWIDGET::OnButton )
    EVT_ENTER_WINDOW(_WXWINDOWS_GLWIDGET::OnEnterWindow )
    END_EVENT_TABLE();

BEGIN_EVENT_TABLE(_WXWINDOWS_WINDOW, wxFrame)
    EVT_MENU(wxID_EXIT, _WXWINDOWS_WINDOW::OnExit)
    EVT_MENU(ID_NEW_WINDOW, _WXWINDOWS_WINDOW::OnNewWindow)
    EVT_TIMER(-1, _WXWINDOWS_WINDOW::OnTimer)
    EVT_MENU(-1, _WXWINDOWS_WINDOW::OnMenu)
    END_EVENT_TABLE();

//---------------------------------------------------------------------------

// Manejadores de las funciones callback de aplicacion (apuntadores a funcion)
static int  (*WXWINDOWSGUI_ejecutor_callback)(int idc, int context_id);
static void (*WXWINDOWSGUI_draw_callback)(int);
static int  (*WXWINDOWSGUI_tick_callback)(int);
static void (*WXWINDOWSGUI_resize_callback)(int x_tam, int y_tam, int);
static int  (*WXWINDOWSGUI_keyboard_callback)(EVENTO_GUI *e, int);
static int  (*WXWINDOWSGUI_mouse_callback)(EVENTO_GUI *e, int);
static void (*WXWINDOWSGUI_multiview_callback)(int operacion, int id_vista,
             char *detalles, char *menu, char *botonera);
static void wxwindows_idle_callback(_WXWINDOWS_GLWIDGET *w);

//===========================================================================
//= Clase _WXWINDOWS_GLWIDGET                                                =
//===========================================================================

_WXWINDOWS_GLWIDGET::_WXWINDOWS_GLWIDGET(wxWindow *parent, wxWindowID id,
                           const wxPoint& pos, const wxSize& size, 
                           long style, const wxString& name) :
    wxGLCanvas(parent, (wxGLCanvas*) NULL, id, pos, size, style, name)
{
    id_vista = GLOBAL_glwidget_id;
    GLOBAL_glwidget_id++;

#ifdef DEBUG_WXWINDOWS
    printf("<_WXWINDOWS_GLWIDGET> Creo la nueva ventana %d\n", id_vista);
    fflush(stdout);
#endif

    char menu[1024] = "1";
    char botonera[1024] = "2";
    if ( WXWINDOWSGUI_multiview_callback ) {
        WXWINDOWSGUI_multiview_callback(GUI_CREAR_VISTA, id_vista,
            "default", menu, botonera);
    }
}

_WXWINDOWS_GLWIDGET::_WXWINDOWS_GLWIDGET(wxWindow *parent, const _WXWINDOWS_GLWIDGET &other, 
                           wxWindowID id, const wxPoint& pos, 
                           const wxSize& size, long style,
                           const wxString& name ) :
    wxGLCanvas(parent, other.GetContext(), id, pos, size, style, name  )
{
    id_vista = GLOBAL_glwidget_id;
    GLOBAL_glwidget_id++;

#ifdef DEBUG_WXWINDOWS
    printf("<_WXWINDOWS_GLWIDGET> Creo la nueva ventana %d\n", id_vista);
    fflush(stdout);
#endif

    char menu[1024];
    char botonera[1024];
    if ( WXWINDOWSGUI_multiview_callback ) {
        WXWINDOWSGUI_multiview_callback(GUI_CREAR_VISTA, id_vista,
            "default", menu, botonera);
    }
}

_WXWINDOWS_GLWIDGET::~_WXWINDOWS_GLWIDGET()
{
    ;
}

void
_WXWINDOWS_GLWIDGET::OnEraseBackground(wxEraseEvent& event)
{
    // Do nothing, to avoid flashing.
}

void
_WXWINDOWS_GLWIDGET::OnEnterWindow( wxMouseEvent& event )
{
    SetFocus();
//    OnMotion(event);
}

void
_WXWINDOWS_GLWIDGET::OnMotion( wxMouseEvent& event )
{
    int x, y;

    event.GetPosition(&x, &y);

    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;

    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_MOUSE_MOVE;

    QUIERO_pintarme = WXWINDOWSGUI_mouse_callback(EVNT_EVENTO_GUI, id_vista);
}

void
_WXWINDOWS_GLWIDGET::OnButton(wxMouseEvent& event)
{
    int x, y;

    event.GetPosition(&x, &y);

    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;

    if ( event.ButtonDown(1) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_DOWN;
        EVNT_EVENTO_GUI->mouse_button_mask |= 0x01;
      }
      else if ( event.ButtonDown(2) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_DOWN;
        EVNT_EVENTO_GUI->mouse_button_mask |= 0x02;
      }
      else if ( event.ButtonDown(3) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_DOWN;
        EVNT_EVENTO_GUI->mouse_button_mask |= 0x04;
      }
      else if ( event.ButtonUp(1) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_UP;
        EVNT_EVENTO_GUI->mouse_button_mask &= ~0x01;
      }
      else if ( event.ButtonUp(2) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_UP;
        EVNT_EVENTO_GUI->mouse_button_mask &= ~0x02;
      }
      else if ( event.ButtonUp(3) ) {
        EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_BUTTON_UP;
        EVNT_EVENTO_GUI->mouse_button_mask &= ~0x04;
      }
    ; 

    QUIERO_pintarme = WXWINDOWSGUI_mouse_callback(EVNT_EVENTO_GUI, id_vista);
}

void
_WXWINDOWS_GLWIDGET::OnPaint(wxPaintEvent& event)
{
    //-----------------------------------------------------------------------
    wxPaintDC dc(this);
  #ifndef __WXMOTIF__
    if (!GetContext()) return;
  #endif
    SetCurrent();

    //-----------------------------------------------------------------------
    WXWINDOWSGUI_draw_callback(id_vista);

    //-----------------------------------------------------------------------
    glFlush();
    SwapBuffers();
}

void
_WXWINDOWS_GLWIDGET::OnSize(wxSizeEvent& event)
{
    // this is also necessary to update the context on some platforms
//    wxGLCanvas::OnSize(event);

    int width, height;
    GetClientSize(& width, & height);

  #ifndef __WXMOTIF__
    if (GetContext())
  #endif
    SetCurrent();

    //-----------------------------------------------------------------------
    WXWINDOWSGUI_resize_callback(width, height, id_vista);
}

void
_WXWINDOWS_GLWIDGET::OnKeyDown(wxKeyEvent& event)
{
#ifdef NONONO_DESCONTINUADO
    long evkey = event.KeyCode();
    if ( evkey == 0 ) return;

    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_KEY_DOWN;
    EVNT_EVENTO_GUI->key_mask = 0x00;
    WXWkeycode2JEDkeycode(EVNT_EVENTO_GUI, (int)evkey);
    QUIERO_pintarme = WXWINDOWSGUI_keyboard_callback(EVNT_EVENTO_GUI,id_vista);

    if ( QUIERO_pintarme != 0 ) {
        Refresh(FALSE);
        Update();
    }
#endif

    event.Skip();
}

void
_WXWINDOWS_GLWIDGET::OnChar(wxKeyEvent& event)
{
    long evkey = event.KeyCode();
    if ( evkey == 0 ) return;

    EVNT_EVENTO_GUI->tipo_de_evento = ETYPE_KEY_DOWN;
    EVNT_EVENTO_GUI->key_mask = 0x00;
    WXWkeycode2JEDkeycode(EVNT_EVENTO_GUI, (int)evkey);
    QUIERO_pintarme = WXWINDOWSGUI_keyboard_callback(EVNT_EVENTO_GUI,id_vista);

    if ( QUIERO_pintarme != 0 ) {
        Refresh(FALSE);
        Update();
    }

    event.Skip();
}

void
_WXWINDOWS_GLWIDGET::OnKeyUp( wxKeyEvent& event )
{
    event.Skip();
}

//===========================================================================
//= Clase _WXWINDOWS_NOTEBOOK                                                =
//===========================================================================

_WXWINDOWS_NOTEBOOK::_WXWINDOWS_NOTEBOOK(wxWindow *parent, wxWindowID id,
    const wxPoint& pos, const wxSize& size, long style)
    : wxNotebook(parent, id, pos, size, style)
{
    ;
}

wxPanel *
_WXWINDOWS_NOTEBOOK::crear_pagina(void)
{
    static int contador = 1;
    char num[5];

    wxPanel *panel = new wxPanel(this);
    sprintf(num, "%d", contador);
    AddPage(panel, wxT(num), FALSE, -1);
    contador++;
    return panel;
}

//===========================================================================
//= Clase _WXWINDOWS_WINDOW                                                  =
//===========================================================================

_WXWINDOWS_WINDOW::_WXWINDOWS_WINDOW(wxFrame *frame, const wxString& title, 
                     const wxPoint& pos, const wxSize& size, long style) 
    : wxFrame(frame, -1, title, pos, size, style), tick_timer(this, TIMER_ID)
{
    drawing_area = NULL;

    _id = GLOBAL_widget_id;
    GLOBAL_widget_id++;

    tick_timer.Start(1000/24);
    area2 = NULL;
}

void
_WXWINDOWS_WINDOW::OnTimer(wxTimerEvent& event)
{
    tick_timer.Stop();
    wxwindows_idle_callback(drawing_area);
    tick_timer.Start(1000/24);
}

void
_WXWINDOWS_WINDOW::OnExit(wxCommandEvent& event)
{
    Destroy();
}

void
_WXWINDOWS_WINDOW::OnNewWindow(wxCommandEvent& event)
{
    _WXWINDOWS_WINDOW *frame = new _WXWINDOWS_WINDOW(NULL, 
                             "AQUYNZA WXWINDOWS TEST",
                             wxPoint(50, 50), wxSize(400, 300));

    // Give it an icon
//  #ifdef __WXMSW__
//    frame->SetIcon(wxIcon("mondrian"));
//  #endif

    // Make a menubar
    wxMenu *popup;
    wxMenuBar *menubar;

    menubar = new wxMenuBar;

    popup = new wxMenu;
    popup->Append(wxID_EXIT, "&Cerrar2");
    popup->Append(ID_NEW_WINDOW, "&Nuevo2" );

    menubar->Append(popup, "&Archivo2");
    frame->SetMenuBar(menubar);
    frame->drawing_area = new _WXWINDOWS_GLWIDGET( frame, *drawing_area, -1,
                                            wxDefaultPosition, wxDefaultSize );

  #if !wxUSE_STATUSBAR
    #error "Active el soporte de barras de estatus en WXWINDOWS!"
  #endif

  #if wxUSE_STATUSBAR
    // Barra de estado
    CreateStatusBar(2);
    SetStatusText("http://www.aquynza.org");
  #endif
    
    frame->Show(TRUE);
}

void
_WXWINDOWS_WINDOW::OnMenu(wxCommandEvent& evento)
{
    //wxString s;
    //s.Printf("Se eligio la opcion #%d", evento.GetId());
    //wxMessageBox(s, "Opcion de menu ejecutada!", wxICON_INFORMATION);

    if ( !WXWINDOWSGUI_ejecutor_callback ) return;

    int cod = WXWINDOWSGUI_ejecutor_callback(evento.GetId(), _id);
    if ( cod != 0 ) QUIERO_pintarme = cod;
}

wxPanel *
_WXWINDOWS_WINDOW::crear_area_adicional(void)
{
    wxPanel *nuevo;

    if ( !area2 ) {
        area2 = new _WXWINDOWS_NOTEBOOK(panel, -1, 
          wxDefaultPosition, wxSize(240, 240));
        nuevo = area2->crear_pagina();
        panel_sizer->Remove(drawing_area);
        panel_sizer->Add(drawing_area, 1, wxGROW | wxALL, 5);
        panel_sizer->Add(area2, 0, wxGROW);
        panel_sizer->Fit(this);
//        panel_sizer->SetSizeHints(this); // Con tamano minimo...
        this->Refresh();
        this->Update();
      }
      else {
        nuevo = area2->crear_pagina();
    }

    return nuevo;
}

//===========================================================================
//= Clase _WXWINDOWS_APLICACION                                              =
//===========================================================================

void
_WXWINDOWS_APLICACION::set_gui(JED_WXWINDOWS_INTERFACE *Gui)
{
    _Gui = Gui;
}

bool
_WXWINDOWS_APLICACION::OnInit(void)
{
    //----------------------------------------------------------------------
    int x_tam = 320;
    int y_tam = 240;
    char defaultname[] = "AQUYNZA Program";
    char *cad = defaultname;

//    wxLog::SetTraceMask(wxTraceMessages);
    if ( LA_Gui ) {
        x_tam = LA_Gui->_xtam;
        y_tam = LA_Gui->_ytam;
        if ( LA_Gui->_nombre ) {
            cad = new char[strlen(LA_Gui->_nombre)+1];
            strcpy(cad, LA_Gui->_nombre);
        }
    }

    //----------------------------------------------------------------------
    _WXWINDOWS_WINDOW *marco;

    marco = new _WXWINDOWS_WINDOW(NULL, cad, 
                                 wxPoint(0, 0),
                                 wxSize(x_tam, y_tam));
    // Give it an icon
//  #ifdef wx_msw
//    marco->SetIcon(wxIcon("mondrian"));
//  #endif

    //----------------------------------------------------------------------
    GUI_MENU *Global = _Gui->resolver_menu("GLOBAL");
    wxMenuBar *menubar;
    wxMenu *popup;

    if ( _Gui->lista_menus.tam() > 0 && Global ) {
        // Ingresa a la GUI WXWINDOWS los items del menu
        menubar = Global->crear_wxw_barra(marco);
      }
      else {
        // Ingresa a la GUI WXWINDOWS algunos items por defecto
        menubar = new wxMenuBar;
        popup = new wxMenu;
        popup->Append(wxID_EXIT, "&Cerrar1");
        popup->Append(ID_NEW_WINDOW, "&Nuevo1" );
        menubar->Append(popup, "&Archivo1");
    }

    marco->SetMenuBar(menubar);

    //----------------------------------------------------------------------
    wxPanel *panelcito;
    long int i;

    marco->panel = new wxPanel(marco, -1, wxDefaultPosition, wxDefaultSize, 0);
    marco->drawing_area = new _WXWINDOWS_GLWIDGET(marco->panel, -1,
        wxDefaultPosition, wxSize(x_tam, y_tam));
    marco->area2 = NULL;
    marco->panel_sizer = new wxBoxSizer(wxHORIZONTAL);
    marco->panel_sizer->Add(marco->drawing_area, 1, wxGROW | wxALL, 1);
    marco->panel_sizer->Fit(marco);
//    marco->panel_sizer->SetSizeHints(marco); // Con tamano minimo...
    marco->panel->SetAutoLayout(TRUE);
    marco->panel->SetSizer(marco->panel_sizer);

    for ( i = 0; 
        _Gui->Controles_pendientes && i < _Gui->Controles_pendientes->tam(); 
         i++ ) {
        panelcito = marco->crear_area_adicional();
        (*_Gui->Controles_pendientes)[i]->crear_wxwindows(
            _Gui->Repositorio_pendiente, panelcito);
    }
    marco->drawing_area->SetFocus();
    //----------------------------------------------------------------------
  #if !wxUSE_STATUSBAR
    #error "Active el soporte de barras de estatus en WXWINDOWS!"
  #endif

  #if wxUSE_STATUSBAR
    // Barra de estado
    marco->CreateStatusBar(2);
    marco->SetStatusText("http://www.aquynza.org");
  #endif

    marco->Show(TRUE);
    return TRUE;
}

//===========================================================================
//= PROGRAMA DE ENTRADA                                                     =
//===========================================================================

#if PLATAFORMA == i386_LINUX_GCC
extern int wxEntry( int argc, char *argv[] ); 
#endif

static JED_WXWINDOWS_INTERFACE *MACHETE_gui = NULL;

wxApp *
crear_aplicacion_wxwindows(void)
{
    _WXWINDOWS_APLICACION *app = new _WXWINDOWS_APLICACION;

    if ( !MACHETE_gui ) {
        fprintf(stderr, "<WXWINDOWS> - ERROR: No hay GUI!\n");
        fflush(stderr);
    }

    app->set_gui(MACHETE_gui);

    return (wxApp *)app;
}

wxAppInitializer
wxTheAppInitializer((wxAppInitializerFunction)crear_aplicacion_wxwindows); 

//===========================================================================
//= CLASES UTILITARIAS WXWINDOWS                                            =
//===========================================================================

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

    friend class JED_WXWINDOWS_INTERFACE;
    friend void wxwindows_draw_callback(void);
    friend void wxwindows_wstatus_callback(int wstatus);
};

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

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

static EVENTO_GUI EVENTO_wxwindows;     // 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 LISTA<VENTANA_WXWINDOWS *> LAS_ventanas;

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

#ifdef NONONO
static void quit_callback(int /*param*/) { exit(1); }
#endif
static void pintar_nulo(int /*context_id*/) { ; }
static void resize_nulo(int /*x*/, int /*y*/, int /*context_id*/) { ; }
static int  evento_nulo(EVENTO_GUI * /*e*/, int /*context_id*/) { return 0; }

//===========================================================================
//= Funciones callback para WXWINDOWS                                       =
//===========================================================================

static void
wxwindows_idle_callback(_WXWINDOWS_GLWIDGET *w)
{
    static BOOLEAN ocupado = FALSE;

    if ( ocupado ) return;
    ocupado = TRUE;

    if ( WXWINDOWSGUI_tick_callback ) {
        int cod = WXWINDOWSGUI_tick_callback(1);
        if ( cod != 0 && QUIERO_pintarme >= 0) {
            QUIERO_pintarme = cod; 
        }
    }

    if ( QUIERO_pintarme != 0 ) {
        //wxwindows_draw_callback();
        QUIERO_pintarme = 0;
        w->Refresh(FALSE);
        w->Update();
    }

    ocupado = FALSE;
}

void
wxwindows_draw_callback(void)
{
    int i, b;

//    b = wxwindowsGetWindow();
    switch ( QUIERO_pintarme ) {
      case -1:
        for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
//            wxwindowsSetWindow(LAS_ventanas[i]->id);
            WXWINDOWSGUI_draw_callback(LAS_ventanas[i]->id);
            glFlush(); glFinish();
        }
        for ( i = 0; BUFFER_doble && i < LAS_ventanas.tam(); i++ ) {
//            wxwindowsSetWindow(LAS_ventanas[i]->id);
//            wxwindowsSwapBuffers();
        }
//        wxwindowsSetWindow(b);
        break;
      case 1:
        for ( i = 0; i < LAS_ventanas.tam(); i++ ) {
            if ( LAS_ventanas[i]->por_pintar ||
                 LAS_ventanas[i]->id == b ) {
//                wxwindowsSetWindow(LAS_ventanas[i]->id);
                WXWINDOWSGUI_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 ) {
//                wxwindowsSetWindow(LAS_ventanas[i]->id);
//                wxwindowsSwapBuffers();
                LAS_ventanas[i]->por_pintar = FALSE;
            }
        }
//        wxwindowsSetWindow(b);
        break;
      case 0: default:
        break;
    }

    QUIERO_pintarme = 0;
}

//===========================================================================
//= Clase JED_WXWINDOWS_INTERFACE                                           =
//===========================================================================

JED_WXWINDOWS_INTERFACE::JED_WXWINDOWS_INTERFACE()
{
    BUFFER_doble = TRUE;

    MACHETE_gui = this;
    WXWINDOWSGUI_draw_callback = pintar_nulo;
    WXWINDOWSGUI_tick_callback = NULL;
    WXWINDOWSGUI_mouse_callback = evento_nulo;
    WXWINDOWSGUI_keyboard_callback = evento_nulo;
    WXWINDOWSGUI_resize_callback = resize_nulo;
    WXWINDOWSGUI_multiview_callback = NULL;
    WXWINDOWSGUI_ejecutor_callback = NULL;
    Controles_pendientes = NULL;
    Repositorio_pendiente = NULL;

    _xtam = 320;
    _ytam = 240;
    _nombre = NULL;
    _Argc = 0;
    _ARgv = NULL;
    LA_Gui = this;
}

JED_WXWINDOWS_INTERFACE::~JED_WXWINDOWS_INTERFACE()
{
    ;
}

void
JED_WXWINDOWS_INTERFACE::solicitar_repintado(void)
{
    QUIERO_pintarme = -1;
}

void JED_WXWINDOWS_INTERFACE::set_draw_callback( void (*p)(int context_id) )
{ WXWINDOWSGUI_draw_callback = p; }

void JED_WXWINDOWS_INTERFACE::set_tick_callback( int (*p)(int context_id) )
{ WXWINDOWSGUI_tick_callback = p; }

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

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

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

void JED_WXWINDOWS_INTERFACE::set_ejecutor( int (*p)(int idc, int context_id) )
{ WXWINDOWSGUI_ejecutor_callback = p; }

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

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

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

#ifdef DEBUG_WXWINDOWS
    printf("<JED_WXWINDOWS_INTERFACE> Creo una interfaz inicial de %d x %d "
        "llamada \"%s\".\n", _xtam, _ytam, _nombre);
    fflush(stdout);
#endif

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

    return TRUE;
}

void
wxwindows_wstatus_callback(int wstatus)
{
    int i, id;
    VENTANA_WXWINDOWS *V = NULL;

    //----------------------------------------------------------------------
//    id = wxwindowsGetWindow();
    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
wxwindows_draw1_callback(void)
{
    WXWINDOWSGUI_draw_callback(1);
    glFlush(); glFinish();
//    wxwindowsSwapBuffers();
//    wxwindowsPostRedisplay();
}

#ifdef NONONO
void
JED_WXWINDOWS_INTERFACE::crear_ventana_wxwindows(void)
{
    //- Arma y asocia un menu para la ventana -------------------------------
    GUI_MENU *Global = resolver_menu(menu);
    int menu_wxwindows;

    if ( lista_menus.tam() > 0 && Global ) {
        //menu_wxwindows = Global->crear_wxwindows(wxwindows_menu_callback);
      }
      else {
        //menu_wxwindows = wxwindowsCreateMenu(quit_callback);
        //wxwindowsSetMenu(menu_wxwindows);
        //wxwindowsAddMenuEntry("Salir", 666);
    }

    //wxwindowsSetMenu(menu_wxwindows);
    //wxwindowsSetWindow(Nueva_ventana->id);
    //wxwindowsAttachMenu(WXWINDOWS_RIGHT_BUTTON);

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

void
JED_WXWINDOWS_INTERFACE::ejecutar(void)
{
    //-----------------------------------------------------------------------
#ifdef DEBUG_WXWINDOWS
    printf("<JED_WXWINDOWS_INTERFACE> Ejecutando interface...\n");
    fflush(stdout);
#endif
    //-----------------------------------------------------------------------
#if PLATAFORMA == i386_LINUX_GCC
    wxEntry(*_Argc, _ARgv);
#endif
#if PLATAFORMA == i386_WIN32_VC
    wxEntry(i386_WIN32_VC_instancia_actual, i386_WIN32_VC_instancia_previa,
            i386_WIN32_VC_linea_de_comandos, i386_WIN32_VC_modo_visual);
#endif
}

void
JED_WXWINDOWS_INTERFACE::finalizar(void)
{
    exit(1);
}

void
JED_WXWINDOWS_INTERFACE::solicitar_nueva_ventana(void)
{
    if ( GUI_creada ) {
//        crear_ventana_wxwindows();
      }
      else {
        PETICIONES_pendientes++;
    }
}

BOOLEAN
JED_WXWINDOWS_INTERFACE::anexar_controles(
#ifndef WXWINDOWS_ENABLED
    LISTA <CONTROL_GUI *> * /*Controles*/,
    REPOSITORIO_DE_ENTIDADES * /*Repositorio*/
#endif
#ifdef WXWINDOWS_ENABLED
  LISTA <CONTROL_GUI *> *Controles, REPOSITORIO_DE_ENTIDADES *Repositorio
#endif
)
{
#ifndef WXWINDOWS_ENABLED
    return FALSE;
#endif
#ifdef WXWINDOWS_ENABLED
    Controles_pendientes = Controles;
    Repositorio_pendiente = Repositorio;

    return TRUE;
#endif
}

#endif // WXWINDOWS_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.