bugfixes, bugfixes, bugfixes...

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@11388 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/mgl/app.h b/include/wx/mgl/app.h
index 8cb604c6a13879d74274d1141083ed41e8e45e24..b3b0b6ca67a522bc4916c78e5ad45215651c88b0 100644 (file)
--- a/include/wx/mgl/app.h
+++ b/include/wx/mgl/app.h
@@ -23,6 +23,7 @@
 
 class WXDLLEXPORT wxApp;
 class WXDLLEXPORT wxLog;
 
 class WXDLLEXPORT wxApp;
 class WXDLLEXPORT wxLog;

+class WXDLLEXPORT wxEventLoop;

 
 //-----------------------------------------------------------------------------
 // wxApp
 
 //-----------------------------------------------------------------------------
 // wxApp


@@ -63,6 +64,8 @@ public:
 private:
     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()
 private:
     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()

+    
+    wxEventLoop *m_mainLoop;

 };
 
 int WXDLLEXPORT wxEntry(int argc, char *argv[]);
 };
 
 int WXDLLEXPORT wxEntry(int argc, char *argv[]);

diff --git a/include/wx/mgl/dc.h b/include/wx/mgl/dc.h
index d59cec8a7bfc733bb2ed079b1f17c0c139b884cd..e37f3ff1b302cf8271f5fd63c6f44a013f26294f 100644 (file)
--- a/include/wx/mgl/dc.h
+++ b/include/wx/mgl/dc.h
@@ -269,8 +269,7 @@ protected:
     wxPalette         m_oldPalette;
     
     wxRegion          m_currentClippingRegion;
     wxPalette         m_oldPalette;
     
     wxRegion          m_currentClippingRegion;

-    // clipping region m_MGLDC had when it was attached:
-    MGLRegion        *m_globalClippingRegion;
+    wxRegion          m_globalClippingRegion;

 
     // wxDC::Blit handles memoryDCs as special cases :(
     bool              m_isMemDC;
 
     // wxDC::Blit handles memoryDCs as special cases :(
     bool              m_isMemDC;

diff --git a/src/mgl/app.cpp b/src/mgl/app.cpp
index d9288130de15ef7c4ba5ffb85d32ead7c62736b9..2027810bd55c8870597bb0b6bed5ee67ca5c81d5 100644 (file)
--- a/src/mgl/app.cpp
+++ b/src/mgl/app.cpp
@@ -28,6 +28,7 @@
 #endif
 
 #include "wx/app.h"
 #endif
 
 #include "wx/app.h"

+#include "wx/fontutil.h"

 #include "wx/mgl/private.h"
 
 //-----------------------------------------------------------------------------
 #include "wx/mgl/private.h"
 
 //-----------------------------------------------------------------------------


@@ -37,8 +38,6 @@
 wxApp *wxTheApp = NULL;
 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 
 wxApp *wxTheApp = NULL;
 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 

-static wxEventLoop *gs_mainEventLoop = NULL;
-

 
 //-----------------------------------------------------------------------------
 // wxExit
 
 //-----------------------------------------------------------------------------
 // wxExit


@@ -70,8 +69,13 @@ bool wxYield()
 
     wxLog::Suspend();
 
 
     wxLog::Suspend();
 

-    while (gs_mainEventLoop->Pending())
-        gs_mainEventLoop->Dispatch();
+    if ( wxEventLoop::GetActive() )
+    {
+        while (wxEventLoop::GetActive()->Pending())
+            wxEventLoop::GetActive()->Dispatch();
+    }
+    else
+        MGL_wmUpdateDC(g_winMng); // FIXME_MGL -- temporary hack, please remove

         
     /* it's necessary to call ProcessIdle() to update the frames sizes which
        might have been changed (it also will update other things set from
         
     /* it's necessary to call ProcessIdle() to update the frames sizes which
        might have been changed (it also will update other things set from


@@ -124,7 +128,7 @@ BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 

-wxApp::wxApp()
+wxApp::wxApp() : m_mainLoop(NULL)

 {
 }
 
 {
 }
 


@@ -227,16 +231,19 @@ bool wxApp::SendIdleEvents(wxWindow* win)
 int wxApp::MainLoop()
 {
     int rt;
 int wxApp::MainLoop()
 {
     int rt;

-    gs_mainEventLoop = new wxEventLoop;
-    rt = gs_mainEventLoop->Run();
-    delete gs_mainEventLoop;
-    gs_mainEventLoop = NULL;
+    m_mainLoop = new wxEventLoop;
+
+    rt = m_mainLoop->Run();
+
+    delete m_mainLoop;
+    m_mainLoop = NULL;

     return rt;
 }
 
 void wxApp::ExitMainLoop()
 {
     return rt;
 }
 
 void wxApp::ExitMainLoop()
 {

-    gs_mainEventLoop->Exit(0);
+    if ( m_mainLoop )
+        m_mainLoop->Exit(0);

 }
 
 bool wxApp::Initialized()
 }
 
 bool wxApp::Initialized()


@@ -248,12 +255,12 @@ bool wxApp::Initialized()
 
 bool wxApp::Pending()
 {
 
 bool wxApp::Pending()
 {

-    return gs_mainEventLoop->Pending();
+    return wxEventLoop::GetActive()->Pending();

 }
 
 void wxApp::Dispatch()
 {
 }
 
 void wxApp::Dispatch()
 {

-    gs_mainEventLoop->Dispatch();
+    wxEventLoop::GetActive()->Dispatch();

 }
 
 void wxApp::DeletePendingObjects()
 }
 
 void wxApp::DeletePendingObjects()


@@ -293,6 +300,9 @@ bool wxApp::Initialize()
 
     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
     wxTheColourDatabase->Initialize();
 
     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
     wxTheColourDatabase->Initialize();

+    
+    // Can't do this in wxModule, because fonts are needed by stock lists
+    wxTheFontsManager = new wxFontsManager;

 
     wxInitializeStockLists();
     wxInitializeStockObjects();
 
     wxInitializeStockLists();
     wxInitializeStockObjects();


@@ -358,9 +368,12 @@ void wxApp::CleanUp()
     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();
     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();

-

     wxDeleteStockLists();
 
     wxDeleteStockLists();
 

+    // Can't do this in wxModule, because fonts are needed by stock lists
+    delete wxTheFontsManager;
+    wxTheFontsManager = (wxFontsManager*) NULL;
+

     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 
     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 

diff --git a/src/mgl/bitmap.cpp b/src/mgl/bitmap.cpp
index b2489c75fd521daa3651a9bfab74550ce2667fbb..4e9e1051eb01dbe7faa9f8d32b361186c58a2fc1 100644 (file)
--- a/src/mgl/bitmap.cpp
+++ b/src/mgl/bitmap.cpp
@@ -48,10 +48,6 @@ static pixel_format_t gs_pixel_format_24 =
 static pixel_format_t gs_pixel_format_32 =
        {0xFF,0x18,0, 0xFF,0x10,0, 0xFF,0x08,0, 0xFF,0x00,0}; // RGBA 32bpp
 
 static pixel_format_t gs_pixel_format_32 =
        {0xFF,0x18,0, 0xFF,0x10,0, 0xFF,0x08,0, 0xFF,0x00,0}; // RGBA 32bpp
 

-// FIXME_MGL -- these formats will probably have to go into another place,
-//              where wxApp could use them to initialize g_displayDC
-
-

 //-----------------------------------------------------------------------------
 // wxMask
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxMask
 //-----------------------------------------------------------------------------

diff --git a/src/mgl/cursor.cpp b/src/mgl/cursor.cpp
index 1e4867ae705e74d2f025491b84e8876656924f71..eb959e8ff8c3f6dfcf16a24867fea64e90e048df 100644 (file)
--- a/src/mgl/cursor.cpp
+++ b/src/mgl/cursor.cpp
@@ -24,7 +24,7 @@
 #include "wx/log.h"
 #include "wx/intl.h"
 
 #include "wx/log.h"
 #include "wx/intl.h"
 

-#include <mgraph.hpp>
+#include "wx/mgl/private.h"

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


@@ -98,8 +98,6 @@ wxCursor::wxCursor(int cursorId)
         case wxCURSOR_BLANK:           cursorname = "blank.cur"; break;
 
         case wxCURSOR_NONE:
         case wxCURSOR_BLANK:           cursorname = "blank.cur"; break;
 
         case wxCURSOR_NONE:

-            // FIXME_MGL - make sure wxWindow uses cursor with
-            //    GetMGLCursor() == NULL correctly, i.e. calls MS_hide()

             *this = wxNullCursor;
             return;
             break;
             *this = wxNullCursor;
             return;
             break;


@@ -199,13 +197,14 @@ MGLCursor *wxCursor::GetMGLCursor() const
 // Global cursor setting
 // ----------------------------------------------------------------------------
 
 // Global cursor setting
 // ----------------------------------------------------------------------------
 

+static wxCursor  g_globalCursor = wxNullCursor;

 
 void wxSetCursor(const wxCursor& cursor)
 {
     if ( cursor.Ok() )
     {
 
 void wxSetCursor(const wxCursor& cursor)
 {
     if ( cursor.Ok() )
     {

-        //MGL_setGlobalCursor(cursor.GetMGLCursor());
-        // FIXME_MGL -- needs MGL WM first
+        MGL_wmSetGlobalCursor(g_winMng, *cursor.GetMGLCursor());
+        g_globalCursor = cursor;

     }
 }
 
     }
 }
 


@@ -215,10 +214,7 @@ void wxSetCursor(const wxCursor& cursor)
 // busy cursor routines
 //-----------------------------------------------------------------------------
 
 // busy cursor routines
 //-----------------------------------------------------------------------------
 

-// FIXME_MGL -- do we need this? It may be better to incorporate 
-//              support for it into MGL (a stack of global cursors?)
-static wxCursor  gs_savedCursor;
-static wxCursor  g_globalCursor;
+static wxCursor  gs_savedCursor = wxNullCursor;

 static int       gs_busyCount = 0;
 
 const wxCursor &wxBusyCursor::GetStoredCursor()
 static int       gs_busyCount = 0;
 
 const wxCursor &wxBusyCursor::GetStoredCursor()


@@ -237,10 +233,9 @@ void wxEndBusyCursor()
 
     wxSetCursor(gs_savedCursor);
     gs_savedCursor = wxNullCursor;
 
     wxSetCursor(gs_savedCursor);
     gs_savedCursor = wxNullCursor;

-    //wxYield(); FIXME_MGL - needed?

 }
 
 }
 

-void wxBeginBusyCursor(wxCursor *WXUNUSED(cursor))
+void wxBeginBusyCursor(wxCursor *cursor)

 {
     if ( gs_busyCount++ > 0 ) return;
 
 {
     if ( gs_busyCount++ > 0 ) return;
 


@@ -248,8 +243,10 @@ void wxBeginBusyCursor(wxCursor *WXUNUSED(cursor))
                   wxT("forgot to call wxEndBusyCursor, will leak memory") );
 
     gs_savedCursor = g_globalCursor;
                   wxT("forgot to call wxEndBusyCursor, will leak memory") );
 
     gs_savedCursor = g_globalCursor;

-    wxSetCursor(wxCursor(wxCURSOR_WAIT));
-    //wxYield(); FIXME_MGL - needed?
+    if ( cursor->Ok() )
+        wxSetCursor(*cursor);
+    else
+        wxSetCursor(wxCursor(wxCURSOR_WAIT));

 }
 
 bool wxIsBusy()
 }
 
 bool wxIsBusy()

diff --git a/src/mgl/dc.cpp b/src/mgl/dc.cpp
index 4b556de6b735d32484e8b4c2146b91c9122a29ee..c37533c8dd23da39e85aee877b156d95522e09df 100644 (file)
--- a/src/mgl/dc.cpp
+++ b/src/mgl/dc.cpp
@@ -152,16 +152,10 @@ wxDC::wxDC()
     m_OwnsMGLDC = FALSE;
     m_ok = FALSE; // must call SetMGLDevCtx() before using it
 
     m_OwnsMGLDC = FALSE;
     m_ok = FALSE; // must call SetMGLDevCtx() before using it
 

-#if 0

     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
                     (double)wxGetDisplaySizeMM().GetHeight();
     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
                     (double)wxGetDisplaySizeMM().GetHeight();

-#endif
-    // FIXME_MGL -- not in wxUniversal branch (and not implementend anyway,
-    //              hardcode it for 75dpi for now)
-    m_mm_to_pix_x = ((double)wxGetDisplaySize().GetWidth() / 75) * inches2mm;
-    m_mm_to_pix_y = ((double)wxGetDisplaySize().GetHeight() / 75) * inches2mm;

 
     m_pen = *wxBLACK_PEN;
     m_font = *wxNORMAL_FONT;
 
     m_pen = *wxBLACK_PEN;
     m_font = *wxNORMAL_FONT;


@@ -172,7 +166,6 @@ wxDC::wxDC()
     m_downloadedPatterns[0] = m_downloadedPatterns[1] = FALSE;
     
     m_mglFont = NULL;
     m_downloadedPatterns[0] = m_downloadedPatterns[1] = FALSE;
     
     m_mglFont = NULL;

-    m_globalClippingRegion = NULL;

 }
 
 
 }
 
 


@@ -180,7 +173,6 @@ wxDC::~wxDC()
 {
     if (m_OwnsMGLDC) 
         delete m_MGLDC;
 {
     if (m_OwnsMGLDC) 
         delete m_MGLDC;

-    delete m_globalClippingRegion;

 }
 
 void wxDC::SetMGLDC(MGLDevCtx *mgldc, bool OwnsMGLDC)
 }
 
 void wxDC::SetMGLDC(MGLDevCtx *mgldc, bool OwnsMGLDC)


@@ -193,11 +185,13 @@ void wxDC::SetMGLDC(MGLDevCtx *mgldc, bool OwnsMGLDC)
     
     if ( mgldc->getDC()->a.clipRegion )
     {
     
     if ( mgldc->getDC()->a.clipRegion )
     {

-        m_globalClippingRegion = new MGLRegion;
-        mgldc->getClipRegion(*m_globalClippingRegion);
+        MGLRegion clip;
+        mgldc->getClipRegion(clip);
+        m_globalClippingRegion = wxRegion(clip);
+        // FIXME_MGL -- reuse wxWindows::m_updateRegion ?
+        m_currentClippingRegion = m_globalClippingRegion;
+        m_clipping = TRUE;

     }
     }

-    else
-        m_globalClippingRegion = NULL;

     
     InitializeMGLDC();
 }
     
     InitializeMGLDC();
 }


@@ -237,13 +231,7 @@ void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
     else
         m_currentClippingRegion.Union(rect);
 
     else
         m_currentClippingRegion.Union(rect);
 

-    if ( m_globalClippingRegion )
-    {
-        m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion()
-                               & *m_globalClippingRegion);
-    }
-    else
-        m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
+    m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());

 
     m_clipping = TRUE;
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 
     m_clipping = TRUE;
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)


@@ -253,7 +241,7 @@ void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 

-    if ( region.Empty() )
+    if ( region.IsEmpty() )

     {
         DestroyClippingRegion();
         return;
     {
         DestroyClippingRegion();
         return;


@@ -282,13 +270,7 @@ void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
     else
         m_currentClippingRegion.Union(rg);
 
     else
         m_currentClippingRegion.Union(rg);
 

-    if ( m_globalClippingRegion )
-    {
-        m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion()
-                               & *m_globalClippingRegion);
-    }
-    else
-        m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
+    m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());

 
     m_clipping = TRUE;
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 
     m_clipping = TRUE;
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)


@@ -298,12 +280,18 @@ void wxDC::DestroyClippingRegion()
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
     
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
     

-    if ( m_globalClippingRegion )
-        m_MGLDC->setClipRegion(*m_globalClippingRegion);
+    if ( !m_globalClippingRegion.IsNull() )
+    {
+        m_MGLDC->setClipRegion(m_globalClippingRegion.GetMGLRegion());
+        m_currentClippingRegion = m_globalClippingRegion;
+        m_clipping = TRUE;
+    }

     else
     else

+    {

         m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex(), m_MGLDC->sizey()));
         m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex(), m_MGLDC->sizey()));

-    m_clipping = FALSE;
-    m_currentClippingRegion.Clear();    
+        m_clipping = FALSE;
+        m_currentClippingRegion.Clear();
+    }

 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------

diff --git a/src/mgl/evtloop.cpp b/src/mgl/evtloop.cpp
index 9e69b980a696dd7288ab0646f2abecc7e1c8e01e..effad7cb10c1f9c31e5fe8e34e47a51c32c44828 100644 (file)
--- a/src/mgl/evtloop.cpp
+++ b/src/mgl/evtloop.cpp
@@ -46,11 +46,11 @@ public:
             SetKeepLooping(TRUE);
         }
 
             SetKeepLooping(TRUE);
         }
 

-    // process a message
-    void ProcessEvent(event_t *evt);
+    // process an event
+    void Dispatch();

 
 

-    // generate an idle message, return TRUE if more idle time requested
-    bool SendIdleMessage();
+    // generate an idle event, return TRUE if more idle time requested
+    bool SendIdleEvent();

 
     // set/get the exit code
     void SetExitCode(int exitcode) { m_exitcode = exitcode; }
 
     // set/get the exit code
     void SetExitCode(int exitcode) { m_exitcode = exitcode; }


@@ -71,12 +71,18 @@ private:
 // wxEventLoopImpl implementation
 // ============================================================================
 
 // wxEventLoopImpl implementation
 // ============================================================================
 

-void wxEventLoopImpl::ProcessEvent(event_t *evt)
+void wxEventLoopImpl::Dispatch()

 {
 {

-    MGL_wmProcessEvent(g_winMng, evt);
+    event_t evt;
+    ibool rc;
+
+    MGL_wmUpdateDC(g_winMng);
+    
+    EVT_halt(&evt, EVT_EVERYEVT);
+    MGL_wmProcessEvent(g_winMng, &evt);

 }
 
 }
 

-bool wxEventLoopImpl::SendIdleMessage()
+bool wxEventLoopImpl::SendIdleEvent()

 {
     wxIdleEvent event;
 
 {
     wxIdleEvent event;
 


@@ -91,6 +97,8 @@ bool wxEventLoopImpl::SendIdleMessage()
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 

+wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+

 wxEventLoop::~wxEventLoop()
 {
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 wxEventLoop::~wxEventLoop()
 {
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );


@@ -107,6 +115,9 @@ int wxEventLoop::Run()
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;

+    
+    wxEventLoop *oldLoop = ms_activeLoop;
+    ms_activeLoop = this;

 
     for ( ;; )
     {
 
     for ( ;; )
     {


@@ -116,7 +127,7 @@ int wxEventLoop::Run()
 
         // generate and process idle events for as long as we don't have
         // anything else to do
 
         // generate and process idle events for as long as we don't have
         // anything else to do

-        while ( !Pending() && m_impl->SendIdleMessage() ) {}
+        while ( !Pending() && m_impl->SendIdleEvent() ) {}

 
         // a message came or no more idle processing to do, sit in Dispatch()
         // waiting for the next message
 
         // a message came or no more idle processing to do, sit in Dispatch()
         // waiting for the next message


@@ -131,6 +142,8 @@ int wxEventLoop::Run()
     delete m_impl;
     m_impl = NULL;
 
     delete m_impl;
     m_impl = NULL;
 

+    ms_activeLoop = oldLoop;
+

     return exitcode;
 }
 
     return exitcode;
 }
 


@@ -156,19 +169,6 @@ bool wxEventLoop::Dispatch()
 {
     wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") );
 
 {
     wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") );
 

-    event_t evt;
-    ibool rc;
-    
-    rc = EVT_getNext(&evt, EVT_EVERYEVT);
-    while ( !rc )
-    {
-        wxUsleep(1000);
-        if ( !m_impl->GetKeepLooping() )
-            return FALSE;
-        rc = EVT_getNext(&evt, EVT_EVERYEVT);
-    }
-
-    m_impl->ProcessEvent(&evt);
-
+    m_impl->Dispatch();

     return m_impl->GetKeepLooping();
 }
     return m_impl->GetKeepLooping();
 }

diff --git a/src/mgl/font.cpp b/src/mgl/font.cpp
index d46be6a92a8c51d7282b720a39cc79330711d279..85e934c02cd75e6a9f9d040c4afb8afab74358e9 100644 (file)
--- a/src/mgl/font.cpp
+++ b/src/mgl/font.cpp
@@ -125,6 +125,7 @@ wxFontRefData::wxFontRefData(const wxFontRefData& data)
     m_valid = data.m_valid;
     if ( m_library )
         m_library->IncRef();
     m_valid = data.m_valid;
     if ( m_library )
         m_library->IncRef();

+    wxLogTrace("mgl_font", "created fntrefdata %p, library is %p", this, m_library);

 }
 
 wxFontRefData::wxFontRefData(int size, int family, int style,
 }
 
 wxFontRefData::wxFontRefData(int size, int family, int style,


@@ -133,10 +134,12 @@ wxFontRefData::wxFontRefData(int size, int family, int style,
                              wxFontEncoding encoding)
 {
     Init(size, family, style, weight, underlined, faceName, encoding);
                              wxFontEncoding encoding)
 {
     Init(size, family, style, weight, underlined, faceName, encoding);

+    wxLogTrace("mgl_font", "created fntrefdata %p, library is %p", this, m_library);

 }
 
 wxFontRefData::~wxFontRefData()
 {
 }
 
 wxFontRefData::~wxFontRefData()
 {

+    wxLogTrace("mgl_font", "destructing fntrefdata %p, library is %p", this, m_library);

     if ( m_library )
         m_library->DecRef();
 }
     if ( m_library )
         m_library->DecRef();
 }

diff --git a/src/mgl/fontutil.cpp b/src/mgl/fontutil.cpp
index cc361b21b1cef8e655b31dea84f66d7e740d49f3..7e262908627bede47d0eef736c7037f38c51ad6e 100644 (file)
--- a/src/mgl/fontutil.cpp
+++ b/src/mgl/fontutil.cpp
@@ -21,16 +21,15 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

+    #include "wx/log.h"
+    #include "wx/fontutil.h"
+    #include "wx/fontmap.h"
+    #include "wx/tokenzr.h"
+    #include "wx/hash.h"

 #endif // PCH
 
 
 #endif // PCH
 
 

-#include "wx/fontutil.h"
-#include "wx/fontmap.h"
-#include "wx/tokenzr.h"
-#include "wx/hash.h"
-#include "wx/module.h"

 #include "wx/listimpl.cpp"
 #include "wx/listimpl.cpp"

-#include "wx/log.h"

 #include "wx/mgl/private.h"
 
 #include <mgraph.h>
 #include "wx/mgl/private.h"
 
 #include <mgraph.h>


@@ -430,24 +429,3 @@ wxMGLFontFamily *wxFontsManager::GetFamily(const wxString& name) const
 
 
 wxFontsManager *wxTheFontsManager = NULL;
 
 
 wxFontsManager *wxTheFontsManager = NULL;

-
-
-// A module that takes care of fonts DB initialization and destruction:
-
-class wxFontutilModule: public wxModule
-{
-DECLARE_DYNAMIC_CLASS(wxFontutilModule)
-public:
-    wxFontutilModule() {}
-    bool OnInit() 
-    {
-        wxTheFontsManager = new wxFontsManager;
-        return TRUE; 
-    }
-    void OnExit() 
-    { 
-        delete wxTheFontsManager;
-    }
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxFontutilModule, wxModule)

diff --git a/src/mgl/settings.cpp b/src/mgl/settings.cpp
index fc10a6bb0ece4c21110b338899cfbddce2dd27b7..bca51ecd13963999e0feb9066029612a0548341d 100644 (file)
--- a/src/mgl/settings.cpp
+++ b/src/mgl/settings.cpp
@@ -18,13 +18,13 @@
 wxColour wxSystemSettings::GetSystemColour(int WXUNUSED(index))
 {
     // FIXME_MGL
 wxColour wxSystemSettings::GetSystemColour(int WXUNUSED(index))
 {
     // FIXME_MGL

-    return wxColour(255,255,0);
+    return wxColour(0,0,0);

 }
 
 wxFont wxSystemSettings::GetSystemFont(int WXUNUSED(index))
 {
     // FIXME_MGL
 }
 
 wxFont wxSystemSettings::GetSystemFont(int WXUNUSED(index))
 {
     // FIXME_MGL

-    return wxFont(12, wxSWISS, wxNORMAL, wxNORMAL);
+    return wxFont(9, wxSWISS, wxNORMAL, wxNORMAL);

 }
 
 int wxSystemSettings::GetSystemMetric(int WXUNUSED(index))
 }
 
 int wxSystemSettings::GetSystemMetric(int WXUNUSED(index))

diff --git a/src/mgl/window.cpp b/src/mgl/window.cpp
index 210c50ec9bf4be4b0f6c67ab3ceb686f85c779e4..13556e8edf5c17c43be1e692ecba7c4b2143d258 100644 (file)
--- a/src/mgl/window.cpp
+++ b/src/mgl/window.cpp
@@ -99,6 +99,14 @@ enum
 //      with desired settings
 
 // FIXME_MGL -- move to app.cpp??
 //      with desired settings
 
 // FIXME_MGL -- move to app.cpp??

+static void wxDesktopPainter(window_t *wnd, MGLDC *dc)
+{
+    // FIXME_MGL - for now...
+    MGL_setColorRGB(0x63, 0x63, 0x96);
+    MGL_fillRectCoord(0, 0, wnd->width, wnd->height);
+}
+
+

 bool wxCreateMGL_WM()
 {
     int mode;
 bool wxCreateMGL_WM()
 {
     int mode;


@@ -106,6 +114,7 @@ bool wxCreateMGL_WM()
     int refresh = MGL_DEFAULT_REFRESH;
     
 #if wxUSE_SYSTEM_OPTIONS
     int refresh = MGL_DEFAULT_REFRESH;
     
 #if wxUSE_SYSTEM_OPTIONS

+    // FIXME_MGL -- so what is The Proper Way?

     if ( wxSystemOptions::HasOption(wxT("mgl.screen-width") )
         width = wxSystemOptions::GetOptionInt(wxT("mgl.screen-width"));
     if ( wxSystemOptions::HasOption(wxT("mgl.screen-height") )
     if ( wxSystemOptions::HasOption(wxT("mgl.screen-width") )
         width = wxSystemOptions::GetOptionInt(wxT("mgl.screen-width"));
     if ( wxSystemOptions::HasOption(wxT("mgl.screen-height") )


@@ -133,6 +142,8 @@ bool wxCreateMGL_WM()
     g_winMng = MGL_wmCreate(g_displayDC->getDC());
     if (!g_winMng)
         return FALSE;
     g_winMng = MGL_wmCreate(g_displayDC->getDC());
     if (!g_winMng)
         return FALSE;

+
+    MGL_wmSetWindowPainter(MGL_wmGetRootWindow(g_winMng), wxDesktopPainter);

     
     return TRUE;
 }
     
     return TRUE;
 }


@@ -163,14 +174,109 @@ static void wxWindowPainter(window_t *wnd, MGLDC *dc)
         MGLDevCtx ctx(dc);
         w->HandlePaint(&ctx);
     }
         MGLDevCtx ctx(dc);
         w->HandlePaint(&ctx);
     }

+    // FIXME_MGL -- root window should be a regular window so that
+    // enter/leave and activate/deactivate events work correctly
+}
+
+static ibool wxWindowMouseHandler(window_t *wnd, event_t *e)
+{
+    wxWindowMGL *win = (wxWindowMGL*)MGL_wmGetWindowUserData(wnd);
+    wxPoint where = win->ScreenToClient(wxPoint(e->where_x, e->where_y));
+    
+    wxEventType type = wxEVT_NULL;
+    wxMouseEvent event;
+    event.SetEventObject(win);
+    event.SetTimestamp(e->when);
+    event.m_x = where.x;
+    event.m_y = where.y;
+    event.m_shiftDown = e->modifiers & EVT_SHIFTKEY;
+    event.m_controlDown = e->modifiers & EVT_CTRLSTATE;
+    event.m_altDown = e->modifiers & EVT_LEFTALT;
+    event.m_metaDown = e->modifiers & EVT_RIGHTALT;
+    event.m_leftDown = e->modifiers & EVT_LEFTBUT;
+    event.m_middleDown = e->modifiers & EVT_MIDDLEBUT;
+    event.m_rightDown = e->modifiers & EVT_RIGHTBUT;
+    
+    switch (e->what)
+    {
+        case EVT_MOUSEDOWN:
+            if ( e->message & EVT_LEFTBMASK )
+                type = (e->message & EVT_DBLCLICK) ?
+                        wxEVT_LEFT_DCLICK : wxEVT_LEFT_DOWN;
+            else if ( e->message & EVT_MIDDLEBMASK )
+                type = (e->message & EVT_DBLCLICK) ?
+                        wxEVT_MIDDLE_DCLICK : wxEVT_MIDDLE_DOWN;
+            else if ( e->message & EVT_RIGHTBMASK )
+                type = (e->message & EVT_DBLCLICK) ? 
+                        wxEVT_RIGHT_DCLICK : wxEVT_RIGHT_DOWN;
+            break;
+
+        case EVT_MOUSEUP:
+            if ( e->message & EVT_LEFTBMASK )
+                type = wxEVT_LEFT_UP;
+            else if ( e->message & EVT_MIDDLEBMASK )
+                type = wxEVT_MIDDLE_UP;
+            else if ( e->message & EVT_RIGHTBMASK )
+                type = wxEVT_RIGHT_UP;
+            break;
+
+        case EVT_MOUSEMOVE:
+            if ( win != g_windowUnderMouse )
+            {
+                if ( g_windowUnderMouse )
+                {
+                    wxMouseEvent event2(event);
+                    wxPoint where2 = g_windowUnderMouse->ScreenToClient(
+                                            wxPoint(e->where_x, e->where_y));
+                    event2.m_x = where2.x;
+                    event2.m_y = where2.y;
+                    event2.SetEventObject(g_windowUnderMouse);
+                    event2.SetEventType(wxEVT_LEAVE_WINDOW);
+                    g_windowUnderMouse->GetEventHandler()->ProcessEvent(event2);
+                }
+                
+                wxMouseEvent event3(event);
+                event3.SetEventType(wxEVT_ENTER_WINDOW);
+                win->GetEventHandler()->ProcessEvent(event3);
+                
+                g_windowUnderMouse = win;
+            }
+            
+            type = wxEVT_MOTION;
+            break;
+
+        default:
+            break;
+    }
+    
+    if ( type == wxEVT_NULL )
+    {
+        return FALSE;
+    }
+    else
+    {
+        event.SetEventType(type);
+        return win->GetEventHandler()->ProcessEvent(event);
+    }
+}
+
+static ibool wxWindowKeybHandler(window_t *wnd, event_t *e)
+{
+    // FIXME_MGL
+    return FALSE;
+}
+
+static ibool wxWindowJoyHandler(window_t *wnd, event_t *e)
+{
+    // FIXME_MGL
+    return FALSE;

 }
 
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 
 }
 
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 

-// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
-// method
+// in wxUniv this class is abstract because it doesn't have DoPopupMenu()

 IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindowMGL, wxWindowBase)
 IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindowMGL, wxWindowBase)


@@ -190,9 +296,6 @@ void wxWindowMGL::Init()
     InitBase();
 
     // mgl specific:
     InitBase();
 
     // mgl specific:

-    if ( !g_winMng && !wxCreateMGL_WM() )
-        wxFatalError(_T("Can't initalize MGL, aborting!"));
-

     m_wnd = NULL;
     m_isShown = TRUE;
     m_isBeingDeleted = FALSE;
     m_wnd = NULL;
     m_isShown = TRUE;
     m_isBeingDeleted = FALSE;


@@ -208,20 +311,8 @@ wxWindowMGL::~wxWindowMGL()
 
     if ( g_focusedWindow == this )
         KillFocus();
 
     if ( g_focusedWindow == this )
         KillFocus();

-
-#if 0 // -- fixme - do we need this?
-    // VS: make sure there's no wxFrame with last focus set to us:
-    for (wxWindow *win = GetParent(); win; win = win->GetParent())
-    {
-        wxFrame *frame = wxDynamicCast(win, wxFrame);
-        if ( frame )
-        {
-            if ( frame->GetLastFocus() == this )
-                frame->SetLastFocus((wxWindow*)NULL);
-            break;
-        }
-    }
-#endif
+    if ( g_windowUnderMouse == this )
+        g_windowUnderMouse = NULL;

 
     // VS: destroy children first and _then_ detach *this from its parent.
     //     If we'd do it the other way around, children wouldn't be able
 
     // VS: destroy children first and _then_ detach *this from its parent.
     //     If we'd do it the other way around, children wouldn't be able


@@ -260,12 +351,28 @@ bool wxWindowMGL::Create(wxWindow *parent,
         m_isShown = FALSE;
     }
 
         m_isShown = FALSE;
     }
 

+    int x, y, w, h;
+    x = pos.x, y = pos.y;
+    if ( x == -1 )
+        x = 0; // FIXME_MGL, something better, see GTK+
+    if ( y == -1 )
+        y = 0; // FIXME_MGL, something better, see GTK+
+    w = WidthDefault(size.x);
+    h = HeightDefault(size.y);
+

     m_wnd = MGL_wmCreateWindow(g_winMng,
                                parent ? parent->GetHandle() : NULL,
     m_wnd = MGL_wmCreateWindow(g_winMng,
                                parent ? parent->GetHandle() : NULL,

-                               pos.x, pos.y, size.x, size.y);
-    MGL_wmShowWindow(m_wnd, m_isShown);
+                               x, y, w, h);
+

     MGL_wmSetWindowUserData(m_wnd, (void*) this);
     MGL_wmSetWindowPainter(m_wnd, wxWindowPainter);
     MGL_wmSetWindowUserData(m_wnd, (void*) this);
     MGL_wmSetWindowPainter(m_wnd, wxWindowPainter);

+    MGL_wmShowWindow(m_wnd, m_isShown);
+    MGL_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetMGLCursor());
+
+    MGL_wmPushWindowEventHandler(m_wnd, wxWindowMouseHandler, EVT_MOUSEEVT, 0);
+    MGL_wmPushWindowEventHandler(m_wnd, wxWindowKeybHandler, EVT_KEYEVT, 0);
+    MGL_wmPushWindowEventHandler(m_wnd, wxWindowJoyHandler, EVT_JOYEVT, 0);
+

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -280,7 +387,7 @@ void wxWindowMGL::SetFocus()
     
     g_focusedWindow = this;
     
     
     g_focusedWindow = this;
     

-    MGL_wmCaptureEvents(GetHandle(), EVT_KEYEVT | EVT_JOYEVT, wxMGL_CAPTURE_KEYB);
+    MGL_wmCaptureEvents(GetHandle(), EVT_KEYEVT|EVT_JOYEVT, wxMGL_CAPTURE_KEYB);

 
 #if wxUSE_CARET
     // caret needs to be informed about focus change
 
 #if wxUSE_CARET
     // caret needs to be informed about focus change


@@ -289,7 +396,7 @@ void wxWindowMGL::SetFocus()
         caret->OnSetFocus();
 #endif // wxUSE_CARET
 
         caret->OnSetFocus();
 #endif // wxUSE_CARET
 

-    if (IsTopLevel())
+    if ( IsTopLevel() )

     {
         wxActivateEvent event(wxEVT_ACTIVATE, TRUE, GetId());
         event.SetEventObject(this);
     {
         wxActivateEvent event(wxEVT_ACTIVATE, TRUE, GetId());
         event.SetEventObject(this);


@@ -389,6 +496,10 @@ bool wxWindowMGL::SetCursor(const wxCursor& cursor)
 
     if ( m_cursor.Ok() )
         MGL_wmSetWindowCursor(m_wnd, *m_cursor.GetMGLCursor());
 
     if ( m_cursor.Ok() )
         MGL_wmSetWindowCursor(m_wnd, *m_cursor.GetMGLCursor());

+    else
+        MGL_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetMGLCursor());
+    
+    // FIXME_MGL -- should it set children's cursor or not?!

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -729,7 +840,7 @@ void wxWindowMGL::HandlePaint(MGLDevCtx *dc)
         m_refreshAfterThaw = TRUE;
         return;
     }
         m_refreshAfterThaw = TRUE;
         return;
     }

-
+    

     MGLRegion clip;
     dc->getClipRegion(clip);
     m_updateRegion = wxRegion(clip);
     MGLRegion clip;
     dc->getClipRegion(clip);
     m_updateRegion = wxRegion(clip);