Motif files added.

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

diff --git a/src/motif/accel.cpp b/src/motif/accel.cpp
new file mode 100644 (file)
index 0000000..4631022
--- /dev/null
+++ b/src/motif/accel.cpp
@@ -0,0 +1,93 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        accel.cpp
+// Purpose:     wxAcceleratorTable
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "accel.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/accel.h"
+#include "wx/string.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxAcceleratorTable, wxObject)
+#endif
+
+class WXDLLEXPORT wxAcceleratorRefData: public wxObjectRefData
+{
+    friend class WXDLLEXPORT wxAcceleratorTable;
+public:
+    wxAcceleratorRefData();
+    ~wxAcceleratorRefData();
+
+/* TODO: implementation
+    inline HACCEL GetHACCEL() const { return m_hAccel; }
+protected:
+    HACCEL      m_hAccel;
+*/
+};
+
+#define M_ACCELDATA ((wxAcceleratorRefData *)m_refData)
+
+wxAcceleratorRefData::wxAcceleratorRefData()
+{
+    // TODO
+/*
+    HACCEL      m_hAccel;
+*/
+}
+
+wxAcceleratorRefData::~wxAcceleratorRefData()
+{
+/*
+  if (m_hAccel)
+  {
+    DestroyAcceleratorTable((HACCEL) m_hAccel);
+  }
+  m_hAccel = 0 ;
+*/
+}
+
+wxAcceleratorTable::wxAcceleratorTable()
+{
+  m_refData = NULL;
+}
+
+wxAcceleratorTable::~wxAcceleratorTable()
+{
+}
+
+// Load from .rc resource
+wxAcceleratorTable::wxAcceleratorTable(const wxString& resource)
+{
+    m_refData = new wxAcceleratorRefData;
+
+/* TODO: load acelerator from resource, if appropriate for your platform
+    M_ACCELDATA->m_hAccel = hAccel;
+    M_ACCELDATA->m_ok = (hAccel != 0);
+*/
+}
+
+// Create from an array
+wxAcceleratorTable::wxAcceleratorTable(int n, wxAcceleratorEntry entries[])
+{
+    m_refData = new wxAcceleratorRefData;
+
+/* TODO: create table from entries
+ */
+}
+
+bool wxAcceleratorTable::Ok() const
+{
+    // TODO
+    return FALSE;
+}
+

diff --git a/src/motif/app.cpp b/src/motif/app.cpp
new file mode 100644 (file)
index 0000000..dc3f61a
--- /dev/null
+++ b/src/motif/app.cpp
@@ -0,0 +1,513 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        app.cpp
+// Purpose:     wxApp
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "app.h"
+#endif
+
+#include "wx/frame.h"
+#include "wx/app.h"
+#include "wx/utils.h"
+#include "wx/gdicmn.h"
+#include "wx/pen.h"
+#include "wx/brush.h"
+#include "wx/cursor.h"
+#include "wx/icon.h"
+#include "wx/palette.h"
+#include "wx/dc.h"
+#include "wx/dialog.h"
+#include "wx/msgdlg.h"
+#include "wx/log.h"
+#include "wx/module.h"
+#include "wx/memory.h"
+
+#if USE_WX_RESOURCES
+#include "wx/resource.h"
+#endif
+
+#if USE_POSTSCRIPT
+#include "wx/postscrp.h"
+#endif
+
+#include <Xm/Xm.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xresource.h>
+#include <X11/Xatom.h>
+
+#include "wx/motif/private.h"
+
+#include <string.h>
+
+extern char *wxBuffer;
+extern wxList wxPendingDelete;
+
+wxApp *wxTheApp = NULL;
+
+wxHashTable *wxWidgetHashTable = NULL;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
+BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
+    EVT_IDLE(wxApp::OnIdle)
+END_EVENT_TABLE()
+#endif
+
+long wxApp::sm_lastMessageTime = 0;
+
+bool wxApp::Initialize()
+{
+#ifdef __WXMSW__
+    wxBuffer = new char[1500];
+#else
+    wxBuffer = new char[BUFSIZ + 512];
+#endif
+
+#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT
+
+    streambuf* sBuf = new wxDebugStreamBuf;
+    ostream* oStr = new ostream(sBuf) ;
+    wxDebugContext::SetStream(oStr, sBuf);
+
+#endif
+  
+    wxClassInfo::InitializeClasses();
+
+    wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+    wxTheColourDatabase->Initialize();
+    wxInitializeStockObjects();
+
+#if USE_WX_RESOURCES
+    wxInitializeResourceSystem();
+#endif
+
+  // For PostScript printing
+#if USE_POSTSCRIPT
+    wxInitializePrintSetupData();
+    wxThePrintPaperDatabase = new wxPrintPaperDatabase;
+    wxThePrintPaperDatabase->CreateDatabase();
+#endif
+
+    wxBitmap::InitStandardHandlers();
+
+    wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
+
+    wxModule::RegisterModules();
+    wxASSERT( wxModule::InitializeModules() == TRUE );
+
+    return TRUE;
+}
+
+void wxApp::CleanUp()
+{
+    delete wxWidgetHashTable;
+    wxWidgetHashTable = NULL;
+
+    wxModule::CleanUpModules();
+
+#if USE_WX_RESOURCES
+    wxCleanUpResourceSystem();
+#endif
+
+    wxDeleteStockObjects() ;
+
+    // Destroy all GDI lists, etc.
+
+    delete wxTheBrushList;
+    wxTheBrushList = NULL;
+
+    delete wxThePenList;
+    wxThePenList = NULL;
+
+    delete wxTheFontList;
+    wxTheFontList = NULL;
+
+    delete wxTheBitmapList;
+    wxTheBitmapList = NULL;
+
+    delete wxTheColourDatabase;
+    wxTheColourDatabase = NULL;
+
+#if USE_POSTSCRIPT
+    wxInitializePrintSetupData(FALSE);
+    delete wxThePrintPaperDatabase;
+    wxThePrintPaperDatabase = NULL;
+#endif
+
+    wxBitmap::CleanUpHandlers();
+
+    delete[] wxBuffer;
+    wxBuffer = NULL;
+
+    wxClassInfo::CleanUpClasses();
+
+    // do it as the very last thing because everything else can log messages
+    wxLog::DontCreateOnDemand();
+    // do it as the very last thing because everything else can log messages
+    delete wxLog::SetActiveTarget(NULL);
+}
+
+int wxEntry( int argc, char *argv[] )
+{
+    if (!wxApp::Initialize())
+      return FALSE;
+    if (!wxTheApp)
+    {
+      if (!wxApp::GetInitializerFunction())
+      {
+        printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
+        return 0;
+      };
+    
+       wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
+    };
+  
+    if (!wxTheApp)
+    {
+      printf( "wxWindows error: wxTheApp == NULL\n" );
+      return 0;
+    };
+
+    wxTheApp->SetClassName(wxFileNameFromPath(argv[0]));
+    wxTheApp->SetAppName(wxFileNameFromPath(argv[0]));
+
+    wxTheApp->argc = argc;
+    wxTheApp->argv = argv;
+
+    // GUI-specific initialization, such as creating an app context.
+    wxTheApp->OnInitGui();
+
+    // Here frames insert themselves automatically
+    // into wxTopLevelWindows by getting created
+    // in OnInit().
+  
+    if (!wxTheApp->OnInit()) return 0;
+
+    int retValue = 0;
+  
+    if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
+
+    if (wxTheApp->GetTopWindow())
+    {
+      delete wxTheApp->GetTopWindow();
+      wxTheApp->SetTopWindow(NULL);
+    }
+  
+    wxTheApp->DeletePendingObjects();
+  
+    wxTheApp->OnExit();
+  
+    wxApp::CleanUp();
+
+    delete wxTheApp;
+    wxTheApp = NULL;
+  
+#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT
+    // At this point we want to check if there are any memory
+    // blocks that aren't part of the wxDebugContext itself,
+    // as a special case. Then when dumping we need to ignore
+    // wxDebugContext, too.
+    if (wxDebugContext::CountObjectsLeft() > 0)
+    {
+      wxTrace("There were memory leaks.\n");
+      wxDebugContext::Dump();
+      wxDebugContext::PrintStatistics();
+    }
+    wxDebugContext::SetStream(NULL, NULL);
+#endif
+  
+    return retValue;
+};
+
+// Static member initialization
+wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
+
+wxApp::wxApp()
+{
+    m_topWindow = NULL;
+    wxTheApp = this;
+    m_className = "";
+    m_wantDebugOutput = TRUE ;
+    m_appName = "";
+    argc = 0;
+    argv = NULL;
+    m_printMode = wxPRINT_POSTSCRIPT;
+    m_exitOnFrameDelete = TRUE;
+    m_auto3D = TRUE;
+
+    m_mainColormap = (WXColormap) NULL;
+    m_appContext = (WXAppContext) NULL;
+    m_topLevelWidget = (WXWidget) NULL;
+    m_maxRequestSize = 0;
+}
+
+bool wxApp::Initialized()
+{
+    if (GetTopWindow())
+      return TRUE;
+    else
+      return FALSE;
+}
+
+int wxApp::MainLoop()
+{
+    m_keepGoing = TRUE;
+
+   /*
+    * Sit around forever waiting to process X-events. Property Change
+    * event are handled special, because they have to refer to
+    * the root window rather than to a widget. therefore we can't
+    * use an Xt-eventhandler.
+    */
+
+    XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
+                 XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
+                 PropertyChangeMask);
+
+    XEvent event;
+
+    // Use this flag to allow breaking the loop via wxApp::ExitMainLoop()
+    while (m_keepGoing)
+    {
+      XtAppNextEvent( (XtAppContext) wxTheApp->GetAppContext(), &event);
+      if(event.type == PropertyNotify)
+      {
+        HandlePropertyChange((WXEvent*) &event);
+      } else
+      {
+        // Terry Gitnick <terryg@scientech.com> - 1/21/98
+         /* if resize event, don't resize until the last resize event for this
+            window is recieved. Prevents flicker as windows are resized. */
+        if (event.type == ResizeRequest)
+        {
+           Display *disp = XtDisplay((Widget) wxTheApp->GetTopLevelWidget());
+           Window win = event.xany.window;
+           XEvent report;
+ 
+           //  to avoid flicker
+           report = event;
+           while( XCheckTypedWindowEvent (disp, win, ResizeRequest, &report));
+        }
+
+        XtDispatchEvent(&event);
+
+        DeletePendingObjects();
+      }
+    }
+
+    return 0;
+}
+
+// Returns TRUE if more time is needed.
+bool wxApp::ProcessIdle()
+{
+    wxIdleEvent event;
+    event.SetEventObject(this);
+    ProcessEvent(event);
+
+    return event.MoreRequested();
+}
+
+void wxApp::ExitMainLoop()
+{
+    m_keepGoing = FALSE;
+}
+
+// Is a message/event pending?
+bool wxApp::Pending()
+{
+    XFlush(XtDisplay( (Widget) wxTheApp->GetTopLevelWidget() ));
+    return (XtAppPending( (XtAppContext) wxTheApp->GetAppContext() ) != 0) ;
+}
+
+// Dispatch a message.
+void wxApp::Dispatch()
+{
+    XtAppProcessEvent( (XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
+}
+
+// This should be redefined in a derived class for
+// handling property change events for XAtom IPC.
+void wxApp::HandlePropertyChange(WXEvent *event)
+{
+    // by default do nothing special
+    XtDispatchEvent((XEvent*) event); /* let Motif do the work */
+}
+
+void wxApp::OnIdle(wxIdleEvent& event)
+{
+    static bool inOnIdle = FALSE;
+
+    // Avoid recursion (via ProcessEvent default case)
+    if (inOnIdle)
+      return;
+
+    inOnIdle = TRUE;
+
+    // 'Garbage' collection of windows deleted with Close().
+    DeletePendingObjects();
+
+    // flush the logged messages if any
+    wxLog *pLog = wxLog::GetActiveTarget();
+    if ( pLog != NULL && pLog->HasPendingMessages() )
+      pLog->Flush();
+
+    // Send OnIdle events to all windows
+    bool needMore = SendIdleEvents();
+
+    if (needMore)
+      event.RequestMore(TRUE);
+
+    inOnIdle = FALSE;
+}
+
+// Send idle event to all top-level windows
+bool wxApp::SendIdleEvents()
+{
+    bool needMore = FALSE;
+       wxNode* node = wxTopLevelWindows.First();
+       while (node)
+       {
+               wxWindow* win = (wxWindow*) node->Data();
+               if (SendIdleEvents(win))
+            needMore = TRUE;
+
+               node = node->Next();
+       }
+    return needMore;
+}
+
+// Send idle event to window and all subwindows
+bool wxApp::SendIdleEvents(wxWindow* win)
+{
+    bool needMore = FALSE;
+
+       wxIdleEvent event;
+       event.SetEventObject(win);
+       win->ProcessEvent(event);
+
+    if (event.MoreRequested())
+        needMore = TRUE;
+
+       wxNode* node = win->GetChildren()->First();
+       while (node)
+       {
+               wxWindow* win = (wxWindow*) node->Data();
+               if (SendIdleEvents(win))
+            needMore = TRUE;
+
+               node = node->Next();
+       }
+    return needMore ;
+}
+
+void wxApp::DeletePendingObjects()
+{
+    wxNode *node = wxPendingDelete.First();
+    while (node)
+    {
+      wxObject *obj = (wxObject *)node->Data();
+    
+      delete obj;
+
+      if (wxPendingDelete.Member(obj))
+        delete node;
+
+      // Deleting one object may have deleted other pending
+      // objects, so start from beginning of list again.
+      node = wxPendingDelete.First();
+    }
+}
+
+wxLog* wxApp::CreateLogTarget()
+{
+    return new wxLogGui;
+}
+
+wxWindow* wxApp::GetTopWindow() const
+{
+    if (m_topWindow)
+        return m_topWindow;
+    else if (wxTopLevelWindows.Number() > 0)
+        return (wxWindow*) wxTopLevelWindows.First()->Data();
+    else
+        return NULL;
+}
+
+// Create an application context
+bool wxApp::OnInitGui()
+{
+    XtToolkitInitialize() ;
+    wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext() ;
+    Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,(String)NULL,NULL,
+                            (const char*) wxTheApp->GetClassName(), NULL,
+# if XtSpecificationRelease < 5
+                            0,(Cardinal*) &argc,argv) ;
+# else
+                            0,&argc,argv) ;
+# endif
+    if (!dpy) {
+      cerr << "wxWindows could not open display for " << wxTheApp->GetClassName() << ": exiting.\n";
+      exit(-1);
+    }
+    wxTheApp->m_topLevelWidget = (WXWidget) XtAppCreateShell((String)NULL, (const char*) wxTheApp->GetClassName(),
+                                     applicationShellWidgetClass,dpy,
+                                     NULL,0) ;
+
+    // Add general resize proc
+    XtActionsRec rec;
+    rec.string = "resize";
+    rec.proc = (XtActionProc)wxWidgetResizeProc;
+    XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);
+
+    GetMainColormap(dpy);
+    m_maxRequestSize = XMaxRequestSize((Display*) dpy);
+
+    return TRUE;
+}
+
+WXColormap wxApp::GetMainColormap(WXDisplay* display)
+{
+    if (!display) /* Must be called first with non-NULL display */
+      return m_mainColormap;
+
+    Colormap c =
+      DefaultColormapOfScreen(XScreenOfDisplay((Display*) display,
+                                            DefaultScreen((Display*) display)));
+
+    if (!m_mainColormap)
+      m_mainColormap = (WXColormap) c;
+
+    return (WXColormap) c;
+}
+
+void wxExit()
+{
+    int retValue = 0;
+    if (wxTheApp)
+      retValue = wxTheApp->OnExit();
+
+    wxApp::CleanUp();
+    /*
+     * Exit in some platform-specific way. Not recommended that the app calls this:
+     * only for emergencies.
+     */
+    exit(retValue);
+}
+
+// Yield to other processes
+bool wxYield()
+{
+    while (wxTheApp && wxTheApp->Pending())
+      wxTheApp->Dispatch();
+    return TRUE;
+}
+

diff --git a/src/motif/bitmap.cpp b/src/motif/bitmap.cpp
new file mode 100644 (file)
index 0000000..ed30fc8
--- /dev/null
+++ b/src/motif/bitmap.cpp
@@ -0,0 +1,430 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        bitmap.cpp
+// Purpose:     wxBitmap
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "bitmap.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/utils.h"
+#include "wx/palette.h"
+#include "wx/bitmap.h"
+#include "wx/icon.h"
+#include "wx/log.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
+IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
+#endif
+
+wxBitmapRefData::wxBitmapRefData()
+{
+    m_ok = FALSE;
+    m_width = 0;
+    m_height = 0;
+    m_depth = 0;
+    m_quality = 0;
+    m_numColors = 0;
+    m_bitmapMask = NULL;
+}
+
+wxBitmapRefData::~wxBitmapRefData()
+{
+    /*
+     * TODO: delete the bitmap data here.
+     */
+
+    if (m_bitmapMask)
+        delete m_bitmapMask;
+    m_bitmapMask = NULL;
+}
+
+wxList wxBitmap::sm_handlers;
+
+wxBitmap::wxBitmap()
+{
+    m_refData = NULL;
+
+    if ( wxTheBitmapList )
+        wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::~wxBitmap()
+{
+    if (wxTheBitmapList)
+        wxTheBitmapList->DeleteObject(this);
+}
+
+wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
+{
+    m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_width = the_width ;
+    M_BITMAPDATA->m_height = the_height ;
+    M_BITMAPDATA->m_depth = no_bits ;
+    M_BITMAPDATA->m_numColors = 0;
+
+    /* TODO: create the bitmap from data */
+
+    if ( wxTheBitmapList )
+        wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::wxBitmap(int w, int h, int d)
+{
+    (void)Create(w, h, d);
+
+    if ( wxTheBitmapList )
+        wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
+{
+    (void) Create(data, type, width, height, depth);
+
+    if ( wxTheBitmapList )
+        wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::wxBitmap(const wxString& filename, long type)
+{
+    LoadFile(filename, (int)type);
+
+    if ( wxTheBitmapList )
+        wxTheBitmapList->AddBitmap(this);
+}
+
+/* TODO: maybe allow creation from XPM
+// Create from data
+wxBitmap::wxBitmap(const char **data)
+{
+    (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+}
+*/
+
+bool wxBitmap::Create(int w, int h, int d)
+{
+    UnRef();
+
+    m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_width = w;
+    M_BITMAPDATA->m_height = h;
+    M_BITMAPDATA->m_depth = d;
+
+    /* TODO: create new bitmap */
+
+    return M_BITMAPDATA->m_ok;
+}
+
+bool wxBitmap::LoadFile(const wxString& filename, long type)
+{
+    UnRef();
+
+    m_refData = new wxBitmapRefData;
+
+    wxBitmapHandler *handler = FindHandler(type);
+
+    if ( handler == NULL ) {
+        wxLogWarning("no bitmap handler for type %d defined.", type);
+
+        return FALSE;
+    }
+
+    return handler->LoadFile(this, filename, type, -1, -1);
+}
+
+bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
+{
+    UnRef();
+
+    m_refData = new wxBitmapRefData;
+
+    wxBitmapHandler *handler = FindHandler(type);
+
+    if ( handler == NULL ) {
+        wxLogWarning("no bitmap handler for type %d defined.", type);
+
+        return FALSE;
+    }
+
+    return handler->Create(this, data, type, width, height, depth);
+}
+
+bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
+{
+    wxBitmapHandler *handler = FindHandler(type);
+
+    if ( handler == NULL ) {
+        wxLogWarning("no bitmap handler for type %d defined.", type);
+
+        return FALSE;
+  }
+
+  return handler->SaveFile(this, filename, type, palette);
+}
+
+void wxBitmap::SetWidth(int w)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_width = w;
+}
+
+void wxBitmap::SetHeight(int h)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_height = h;
+}
+
+void wxBitmap::SetDepth(int d)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_depth = d;
+}
+
+void wxBitmap::SetQuality(int q)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_quality = q;
+}
+
+void wxBitmap::SetOk(bool isOk)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_ok = isOk;
+}
+
+void wxBitmap::SetPalette(const wxPalette& palette)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_bitmapPalette = palette ;
+}
+
+void wxBitmap::SetMask(wxMask *mask)
+{
+    if (!M_BITMAPDATA)
+        m_refData = new wxBitmapRefData;
+
+    M_BITMAPDATA->m_bitmapMask = mask ;
+}
+
+void wxBitmap::AddHandler(wxBitmapHandler *handler)
+{
+    sm_handlers.Append(handler);
+}
+
+void wxBitmap::InsertHandler(wxBitmapHandler *handler)
+{
+    sm_handlers.Insert(handler);
+}
+
+bool wxBitmap::RemoveHandler(const wxString& name)
+{
+    wxBitmapHandler *handler = FindHandler(name);
+    if ( handler )
+    {
+        sm_handlers.DeleteObject(handler);
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
+{
+    wxNode *node = sm_handlers.First();
+    while ( node )
+    {
+        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+        if ( handler->GetName() == name )
+            return handler;
+        node = node->Next();
+    }
+    return NULL;
+}
+
+wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
+{
+    wxNode *node = sm_handlers.First();
+    while ( node )
+    {
+        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+        if ( handler->GetExtension() == extension &&
+                    (bitmapType == -1 || handler->GetType() == bitmapType) )
+            return handler;
+        node = node->Next();
+    }
+    return NULL;
+}
+
+wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
+{
+    wxNode *node = sm_handlers.First();
+    while ( node )
+    {
+        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+        if (handler->GetType() == bitmapType)
+            return handler;
+        node = node->Next();
+    }
+    return NULL;
+}
+
+/*
+ * wxMask
+ */
+
+wxMask::wxMask()
+{
+/* TODO
+    m_maskBitmap = 0;
+*/
+}
+
+// Construct a mask from a bitmap and a colour indicating
+// the transparent area
+wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
+{
+/* TODO
+    m_maskBitmap = 0;
+*/
+    Create(bitmap, colour);
+}
+
+// Construct a mask from a bitmap and a palette index indicating
+// the transparent area
+wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
+{
+/* TODO
+    m_maskBitmap = 0;
+*/
+
+    Create(bitmap, paletteIndex);
+}
+
+// Construct a mask from a mono bitmap (copies the bitmap).
+wxMask::wxMask(const wxBitmap& bitmap)
+{
+/* TODO
+    m_maskBitmap = 0;
+*/
+
+    Create(bitmap);
+}
+
+wxMask::~wxMask()
+{
+// TODO: delete mask bitmap
+}
+
+// Create a mask from a mono bitmap (copies the bitmap).
+bool wxMask::Create(const wxBitmap& bitmap)
+{
+// TODO
+    return FALSE;
+}
+
+// Create a mask from a bitmap and a palette index indicating
+// the transparent area
+bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
+{
+// TODO
+    return FALSE;
+}
+
+// Create a mask from a bitmap and a colour indicating
+// the transparent area
+bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
+{
+// TODO
+    return FALSE;
+}
+
+/*
+ * wxBitmapHandler
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+
+bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
+{
+    return FALSE;
+}
+
+bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
+        int desiredWidth, int desiredHeight)
+{
+    return FALSE;
+}
+
+bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
+{
+    return FALSE;
+}
+
+/*
+ * Standard handlers
+ */
+
+/* TODO: bitmap handlers, a bit like this:
+class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
+{
+    DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
+public:
+    inline wxBMPResourceHandler()
+    {
+        m_name = "Windows bitmap resource";
+        m_extension = "";
+        m_type = wxBITMAP_TYPE_BMP_RESOURCE;
+    };
+
+    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+          int desiredWidth, int desiredHeight);
+};
+IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
+*/
+
+void wxBitmap::CleanUpHandlers()
+{
+    wxNode *node = sm_handlers.First();
+    while ( node )
+    {
+        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+        wxNode *next = node->Next();
+        delete handler;
+        delete node;
+        node = next;
+    }
+}
+
+void wxBitmap::InitStandardHandlers()
+{
+/* TODO: initialize all standard bitmap or derive class handlers here.
+    AddHandler(new wxBMPResourceHandler);
+    AddHandler(new wxBMPFileHandler);
+    AddHandler(new wxXPMFileHandler);
+    AddHandler(new wxXPMDataHandler);
+    AddHandler(new wxICOResourceHandler);
+    AddHandler(new wxICOFileHandler);
+*/
+}

diff --git a/src/motif/bmpbuttn.cpp b/src/motif/bmpbuttn.cpp
new file mode 100644 (file)
index 0000000..96bb57b
--- /dev/null
+++ b/src/motif/bmpbuttn.cpp
@@ -0,0 +1,65 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        bmpbuttn.cpp
+// Purpose:     wxBitmapButton
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "bmpbuttn.h"
+#endif
+
+#include "wx/bmpbuttn.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
+#endif
+
+bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    m_buttonBitmap = bitmap;
+    SetName(name);
+    SetValidator(validator);
+    parent->AddChild(this);
+
+    m_backgroundColour = parent->GetDefaultBackgroundColour() ;
+    m_foregroundColour = parent->GetDefaultForegroundColour() ;
+    m_windowStyle = style;
+    m_marginX = 0;
+    m_marginY = 0;
+
+    int x = pos.x;
+    int y = pos.y;
+    int width = size.x;
+    int height = size.y;
+
+    if (id == -1)
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    if ( width == -1 && bitmap.Ok())
+       width = bitmap.GetWidth() + 2*m_marginX;
+
+    if ( height == -1 && bitmap.Ok())
+       height = bitmap.GetHeight() + 2*m_marginY;
+
+    /* TODO: create bitmap button
+     */
+
+    return FALSE;
+}
+
+void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap)
+{
+    m_buttonBitmap = bitmap;
+}
+

diff --git a/src/motif/brush.cpp b/src/motif/brush.cpp
new file mode 100644 (file)
index 0000000..45a73b7
--- /dev/null
+++ b/src/motif/brush.cpp
@@ -0,0 +1,162 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        brush.cpp
+// Purpose:     wxBrush
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "brush.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/utils.h"
+#include "wx/brush.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
+#endif
+
+wxBrushRefData::wxBrushRefData()
+{
+    m_style = wxSOLID;
+// TODO: null data
+}
+
+wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
+{
+  m_style = data.m_style;
+  m_stipple = data.m_stipple;
+  m_colour = data.m_colour;
+/* TODO: null data
+  m_hBrush = 0;
+*/
+}
+
+wxBrushRefData::~wxBrushRefData()
+{
+// TODO: delete data
+}
+
+// Brushes
+wxBrush::wxBrush()
+{
+    if ( wxTheBrushList )
+        wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::~wxBrush()
+{
+    if ( wxTheBrushList )
+        wxTheBrushList->RemoveBrush(this);
+}
+
+wxBrush::wxBrush(const wxColour& col, int Style)
+{
+    m_refData = new wxBrushRefData;
+
+    M_BRUSHDATA->m_colour = col;
+    M_BRUSHDATA->m_style = Style;
+
+    RealizeResource();
+
+    if ( wxTheBrushList )
+        wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::wxBrush(const wxString& col, int Style)
+{
+    m_refData = new wxBrushRefData;
+
+    // Implicit conversion from string to wxColour via colour database
+    M_BRUSHDATA->m_colour = col;
+    M_BRUSHDATA->m_style = Style;
+
+    RealizeResource();
+
+    if ( wxTheBrushList )
+        wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::wxBrush(const wxBitmap& stipple)
+{
+    m_refData = new wxBrushRefData;
+
+    M_BRUSHDATA->m_style = wxSTIPPLE;
+    M_BRUSHDATA->m_stipple = stipple;
+
+    RealizeResource();
+
+    if ( wxTheBrushList )
+        wxTheBrushList->AddBrush(this);
+}
+
+void wxBrush::Unshare()
+{
+       // Don't change shared data
+       if (!m_refData)
+    {
+               m_refData = new wxBrushRefData();
+       }
+    else
+    {
+               wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
+               UnRef();
+               m_refData = ref;
+       }
+}
+
+void wxBrush::SetColour(const wxColour& col)
+{
+    Unshare();
+
+    M_BRUSHDATA->m_colour = col;
+
+    RealizeResource();
+}
+
+void wxBrush::SetColour(const wxString& col)
+{
+    Unshare();
+
+    M_BRUSHDATA->m_colour = col;
+
+    RealizeResource();
+}
+
+void wxBrush::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
+{
+    Unshare();
+
+    M_BRUSHDATA->m_colour.Set(r, g, b);
+
+    RealizeResource();
+}
+
+void wxBrush::SetStyle(int Style)
+{
+    Unshare();
+
+    M_BRUSHDATA->m_style = Style;
+
+    RealizeResource();
+}
+
+void wxBrush::SetStipple(const wxBitmap& Stipple)
+{
+    Unshare();
+
+    M_BRUSHDATA->m_stipple = Stipple;
+
+    RealizeResource();
+}
+
+void wxBrush::RealizeResource()
+{
+// TODO: create the brush
+}
+

diff --git a/src/motif/button.cpp b/src/motif/button.cpp
new file mode 100644 (file)
index 0000000..d7cdab1
--- /dev/null
+++ b/src/motif/button.cpp
@@ -0,0 +1,75 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        button.cpp
+// Purpose:     wxButton
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "button.h"
+#endif
+
+#include "wx/button.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
+#endif
+
+// Button
+
+bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString& label,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_windowStyle = style;
+
+    parent->AddChild((wxButton *)this);
+
+    if (id == -1)
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    // TODO: create button
+
+    return FALSE;
+}
+
+void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxButton::SetDefault()
+{
+    wxWindow *parent = (wxWindow *)GetParent();
+    if (parent)
+        parent->SetDefaultItem(this);
+
+    // TODO: make button the default
+}
+
+wxString wxButton::GetLabel() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxButton::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+void wxButton::Command (wxCommandEvent & event)
+{
+    ProcessCommand (event);
+}
+

diff --git a/src/motif/checkbox.cpp b/src/motif/checkbox.cpp
new file mode 100644 (file)
index 0000000..8755f5d
--- /dev/null
+++ b/src/motif/checkbox.cpp
@@ -0,0 +1,117 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        checkbox.cpp
+// Purpose:     wxCheckBox
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "checkbox.h"
+#endif
+
+#include "wx/checkbox.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
+#endif
+
+// Single check box item
+bool wxCheckBox::Create(wxWindow *parent, wxWindowID id, const wxString& label,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    // TODO: create checkbox
+
+    return FALSE;
+}
+
+void wxCheckBox::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxCheckBox::SetValue(bool val)
+{
+    // TODO
+}
+
+bool wxCheckBox::GetValue() const
+{
+    // TODO
+    return FALSE;
+}
+
+void wxCheckBox::Command (wxCommandEvent & event)
+{
+    SetValue ((event.GetInt() != 0));
+    ProcessCommand (event);
+}
+
+// Bitmap checkbox
+bool wxBitmapCheckBox::Create(wxWindow *parent, wxWindowID id, const wxBitmap *label,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    // TODO: Create the bitmap checkbox
+
+    return FALSE;
+}
+
+void wxBitmapCheckBox::SetLabel(const wxBitmap *bitmap)
+{
+    // TODO
+}
+
+void wxBitmapCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxBitmapCheckBox::SetValue(bool val)
+{
+    // TODO
+}
+
+bool wxBitmapCheckBox::GetValue() const
+{
+    // TODOD
+    return FALSE;
+}
+
+

diff --git a/src/motif/checklst.cpp b/src/motif/checklst.cpp
new file mode 100644 (file)
index 0000000..00a5676
--- /dev/null
+++ b/src/motif/checklst.cpp
@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        checklst.cpp
+// Purpose:     implementation of wxCheckListBox class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// headers & declarations
+// ============================================================================
+
+#ifdef __GNUG__
+#pragma implementation "checklst.h"
+#endif
+
+#include "wx/checklst.h"
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+#if !USE_SHARED_LIBRARY
+  IMPLEMENT_DYNAMIC_CLASS(wxCheckListBox, wxListBox)
+#endif
+
+// ----------------------------------------------------------------------------
+// implementation of wxCheckListBox class
+// ----------------------------------------------------------------------------
+
+// define event table
+// ------------------
+BEGIN_EVENT_TABLE(wxCheckListBox, wxListBox)
+END_EVENT_TABLE()
+
+// control creation
+// ----------------
+
+// def ctor: use Create() to really create the control
+wxCheckListBox::wxCheckListBox() : wxListBox()
+{
+}
+
+// ctor which creates the associated control
+wxCheckListBox::wxCheckListBox(wxWindow *parent, wxWindowID id,
+                               const wxPoint& pos, const wxSize& size,
+                               int nStrings, const wxString choices[],
+                               long style, const wxValidator& val,
+                               const wxString& name)
+              : wxListBox()
+{
+    // TODO: you'll probably need a separate Create instead of using
+    // the wxListBox one as here.
+    Create(parent, id, pos, size, nStrings, choices, style|wxLB_OWNERDRAW, val, name);
+}
+
+// check items
+// -----------
+
+bool wxCheckListBox::IsChecked(uint uiIndex) const
+{
+    // TODO
+    return FALSE;
+}
+
+void wxCheckListBox::Check(uint uiIndex, bool bCheck)
+{
+    // TODO
+}
+
+

diff --git a/src/motif/choice.cpp b/src/motif/choice.cpp
new file mode 100644 (file)
index 0000000..9ba26a3
--- /dev/null
+++ b/src/motif/choice.cpp
@@ -0,0 +1,119 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        choice.cpp
+// Purpose:     wxChoice
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "choice.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/choice.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
+#endif
+
+bool wxChoice::Create(wxWindow *parent, wxWindowID id,
+           const wxPoint& pos,
+           const wxSize& size,
+                  int n, const wxString choices[],
+                  long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_noStrings = n;
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+       m_windowId = (int)NewControlId();
+    else
+       m_windowId = id;
+
+    // TODO: create choice control
+    return FALSE;
+}
+
+void wxChoice::Append(const wxString& item)
+{
+    // TODO
+    m_noStrings ++;
+}
+
+void wxChoice::Delete(int n)
+{
+    // TODO
+    m_noStrings --;
+}
+
+void wxChoice::Clear()
+{
+    // TODO
+    m_noStrings = 0;
+}
+
+int wxChoice::GetSelection() const
+{
+    // TODO
+    return 0;
+}
+
+void wxChoice::SetSelection(int n)
+{
+    // TODO
+}
+
+int wxChoice::FindString(const wxString& s) const
+{
+    // TODO
+    return 0;
+}
+
+wxString wxChoice::GetString(int n) const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxChoice::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+wxString wxChoice::GetStringSelection () const
+{
+    int sel = GetSelection ();
+    if (sel > -1)
+        return wxString(this->GetString (sel));
+    else
+        return wxString("");
+}
+
+bool wxChoice::SetStringSelection (const wxString& s)
+{
+    int sel = FindString (s);
+    if (sel > -1)
+        {
+            SetSelection (sel);
+            return TRUE;
+        }
+    else
+        return FALSE;
+}
+
+void wxChoice::Command(wxCommandEvent & event)
+{
+    SetSelection (event.GetInt());
+    ProcessCommand (event);
+}
+

diff --git a/src/motif/clipbrd.cpp b/src/motif/clipbrd.cpp
new file mode 100644 (file)
index 0000000..e22f9f8
--- /dev/null
+++ b/src/motif/clipbrd.cpp
@@ -0,0 +1,237 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        clipbrd.cpp
+// Purpose:     Clipboard functionality
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma implementation "clipbrd.h"
+#endif
+
+#include "wx/app.h"
+#include "wx/frame.h"
+#include "wx/bitmap.h"
+#include "wx/utils.h"
+#include "wx/metafile.h"
+#include "wx/clipbrd.h"
+
+#include <string.h>
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
+#endif
+
+bool wxOpenClipboard()
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxCloseClipboard()
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxEmptyClipboard()
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxClipboardOpen()
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxIsClipboardFormatAvailable(int dataFormat)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxSetClipboardData(int dataFormat, wxObject *obj, int width, int height)
+{
+    // TODO
+    return FALSE;
+}
+
+wxObject *wxGetClipboardData(int dataFormat, long *len)
+{
+    // TODO
+    return NULL;
+}
+
+int  wxEnumClipboardFormats(int dataFormat)
+{
+    // TODO
+    return 0;
+}
+
+int  wxRegisterClipboardFormat(char *formatName)
+{
+    // TODO
+    return 0;
+}
+
+bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount)
+{
+    // TODO
+    return FALSE;
+}
+
+/*
+ * Generalized clipboard implementation by Matthew Flatt
+ */
+
+wxClipboard *wxTheClipboard = NULL;
+
+void wxInitClipboard()
+{
+  if (!wxTheClipboard)
+    wxTheClipboard = new wxClipboard;
+}
+
+wxClipboard::wxClipboard()
+{
+  clipOwner = NULL;
+  cbString = NULL;
+}
+
+wxClipboard::~wxClipboard()
+{
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  if (cbString)
+    delete[] cbString;
+}
+
+static int FormatStringToID(char *str)
+{
+  if (!strcmp(str, "TEXT"))
+    return wxDF_TEXT;
+
+  return wxRegisterClipboardFormat(str);
+}
+
+void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
+{
+  bool got_selection;
+
+  if (clipOwner)
+    clipOwner->BeingReplaced();
+  clipOwner = client;
+  if (cbString) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+
+  if (wxOpenClipboard()) {
+    char **formats, *data;
+         int i;
+    int ftype;
+    long size;
+
+    formats = clipOwner->formats.ListToArray(FALSE);
+    for (i = clipOwner->formats.Number(); i--; ) {
+      ftype = FormatStringToID(formats[i]);
+      data = clipOwner->GetData(formats[i], &size);
+      if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
+        got_selection = FALSE;
+        break;
+      }
+    }
+
+    if (i < 0)
+      got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+  
+  got_selection = FALSE; // Assume another process takes over
+
+  if (!got_selection) {
+    clipOwner->BeingReplaced();
+         clipOwner = NULL;
+  }
+}
+
+wxClipboardClient *wxClipboard::GetClipboardClient()
+{
+  return clipOwner;
+}
+
+void wxClipboard::SetClipboardString(char *str, long time)
+{
+  bool got_selection;
+
+  if (clipOwner) {
+    clipOwner->BeingReplaced();
+    clipOwner = NULL;
+  }
+  if (cbString)
+    delete[] cbString;
+
+  cbString = str;
+
+  if (wxOpenClipboard()) {
+    if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
+      got_selection = FALSE;
+    else
+                got_selection = wxCloseClipboard();
+  } else
+    got_selection = FALSE;
+
+  got_selection = FALSE; // Assume another process takes over
+
+  if (!got_selection) {
+    delete[] cbString;
+    cbString = NULL;
+  }
+}
+
+char *wxClipboard::GetClipboardString(long time)
+{
+  char *str;
+  long length;
+
+  str = GetClipboardData("TEXT", &length, time);
+  if (!str) {
+    str = new char[1];
+    *str = 0;
+  }
+
+  return str;
+}
+
+char *wxClipboard::GetClipboardData(char *format, long *length, long time)
+{
+  if (clipOwner)  {
+         if (clipOwner->formats.Member(format))
+      return clipOwner->GetData(format, length);
+    else
+      return NULL;
+  } else if (cbString) {
+    if (!strcmp(format, "TEXT"))
+      return copystring(cbString);
+    else
+      return NULL;
+  } else {
+    if (wxOpenClipboard()) {
+      receivedString = (char *)wxGetClipboardData(FormatStringToID(format), 
+                                                  length);
+      wxCloseClipboard();
+    } else
+      receivedString = NULL;
+
+    return receivedString;
+  }
+}
+

diff --git a/src/motif/colordlg.cpp b/src/motif/colordlg.cpp
new file mode 100644 (file)
index 0000000..784dc76
--- /dev/null
+++ b/src/motif/colordlg.cpp
@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        colordlg.cpp
+// Purpose:     wxColourDialog class. NOTE: you can use the generic class
+//              if you wish, instead of implementing this.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "colordlg.h"
+#endif
+
+#include "wx/stubs/colordlg.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxColourDialog, wxDialog)
+#endif
+
+/*
+ * wxColourDialog
+ */
+
+wxColourDialog::wxColourDialog()
+{
+    m_dialogParent = NULL;
+}
+
+wxColourDialog::wxColourDialog(wxWindow *parent, wxColourData *data)
+{
+    Create(parent, data);
+}
+
+bool wxColourDialog::Create(wxWindow *parent, wxColourData *data)
+{
+    m_dialogParent = parent;
+  
+    if (data)
+        m_colourData = *data;
+    return TRUE;
+}
+
+int wxColourDialog::ShowModal()
+{
+    /* TODO: implement dialog
+     */
+
+    return wxID_CANCEL;
+}
+

diff --git a/src/motif/colour.cpp b/src/motif/colour.cpp
new file mode 100644 (file)
index 0000000..a6b5b66
--- /dev/null
+++ b/src/motif/colour.cpp
@@ -0,0 +1,126 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        colour.cpp
+// Purpose:     wxColour class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "colour.h"
+#endif
+
+#include "wx/gdicmn.h"
+#include "wx/colour.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
+#endif
+
+// Colour
+
+wxColour::wxColour ()
+{
+    m_isInit = FALSE;
+    m_red = m_blue = m_green = 0;
+/* TODO
+    m_pixel = 0;
+*/
+}
+
+wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
+{
+    m_red = r;
+    m_green = g;
+    m_blue = b;
+    m_isInit = TRUE;
+/* TODO
+    m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}
+
+wxColour::wxColour (const wxColour& col)
+{
+    m_red = col.m_red;
+    m_green = col.m_green;
+    m_blue = col.m_blue;
+    m_isInit = col.m_isInit;
+/* TODO
+    m_pixel = col.m_pixel;
+*/
+}
+
+wxColour& wxColour::operator =(const wxColour& col)
+{
+  m_red = col.m_red;
+  m_green = col.m_green;
+  m_blue = col.m_blue;
+  m_isInit = col.m_isInit;
+/* TODO
+  m_pixel = col.m_pixel;
+*/
+  return *this;
+}
+
+wxColour::wxColour (const wxString& col)
+{
+    wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+    if (the_colour)
+    {
+        m_red = the_colour->Red ();
+        m_green = the_colour->Green ();
+        m_blue = the_colour->Blue ();
+        m_isInit = TRUE;
+    }
+    else
+    {
+        m_red = 0;
+        m_green = 0;
+        m_blue = 0;
+        m_isInit = FALSE;
+    }
+/* TODO
+    m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}
+
+wxColour::~wxColour ()
+{
+}
+
+wxColour& wxColour::operator = (const wxString& col)
+{
+    wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+    if (the_colour)
+    {
+        m_red = the_colour->Red ();
+        m_green = the_colour->Green ();
+        m_blue = the_colour->Blue ();
+        m_isInit = TRUE;
+    }
+    else
+    {
+        m_red = 0;
+        m_green = 0;
+        m_blue = 0;
+        m_isInit = FALSE;
+    }
+/* TODO
+    m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+    return (*this);
+}
+
+void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
+{
+    m_red = r;
+    m_green = g;
+    m_blue = b;
+    m_isInit = TRUE;
+/* TODO
+    m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}

diff --git a/src/motif/combobox.cpp b/src/motif/combobox.cpp
new file mode 100644 (file)
index 0000000..43547b4
--- /dev/null
+++ b/src/motif/combobox.cpp
@@ -0,0 +1,116 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        combobox.cpp
+// Purpose:     wxComboBox class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "combobox.h"
+#endif
+
+#include "wx/combobox.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
+#endif
+
+bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
+           const wxString& value,
+           const wxPoint& pos,
+           const wxSize& size,
+                  int n, const wxString choices[],
+                  long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_noStrings = n;
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+       m_windowId = (int)NewControlId();
+    else
+       m_windowId = id;
+
+    // TODO: create combobox control
+
+    return TRUE;
+}
+
+wxString wxComboBox::GetValue() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxComboBox::SetValue(const wxString& value)
+{
+    // TODO
+}
+
+// Clipboard operations
+void wxComboBox::Copy()
+{
+    // TODO
+}
+
+void wxComboBox::Cut()
+{
+    // TODO
+}
+
+void wxComboBox::Paste()
+{
+    // TODO
+}
+
+void wxComboBox::SetEditable(bool editable)
+{
+    // TODO
+}
+
+void wxComboBox::SetInsertionPoint(long pos)
+{
+    // TODO
+}
+
+void wxComboBox::SetInsertionPointEnd()
+{
+    // TODO
+}
+
+long wxComboBox::GetInsertionPoint() const
+{
+    // TODO
+    return 0;
+}
+
+long wxComboBox::GetLastPosition() const
+{
+    // TODO
+    return 0;
+}
+
+void wxComboBox::Replace(long from, long to, const wxString& value)
+{
+    // TODO
+}
+
+void wxComboBox::Remove(long from, long to)
+{
+    // TODO
+}
+
+void wxComboBox::SetSelection(long from, long to)
+{
+    // TODO
+}
+

diff --git a/src/motif/control.cpp b/src/motif/control.cpp
new file mode 100644 (file)
index 0000000..aa0baba
--- /dev/null
+++ b/src/motif/control.cpp
@@ -0,0 +1,95 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        control.cpp
+// Purpose:     wxControl class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "control.h"
+#endif
+
+#include "wx/control.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
+
+BEGIN_EVENT_TABLE(wxControl, wxWindow)
+END_EVENT_TABLE()
+#endif
+
+// Item members
+wxControl::wxControl()
+{
+    m_backgroundColour = *wxWHITE;
+    m_foregroundColour = *wxBLACK;
+    m_callback = 0;
+}
+
+wxControl::~wxControl()
+{
+    // If we delete an item, we should initialize the parent panel,
+    // because it could now be invalid.
+    wxWindow *parent = (wxWindow *)GetParent();
+    if (parent)
+    {
+        if (parent->GetDefaultItem() == (wxButton*) this)
+            parent->SetDefaultItem(NULL);
+    }
+}
+
+void wxControl::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+wxString wxControl::GetLabel() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxControl::ProcessCommand (wxCommandEvent & event)
+{
+  // Tries:
+  // 1) A callback function (to become obsolete)
+  // 2) OnCommand, starting at this window and working up parent hierarchy
+  // 3) OnCommand then calls ProcessEvent to search the event tables.
+  if (m_callback)
+    {
+      (void) (*(m_callback)) (*this, event);
+    }
+    else
+    {
+      GetEventHandler()->OnCommand(*this, event);
+    }
+}
+
+void wxControl::Centre (int direction)
+{
+  int x, y, width, height, panel_width, panel_height, new_x, new_y;
+
+  wxWindow *parent = (wxWindow *) GetParent ();
+  if (!parent)
+    return;
+
+  parent->GetClientSize (&panel_width, &panel_height);
+  GetSize (&width, &height);
+  GetPosition (&x, &y);
+
+  new_x = x;
+  new_y = y;
+
+  if (direction & wxHORIZONTAL)
+    new_x = (int) ((panel_width - width) / 2);
+
+  if (direction & wxVERTICAL)
+    new_y = (int) ((panel_height - height) / 2);
+
+  SetSize (new_x, new_y, width, height);
+}
+

diff --git a/src/motif/cursor.cpp b/src/motif/cursor.cpp
new file mode 100644 (file)
index 0000000..4ecd0ad
--- /dev/null
+++ b/src/motif/cursor.cpp
@@ -0,0 +1,187 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        cursor.cpp
+// Purpose:     wxCursor class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "cursor.h"
+#endif
+
+#include "wx/cursor.h"
+#include "wx/icon.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
+#endif
+
+wxCursorRefData::wxCursorRefData()
+{
+    m_width = 32; m_height = 32;
+
+/* TODO
+    m_hCursor = 0 ;
+*/
+}
+
+wxCursorRefData::~wxCursorRefData()
+{
+    // TODO: destroy cursor
+}
+
+// Cursors
+wxCursor::wxCursor()
+{
+}
+
+wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
+    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
+{
+}
+
+wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
+{
+    m_refData = new wxIconRefData;
+
+    // TODO: create cursor from a file
+}
+
+// Cursors by stock number
+wxCursor::wxCursor(int cursor_type)
+{
+  m_refData = new wxIconRefData;
+
+/* TODO
+  switch (cursor_type)
+  {
+    case wxCURSOR_WAIT:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_WAIT);
+      break;
+    case wxCURSOR_IBEAM:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_IBEAM);
+      break;
+    case wxCURSOR_CROSS:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_CROSS);
+      break;
+    case wxCURSOR_SIZENWSE:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENWSE);
+      break;
+    case wxCURSOR_SIZENESW:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENESW);
+      break;
+    case wxCURSOR_SIZEWE:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZEWE);
+      break;
+    case wxCURSOR_SIZENS:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENS);
+      break;
+    case wxCURSOR_CHAR:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+      break;
+    }
+    case wxCURSOR_HAND:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_HAND");
+      break;
+    }
+    case wxCURSOR_BULLSEYE:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BULLSEYE");
+      break;
+    }
+    case wxCURSOR_PENCIL:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PENCIL");
+      break;
+    }
+    case wxCURSOR_MAGNIFIER:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_MAGNIFIER");
+      break;
+    }
+    case wxCURSOR_NO_ENTRY:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_NO_ENTRY");
+      break;
+    }
+    case wxCURSOR_LEFT_BUTTON:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+      break;
+    }
+    case wxCURSOR_RIGHT_BUTTON:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+      break;
+    }
+    case wxCURSOR_MIDDLE_BUTTON:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+      break;
+    }
+    case wxCURSOR_SIZING:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_SIZING");
+      break;
+    }
+    case wxCURSOR_WATCH:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_WATCH");
+      break;
+    }
+    case wxCURSOR_SPRAYCAN:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_ROLLER");
+      break;
+    }
+    case wxCURSOR_PAINT_BRUSH:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PBRUSH");
+      break;
+    }
+    case wxCURSOR_POINT_LEFT:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PLEFT");
+      break;
+    }
+    case wxCURSOR_POINT_RIGHT:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PRIGHT");
+      break;
+    }
+    case wxCURSOR_QUESTION_ARROW:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_QARROW");
+      break;
+    }
+    case wxCURSOR_BLANK:
+    {
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BLANK");
+      break;
+    }
+    default:
+    case wxCURSOR_ARROW:
+      M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+      break;
+  }
+*/
+
+}
+
+wxCursor::~wxCursor()
+{
+}
+
+// Global cursor setting
+void wxSetCursor(const wxCursor& cursor)
+{
+  // TODO (optional on platforms with no global cursor)
+}
+
+

diff --git a/src/motif/data.cpp b/src/motif/data.cpp
new file mode 100644 (file)
index 0000000..793bc7d
--- /dev/null
+++ b/src/motif/data.cpp
@@ -0,0 +1,147 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        data.cpp
+// Purpose:     Various data
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wx.h"
+
+#define _MAXPATHLEN 500
+
+// Useful buffer, initialized in CommonInit
+char *wxBuffer = NULL;
+
+// Windows List
+wxList wxTopLevelWindows;
+
+// List of windows pending deletion
+wxList wxPendingDelete;
+
+int wxPageNumber;
+
+// GDI Object Lists
+wxBrushList *wxTheBrushList = NULL;
+wxPenList   *wxThePenList = NULL;
+wxFontList   *wxTheFontList = NULL;
+wxBitmapList   *wxTheBitmapList = NULL;
+
+wxColourDatabase *wxTheColourDatabase = NULL;
+
+// Stock objects
+wxFont *wxNORMAL_FONT;
+wxFont *wxSMALL_FONT;
+wxFont *wxITALIC_FONT;
+wxFont *wxSWISS_FONT;
+wxPen *wxRED_PEN;
+
+wxPen *wxCYAN_PEN;
+wxPen *wxGREEN_PEN;
+wxPen *wxBLACK_PEN;
+wxPen *wxWHITE_PEN;
+wxPen *wxTRANSPARENT_PEN;
+wxPen *wxBLACK_DASHED_PEN;
+wxPen *wxGREY_PEN;
+wxPen *wxMEDIUM_GREY_PEN;
+wxPen *wxLIGHT_GREY_PEN;
+
+wxBrush *wxBLUE_BRUSH;
+wxBrush *wxGREEN_BRUSH;
+wxBrush *wxWHITE_BRUSH;
+wxBrush *wxBLACK_BRUSH;
+wxBrush *wxTRANSPARENT_BRUSH;
+wxBrush *wxCYAN_BRUSH;
+wxBrush *wxRED_BRUSH;
+wxBrush *wxGREY_BRUSH;
+wxBrush *wxMEDIUM_GREY_BRUSH;
+wxBrush *wxLIGHT_GREY_BRUSH;
+
+wxColour *wxBLACK;
+wxColour *wxWHITE;
+wxColour *wxRED;
+wxColour *wxBLUE;
+wxColour *wxGREEN;
+wxColour *wxCYAN;
+wxColour *wxLIGHT_GREY;
+
+wxCursor *wxSTANDARD_CURSOR = NULL;
+wxCursor *wxHOURGLASS_CURSOR = NULL;
+wxCursor *wxCROSS_CURSOR = NULL;
+
+// 'Null' objects
+wxAcceleratorTable wxNullAcceleratorTable;
+wxBitmap wxNullBitmap;
+wxIcon   wxNullIcon;
+wxCursor wxNullCursor;
+wxPen    wxNullPen;
+wxBrush  wxNullBrush;
+wxPalette wxNullPalette;
+wxFont   wxNullFont;
+wxColour wxNullColour;
+
+// Default window names
+const char *wxButtonNameStr = "button";
+const char *wxCanvasNameStr = "canvas";
+const char *wxCheckBoxNameStr = "check";
+const char *wxChoiceNameStr = "choice";
+const char *wxComboBoxNameStr = "comboBox";
+const char *wxDialogNameStr = "dialog";
+const char *wxFrameNameStr = "frame";
+const char *wxGaugeNameStr = "gauge";
+const char *wxStaticBoxNameStr = "groupBox";
+const char *wxListBoxNameStr = "listBox";
+const char *wxStaticTextNameStr = "message";
+const char *wxStaticBitmapNameStr = "message";
+const char *wxMultiTextNameStr = "multitext";
+const char *wxPanelNameStr = "panel";
+const char *wxRadioBoxNameStr = "radioBox";
+const char *wxRadioButtonNameStr = "radioButton";
+const char *wxBitmapRadioButtonNameStr = "radioButton";
+const char *wxScrollBarNameStr = "scrollBar";
+const char *wxSliderNameStr = "slider";
+const char *wxStaticNameStr = "static";
+const char *wxTextCtrlWindowNameStr = "textWindow";
+const char *wxTextCtrlNameStr = "text";
+const char *wxVirtListBoxNameStr = "virtListBox";
+const char *wxButtonBarNameStr = "buttonbar";
+const char *wxEnhDialogNameStr = "Shell";
+const char *wxToolBarNameStr = "toolbar";
+const char *wxStatusLineNameStr = "status_line";
+const char *wxEmptyString = "";
+const char *wxGetTextFromUserPromptStr = "Input Text";
+const char *wxMessageBoxCaptionStr = "Message";
+const char *wxFileSelectorPromptStr = "Select a file";
+const char *wxFileSelectorDefaultWildcardStr = "*.*";
+const char *wxInternalErrorStr = "wxWindows Internal Error";
+const char *wxFatalErrorStr = "wxWindows Fatal Error";
+
+// See wx/utils.h
+const char *wxFloatToStringStr = "%.2f";
+const char *wxDoubleToStringStr = "%.2f";
+
+#if USE_POSTSCRIPT
+wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
+#endif
+
+#if USE_SHARED_LIBRARY
+///// Event tables (also must be in one, statically-linked file for shared libraries)
+
+// This is the base, wxEvtHandler 'bootstrap' code which is expanded manually here
+const wxEventTable *wxEvtHandler::GetEventTable() const { return &wxEvtHandler::sm_eventTable; }
+
+const wxEventTable wxEvtHandler::sm_eventTable =
+       { NULL, &wxEvtHandler::sm_eventTableEntries[0] };
+
+const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = { { 0, 0, 0, NULL } };
+#endif
+
+const wxSize wxDefaultSize(-1, -1);
+const wxPoint wxDefaultPosition(-1, -1);

diff --git a/src/motif/dc.cpp b/src/motif/dc.cpp
new file mode 100644 (file)
index 0000000..dc5c498
--- /dev/null
+++ b/src/motif/dc.cpp
@@ -0,0 +1,390 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dc.cpp
+// Purpose:     wxDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dc.h"
+#endif
+
+#include "wx/dc.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+#endif
+
+//-----------------------------------------------------------------------------
+// constants
+//-----------------------------------------------------------------------------
+
+#define mm2inches              0.0393700787402
+#define inches2mm              25.4
+#define mm2twips               56.6929133859
+#define twips2mm               0.0176388888889
+#define mm2pt                  2.83464566929
+#define pt2mm                  0.352777777778
+
+//-----------------------------------------------------------------------------
+// wxDC
+//-----------------------------------------------------------------------------
+
+wxDC::wxDC(void)
+{
+  m_ok = FALSE;
+  m_optimize = FALSE;
+  m_autoSetting = FALSE;
+  m_colour = TRUE;
+  m_clipping = FALSE;
+  
+  m_mm_to_pix_x = 1.0;
+  m_mm_to_pix_y = 1.0;
+  
+  m_logicalOriginX = 0;
+  m_logicalOriginY = 0;
+  m_deviceOriginX = 0;
+  m_deviceOriginY = 0;
+  m_internalDeviceOriginX = 0;
+  m_internalDeviceOriginY = 0;
+  m_externalDeviceOriginX = 0;
+  m_externalDeviceOriginY = 0;
+  
+  m_logicalScaleX = 1.0;
+  m_logicalScaleY = 1.0;
+  m_userScaleX = 1.0;
+  m_userScaleY = 1.0;
+  m_scaleX = 1.0;
+  m_scaleY = 1.0;
+  
+  m_mappingMode = MM_TEXT;
+  m_needComputeScaleX = FALSE;
+  m_needComputeScaleY = FALSE;
+  
+  m_signX = 1;  // default x-axis left to right
+  m_signY = 1;  // default y-axis top down
+
+  m_maxX = m_maxY = -100000;
+  m_minY = m_minY =  100000;
+
+  m_logicalFunction = wxCOPY;
+//  m_textAlignment = wxALIGN_TOP_LEFT;
+  m_backgroundMode = wxTRANSPARENT;
+  
+  m_textForegroundColour = *wxBLACK;
+  m_textBackgroundColour = *wxWHITE;
+  m_pen = *wxBLACK_PEN;
+  m_font = *wxNORMAL_FONT;
+  m_brush = *wxTRANSPARENT_BRUSH;
+  m_backgroundBrush = *wxWHITE_BRUSH;
+  
+//  m_palette = wxAPP_COLOURMAP;
+};
+
+wxDC::~wxDC(void)
+{
+};
+
+void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
+{
+};
+
+void wxDC::DrawPoint( wxPoint& point ) 
+{ 
+  DrawPoint( point.x, point.y ); 
+};
+
+void wxDC::DrawPolygon( wxList *list, long xoffset, long yoffset, int fillStyle )
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for( wxNode *node = list->First(); node; node = node->Next() )
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  };
+  DrawPolygon( n, points, xoffset, yoffset, fillStyle );
+  delete[] points;
+};
+
+void wxDC::DrawLines( wxList *list, long xoffset, long yoffset )
+{
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for( wxNode *node = list->First(); node; node = node->Next() ) 
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  };
+  DrawLines( n, points, xoffset, yoffset );
+  delete []points;
+};
+
+void wxDC::DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 )
+{
+  wxList list;
+  list.Append( (wxObject*)new wxPoint(x1, y1) );
+  list.Append( (wxObject*)new wxPoint(x2, y2) );
+  list.Append( (wxObject*)new wxPoint(x3, y3) );
+  DrawSpline(&list);
+  wxNode *node = list.First();
+  while (node)
+  {
+    wxPoint *p = (wxPoint*)node->Data();
+    delete p;
+    node = node->Next();
+  };
+};
+
+void wxDC::DrawSpline( wxList *points )
+{
+  DrawOpenSpline( points );
+};
+
+void wxDC::DrawSpline( int n, wxPoint points[] )
+{
+  wxList list;
+  for (int i = 0; i < n; i++) list.Append( (wxObject*)&points[i] );
+  DrawSpline( &list );
+};
+
+void wxDC::SetClippingRegion( long x, long y, long width, long height )
+{
+  m_clipping = TRUE;
+  m_clipX1 = x;
+  m_clipY1 = y;
+  m_clipX2 = x + width;
+  m_clipY2 = y + height;
+};
+
+void wxDC::DestroyClippingRegion(void)
+{
+  m_clipping = FALSE;
+};
+
+void wxDC::GetClippingBox( long *x, long *y, long *width, long *height ) const
+{
+  if (m_clipping)
+  {
+    if (x) *x = m_clipX1;
+    if (y) *y = m_clipY1;
+    if (width) *width = (m_clipX2 - m_clipX1);
+    if (height) *height = (m_clipY2 - m_clipY1);
+  }
+  else
+   *x = *y = *width = *height = 0;
+};
+
+void wxDC::GetSize( int* width, int* height ) const
+{
+  *width = m_maxX-m_minX;
+  *height = m_maxY-m_minY;
+};
+
+void wxDC::GetSizeMM( long* width, long* height ) const
+{
+  int w = 0;
+  int h = 0;
+  GetSize( &w, &h );
+  *width = long( double(w) / (m_scaleX*m_mm_to_pix_x) );
+  *height = long( double(h) / (m_scaleY*m_mm_to_pix_y) );
+};
+
+void wxDC::SetTextForeground( const wxColour &col )
+{
+  if (!Ok()) return;
+  m_textForegroundColour = col;
+};
+
+void wxDC::SetTextBackground( const wxColour &col )
+{
+  if (!Ok()) return;
+  m_textBackgroundColour = col;
+};
+
+void wxDC::SetMapMode( int mode )
+{
+  switch (mode) 
+  {
+    case MM_TWIPS:
+      SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
+      break;
+    case MM_POINTS:
+      SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
+      break;
+    case MM_METRIC:
+      SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
+      break;
+    case MM_LOMETRIC:
+      SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
+      break;
+    default:
+    case MM_TEXT:
+      SetLogicalScale( 1.0, 1.0 );
+      break;
+  };
+  if (mode != MM_TEXT)
+  {
+    m_needComputeScaleX = TRUE;
+    m_needComputeScaleY = TRUE;
+  };
+};
+
+void wxDC::SetUserScale( double x, double y )
+{
+  // allow negative ? -> no
+  m_userScaleX = x;
+  m_userScaleY = y;
+  ComputeScaleAndOrigin();
+};
+
+void wxDC::GetUserScale( double *x, double *y )
+{
+  if (x) *x = m_userScaleX;
+  if (y) *y = m_userScaleY;
+};
+
+void wxDC::SetLogicalScale( double x, double y )
+{
+  // allow negative ?
+  m_logicalScaleX = x;
+  m_logicalScaleY = y;
+  ComputeScaleAndOrigin();
+};
+
+void wxDC::GetLogicalScale( double *x, double *y )
+{
+  if (x) *x = m_logicalScaleX;
+  if (y) *y = m_logicalScaleY;
+};
+
+void wxDC::SetLogicalOrigin( long x, long y )
+{
+  m_logicalOriginX = x * m_signX;   // is this still correct ?
+  m_logicalOriginY = y * m_signY;
+  ComputeScaleAndOrigin();
+};
+
+void wxDC::GetLogicalOrigin( long *x, long *y )
+{
+  if (x) *x = m_logicalOriginX;
+  if (y) *y = m_logicalOriginY;
+};
+
+void wxDC::SetDeviceOrigin( long x, long y )
+{
+  m_externalDeviceOriginX = x;
+  m_externalDeviceOriginY = y;
+  ComputeScaleAndOrigin();
+};
+
+void wxDC::GetDeviceOrigin( long *x, long *y )
+{
+//  if (x) *x = m_externalDeviceOriginX;
+//  if (y) *y = m_externalDeviceOriginY;
+  if (x) *x = m_deviceOriginX;
+  if (y) *y = m_deviceOriginY;
+};
+
+void wxDC::SetInternalDeviceOrigin( long x, long y )
+{
+  m_internalDeviceOriginX = x;
+  m_internalDeviceOriginY = y;
+  ComputeScaleAndOrigin();
+};
+
+void wxDC::GetInternalDeviceOrigin( long *x, long *y )
+{
+  if (x) *x = m_internalDeviceOriginX;
+  if (y) *y = m_internalDeviceOriginY;
+};
+
+void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+{
+  m_signX = (xLeftRight ?  1 : -1);
+  m_signY = (yBottomUp  ? -1 :  1);
+  ComputeScaleAndOrigin();
+};
+
+long wxDC::DeviceToLogicalX(long x) const
+{
+  return XDEV2LOG(x);
+};
+
+long wxDC::DeviceToLogicalY(long y) const
+{
+  return YDEV2LOG(y);
+};
+
+long wxDC::DeviceToLogicalXRel(long x) const
+{
+  return XDEV2LOGREL(x);
+};
+
+long wxDC::DeviceToLogicalYRel(long y) const
+{
+  return YDEV2LOGREL(y);
+};
+
+long wxDC::LogicalToDeviceX(long x) const
+{
+  return XLOG2DEV(x);
+};
+
+long wxDC::LogicalToDeviceY(long y) const
+{
+  return YLOG2DEV(y);
+};
+
+long wxDC::LogicalToDeviceXRel(long x) const
+{
+  return XLOG2DEVREL(x);
+};
+
+long wxDC::LogicalToDeviceYRel(long y) const
+{
+  return YLOG2DEVREL(y);
+};
+    
+void wxDC::CalcBoundingBox( long x, long y )
+{
+  if (x < m_minX) m_minX = x;
+  if (y < m_minY) m_minY = y;
+  if (x > m_maxX) m_maxX = x;
+  if (y > m_maxY) m_maxY = y;
+};
+
+void wxDC::ComputeScaleAndOrigin(void)
+{
+  // CMB: copy scale to see if it changes
+  double origScaleX = m_scaleX;
+  double origScaleY = m_scaleY;
+
+  m_scaleX = m_logicalScaleX * m_userScaleX;
+  m_scaleY = m_logicalScaleY * m_userScaleY;
+
+  m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX;
+  m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY;
+
+  // CMB: if scale has changed call SetPen to recalulate the line width 
+  if (m_scaleX != origScaleX || m_scaleY != origScaleY)
+  {
+    // this is a bit artificial, but we need to force wxDC to think
+    // the pen has changed
+    wxPen* pen = GetPen();
+    wxPen tempPen;
+    m_pen = tempPen;
+    SetPen(pen);
+  }
+};
+

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
new file mode 100644 (file)
index 0000000..9bd08a3
--- /dev/null
+++ b/src/motif/dcclient.cpp
@@ -0,0 +1,620 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcclient.cpp
+// Purpose:     wxClientDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dcclient.h"
+#endif
+
+#include "wx/dcclient.h"
+#include "wx/dcmemory.h"
+#include <math.h>
+
+//-----------------------------------------------------------------------------
+// constants
+//-----------------------------------------------------------------------------
+
+#define RAD2DEG 57.2957795131
+
+//-----------------------------------------------------------------------------
+// wxPaintDC
+//-----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARY
+//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
+//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
+#endif
+
+
+wxPaintDC::wxPaintDC(void)
+{
+};
+
+wxPaintDC::wxPaintDC( wxWindow *window )
+{
+};
+
+wxPaintDC::~wxPaintDC(void)
+{
+};
+
+void wxPaintDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), 
+  wxColour* WXUNUSED(col), int WXUNUSED(style) )
+{
+};
+
+bool wxPaintDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
+{
+  return FALSE;
+};
+
+void wxPaintDC::DrawLine( long x1, long y1, long x2, long y2 )
+{
+  if (!Ok()) return;
+  
+};
+
+void wxPaintDC::CrossHair( long x, long y )
+{
+  if (!Ok()) return;
+  
+};
+
+void wxPaintDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
+{
+  if (!Ok()) return;
+  
+  long xx1 = XLOG2DEV(x1); 
+  long yy1 = YLOG2DEV(y1);
+  long xx2 = XLOG2DEV(x2); 
+  long yy2 = YLOG2DEV(y2);
+  long xxc = XLOG2DEV((long)xc); 
+  long yyc = YLOG2DEV((long)yc);
+  double dx = xx1 - xxc; 
+  double dy = yy1 - yyc;
+  double radius = sqrt(dx*dx+dy*dy);
+  long   r      = (long)radius;
+  double radius1, radius2;
+
+  if (xx1 == xx2 && yy1 == yy2) 
+  {
+    radius1 = 0.0;
+    radius2 = 360.0;
+  } 
+  else 
+  if (radius == 0.0) 
+  {
+    radius1 = radius2 = 0.0;
+  } 
+  else 
+  {
+    radius1 = (xx1 - xxc == 0) ?
+           (yy1 - yyc < 0) ? 90.0 : -90.0 :
+           -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
+    radius2 = (xx2 - xxc == 0) ?
+           (yy2 - yyc < 0) ? 90.0 : -90.0 :
+           -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
+  };
+  long alpha1 = long(radius1 * 64.0);
+  long alpha2 = long((radius2 - radius1) * 64.0);
+  while (alpha2 <= 0) alpha2 += 360*64;
+  while (alpha1 > 360*64) alpha1 -= 360*64;
+
+  if (m_brush.GetStyle() != wxTRANSPARENT) {};
+    
+  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+  
+};
+
+void wxPaintDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
+{
+  if (!Ok()) return;
+  
+  long xx = XLOG2DEV(x);    
+  long yy = YLOG2DEV(y);
+  long ww = m_signX * XLOG2DEVREL(width); 
+  long hh = m_signY * YLOG2DEVREL(height);
+  
+  // CMB: handle -ve width and/or height
+  if (ww < 0) { ww = -ww; xx = xx - ww; }
+  if (hh < 0) { hh = -hh; yy = yy - hh; }
+  
+  long start = long(sa * 64.0);
+  long end = long(ea * 64.0);
+  if (m_brush.GetStyle() != wxTRANSPARENT) {};
+  
+  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+};
+
+void wxPaintDC::DrawPoint( long x, long y )
+{
+  if (!Ok()) return;
+  
+  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+};
+
+void wxPaintDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
+{
+  if (!Ok()) return;
+  
+  if (m_pen.GetStyle() == wxTRANSPARENT) return;
+  
+  for (int i = 0; i < n-1; i++)
+  {
+    long x1 = XLOG2DEV(points[i].x + xoffset);
+    long x2 = XLOG2DEV(points[i+1].x + xoffset);
+    long y1 = YLOG2DEV(points[i].y + yoffset);     // oh, what a waste
+    long y2 = YLOG2DEV(points[i+1].y + yoffset);
+  };
+};
+
+void wxPaintDC::DrawLines( wxList *points, long xoffset, long yoffset )
+{
+  if (!Ok()) return;
+  
+  if (m_pen.GetStyle() == wxTRANSPARENT) return;
+  
+  wxNode *node = points->First();
+  while (node->Next())
+  {
+    wxPoint *point = (wxPoint*)node->Data();
+    wxPoint *npoint = (wxPoint*)node->Next()->Data();
+    long x1 = XLOG2DEV(point->x + xoffset);
+    long x2 = XLOG2DEV(npoint->x + xoffset);
+    long y1 = YLOG2DEV(point->y + yoffset);    // and again...
+    long y2 = YLOG2DEV(npoint->y + yoffset);
+    node = node->Next();
+  };
+};
+
+void wxPaintDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[], 
+  long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+{
+  if (!Ok()) return;
+};
+
+void wxPaintDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset), 
+                             long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+{
+  if (!Ok()) return;
+};
+
+void wxPaintDC::DrawRectangle( long x, long y, long width, long height )
+{
+  if (!Ok()) return;
+
+  long xx = XLOG2DEV(x);
+  long yy = YLOG2DEV(y);
+  long ww = m_signX * XLOG2DEVREL(width);
+  long hh = m_signY * YLOG2DEVREL(height);
+    
+  // CMB: draw nothing if transformed w or h is 0
+  if (ww == 0 || hh == 0) return;
+
+  // CMB: handle -ve width and/or height
+  if (ww < 0) { ww = -ww; xx = xx - ww; }
+  if (hh < 0) { hh = -hh; yy = yy - hh; }
+
+  if (m_brush.GetStyle() != wxTRANSPARENT) {};
+    
+  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+};
+
+void wxPaintDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
+{
+  if (!Ok()) return;
+  
+  if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
+  
+  long xx = XLOG2DEV(x);    
+  long yy = YLOG2DEV(y);
+  long ww = m_signX * XLOG2DEVREL(width); 
+  long hh = m_signY * YLOG2DEVREL(height);
+  long rr = XLOG2DEVREL((long)radius);
+
+  // CMB: handle -ve width and/or height
+  if (ww < 0) { ww = -ww; xx = xx - ww; }
+  if (hh < 0) { hh = -hh; yy = yy - hh; }
+
+  // CMB: if radius is zero use DrawRectangle() instead to avoid
+  // X drawing errors with small radii
+  if (rr == 0)
+  {
+    DrawRectangle( x, y, width, height );
+    return;
+  }
+
+  // CMB: draw nothing if transformed w or h is 0
+  if (ww == 0 || hh == 0) return;
+
+  // CMB: adjust size if outline is drawn otherwise the result is
+  // 1 pixel too wide and high
+  if (m_pen.GetStyle() != wxTRANSPARENT)
+  {
+    ww--;
+    hh--;
+  }
+
+  // CMB: ensure dd is not larger than rectangle otherwise we
+  // get an hour glass shape
+  long dd = 2 * rr;
+  if (dd > ww) dd = ww;
+  if (dd > hh) dd = hh;
+  rr = dd / 2;
+
+  if (m_brush.GetStyle() != wxTRANSPARENT)
+  {
+  };
+  
+  if (m_pen.GetStyle() != wxTRANSPARENT)
+  {
+  };
+};
+
+void wxPaintDC::DrawEllipse( long x, long y, long width, long height )
+{
+  if (!Ok()) return;
+  
+  long xx = XLOG2DEV(x);    
+  long yy = YLOG2DEV(y);
+  long ww = m_signX * XLOG2DEVREL(width); 
+  long hh = m_signY * YLOG2DEVREL(height);
+
+  // CMB: handle -ve width and/or height
+  if (ww < 0) { ww = -ww; xx = xx - ww; }
+  if (hh < 0) { hh = -hh; yy = yy - hh; }
+  
+  if (m_brush.GetStyle() != wxTRANSPARENT) {};
+  
+  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+};
+
+bool wxPaintDC::CanDrawBitmap(void) const
+{
+  return TRUE;
+};
+
+void wxPaintDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
+{
+  if (!Ok()) return;
+  
+  if (!icon.Ok()) return;
+  
+  int xx = XLOG2DEV(x);
+  int yy = YLOG2DEV(y);
+  
+};
+
+bool wxPaintDC::Blit( long xdest, long ydest, long width, long height,
+       wxDC *source, long xsrc, long ysrc, int WXUNUSED(logical_func), bool WXUNUSED(useMask) )
+{
+  if (!Ok()) return FALSE;
+  
+  // CMB 20/5/98: add blitting of bitmaps
+  if (source->IsKindOf(CLASSINFO(wxMemoryDC)))
+  {
+    wxMemoryDC* srcDC = (wxMemoryDC*)source;
+    /*
+     GdkBitmap* bmap = srcDC->m_selected.GetBitmap();
+    if (bmap)
+    {
+      gdk_draw_bitmap (
+          m_window,
+          m_textGC,
+          bmap,
+          source->DeviceToLogicalX(xsrc), source->DeviceToLogicalY(ysrc),
+          XLOG2DEV(xdest), YLOG2DEV(ydest),
+          source->DeviceToLogicalXRel(width), source->DeviceToLogicalYRel(height)
+          );
+      return TRUE;
+    }
+    */
+  }
+
+  return TRUE;
+};
+
+void wxPaintDC::DrawText( const wxString &text, long x, long y, bool
+WXUNUSED(use16) )
+{
+  if (!Ok()) return;
+
+};
+
+
+
+bool wxPaintDC::CanGetTextExtent(void) const
+{
+  return TRUE;
+};
+
+void wxPaintDC::GetTextExtent( const wxString &string, long *width, long *height,
+                     long *WXUNUSED(descent), long *WXUNUSED(externalLeading),
+                     wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) )
+{
+  if (!Ok()) return;
+  
+};
+
+long wxPaintDC::GetCharWidth(void)
+{
+  if (!Ok()) return 0;
+  return 0;
+};
+
+long wxPaintDC::GetCharHeight(void)
+{
+  if (!Ok()) return 0;
+  return 0;
+};
+
+void wxPaintDC::Clear(void)
+{
+  if (!Ok()) return;
+  
+};
+
+void wxPaintDC::SetFont( const wxFont &font )
+{
+  if (!Ok()) return;
+  
+  m_font = font;
+};
+
+void wxPaintDC::SetPen( const wxPen &pen )
+{
+  if (!Ok()) return;
+
+  if (m_pen == pen) return;
+  
+  m_pen = pen;
+  
+  if (!m_pen.Ok()) return;
+};
+
+void wxPaintDC::SetBrush( const wxBrush &brush )
+{
+  if (!Ok()) return;
+  
+  if (m_brush == brush) return;
+  
+  m_brush = brush;
+  
+  if (!m_brush.Ok()) return;
+  
+};
+
+void wxPaintDC::SetBackground( const wxBrush &brush )
+{
+  if (!Ok()) return;
+  
+  if (m_backgroundBrush == brush) return;
+  
+  m_backgroundBrush = brush;
+  
+  if (!m_backgroundBrush.Ok()) return;
+  
+};
+
+void wxPaintDC::SetLogicalFunction( int function )
+{
+  if (m_logicalFunction == function) return;
+};
+
+void wxPaintDC::SetTextForeground( const wxColour &col )
+{
+  if (!Ok()) return;
+  
+  if (m_textForegroundColour == col) return;
+  
+  m_textForegroundColour = col;
+  if (!m_textForegroundColour.Ok()) return;
+};
+
+void wxPaintDC::SetTextBackground( const wxColour &col )
+{
+  if (!Ok()) return;
+  
+  if (m_textBackgroundColour == col) return;
+  
+  m_textBackgroundColour = col;
+  if (!m_textBackgroundColour.Ok()) return;
+};
+
+void wxPaintDC::SetBackgroundMode( int mode )
+{
+  m_backgroundMode = mode;
+
+  if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
+  {
+  }
+};
+
+void wxPaintDC::SetPalette( const wxPalette& WXUNUSED(palette) )
+{
+};
+
+void wxPaintDC::SetClippingRegion( long x, long y, long width, long height )
+{
+  wxDC::SetClippingRegion( x, y, width, height );
+  
+};
+
+void wxPaintDC::DestroyClippingRegion(void)
+{
+  wxDC::DestroyClippingRegion();
+  
+};
+
+// ----------------------------------- spline code ----------------------------------------
+
+void wx_quadratic_spline(double a1, double b1, double a2, double b2,
+                         double a3, double b3, double a4, double b4);
+void wx_clear_stack(void);
+int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
+        double *y3, double *x4, double *y4);
+void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
+          double x4, double y4);
+static bool wx_spline_add_point(double x, double y);
+static void wx_spline_draw_point_array(wxDC *dc);
+
+wxList wx_spline_point_list;
+
+#define                half(z1, z2)    ((z1+z2)/2.0)
+#define                THRESHOLD       5
+
+/* iterative version */
+
+void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
+                 double b4)
+{
+    register double  xmid, ymid;
+    double           x1, y1, x2, y2, x3, y3, x4, y4;
+
+    wx_clear_stack();
+    wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
+
+    while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
+        xmid = (double)half(x2, x3);
+        ymid = (double)half(y2, y3);
+       if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
+           fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
+            wx_spline_add_point( x1, y1 );
+            wx_spline_add_point( xmid, ymid );
+       } else {
+            wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
+                 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
+            wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
+                 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
+       }
+    }
+}
+
+/* utilities used by spline drawing routines */
+
+typedef struct wx_spline_stack_struct {
+    double           x1, y1, x2, y2, x3, y3, x4, y4;
+} Stack;
+
+#define         SPLINE_STACK_DEPTH             20
+static Stack    wx_spline_stack[SPLINE_STACK_DEPTH];
+static Stack   *wx_stack_top;
+static int      wx_stack_count;
+
+void wx_clear_stack(void)
+{
+    wx_stack_top = wx_spline_stack;
+    wx_stack_count = 0;
+}
+
+void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
+{
+    wx_stack_top->x1 = x1;
+    wx_stack_top->y1 = y1;
+    wx_stack_top->x2 = x2;
+    wx_stack_top->y2 = y2;
+    wx_stack_top->x3 = x3;
+    wx_stack_top->y3 = y3;
+    wx_stack_top->x4 = x4;
+    wx_stack_top->y4 = y4;
+    wx_stack_top++;
+    wx_stack_count++;
+}
+
+int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
+                  double *x3, double *y3, double *x4, double *y4)
+{
+    if (wx_stack_count == 0)
+       return (0);
+    wx_stack_top--;
+    wx_stack_count--;
+    *x1 = wx_stack_top->x1;
+    *y1 = wx_stack_top->y1;
+    *x2 = wx_stack_top->x2;
+    *y2 = wx_stack_top->y2;
+    *x3 = wx_stack_top->x3;
+    *y3 = wx_stack_top->y3;
+    *x4 = wx_stack_top->x4;
+    *y4 = wx_stack_top->y4;
+    return (1);
+}
+
+static bool wx_spline_add_point(double x, double y)
+{
+  wxPoint *point = new wxPoint ;
+  point->x = (int) x;
+  point->y = (int) y;
+  wx_spline_point_list.Append((wxObject*)point);
+  return TRUE;
+}
+
+static void wx_spline_draw_point_array(wxDC *dc)
+{
+  dc->DrawLines(&wx_spline_point_list, 0, 0 );
+  wxNode *node = wx_spline_point_list.First();
+  while (node)
+  {
+    wxPoint *point = (wxPoint *)node->Data();
+    delete point;
+    delete node;
+    node = wx_spline_point_list.First();
+  }
+}
+
+void wxPaintDC::DrawOpenSpline( wxList *points )
+{
+    wxPoint *p;
+    double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
+    double           x1, y1, x2, y2;
+
+    wxNode *node = points->First();
+    p = (wxPoint *)node->Data();
+
+    x1 = p->x;
+    y1 = p->y;
+
+    node = node->Next();
+    p = (wxPoint *)node->Data();
+
+    x2 = p->x;
+    y2 = p->y;
+    cx1 = (double)((x1 + x2) / 2);
+    cy1 = (double)((y1 + y2) / 2);
+    cx2 = (double)((cx1 + x2) / 2);
+    cy2 = (double)((cy1 + y2) / 2);
+
+    wx_spline_add_point(x1, y1);
+
+    while ((node = node->Next()) != NULL)
+    {
+        p = (wxPoint *)node->Data();
+       x1 = x2;
+       y1 = y2;
+       x2 = p->x;
+       y2 = p->y;
+        cx4 = (double)(x1 + x2) / 2;
+        cy4 = (double)(y1 + y2) / 2;
+        cx3 = (double)(x1 + cx4) / 2;
+        cy3 = (double)(y1 + cy4) / 2;
+
+        wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
+
+       cx1 = cx4;
+       cy1 = cy4;
+        cx2 = (double)(cx1 + x2) / 2;
+        cy2 = (double)(cy1 + y2) / 2;
+    }
+
+    wx_spline_add_point( cx1, cy1 );
+    wx_spline_add_point( x2, y2 );
+
+    wx_spline_draw_point_array( this );
+};

diff --git a/src/motif/dcmemory.cpp b/src/motif/dcmemory.cpp
new file mode 100644 (file)
index 0000000..9a80e5f
--- /dev/null
+++ b/src/motif/dcmemory.cpp
@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcmemory.cpp
+// Purpose:     wxMemoryDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dcmemory.h"
+#endif
+
+#include "wx/dcmemory.h"
+
+//-----------------------------------------------------------------------------
+// wxMemoryDC
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxPaintDC)
+
+wxMemoryDC::wxMemoryDC(void)
+{
+  m_ok = FALSE;
+};
+
+wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) )
+{
+  m_ok = FALSE;
+};
+
+wxMemoryDC::~wxMemoryDC(void)
+{
+};
+
+void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
+{
+  m_selected = bitmap;
+  if (m_selected.Ok())
+  {
+  }
+  else
+  {
+    m_ok = FALSE;
+  };
+};
+
+void wxMemoryDC::GetSize( int *width, int *height ) const
+{
+  if (m_selected.Ok())
+  {
+    if (width) (*width) = m_selected.GetWidth();
+    if (height) (*height) = m_selected.GetHeight();
+  }
+  else
+  {
+    if (width) (*width) = 0;
+    if (height) (*height) = 0;
+  };
+};
+
+

diff --git a/src/motif/dcscreen.cpp b/src/motif/dcscreen.cpp
new file mode 100644 (file)
index 0000000..82f4985
--- /dev/null
+++ b/src/motif/dcscreen.cpp
@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dcscreen.cpp
+// Purpose:     wxScreenDC class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dcscreen.h"
+#endif
+
+#include "wx/dcscreen.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxPaintDC)
+#endif
+
+// Create a DC representing the whole screen
+wxScreenDC::wxScreenDC()
+{
+    // TODO
+}
+
+wxScreenDC::~wxScreenDC()
+{
+    // TODO
+}
+

diff --git a/src/motif/dialog.cpp b/src/motif/dialog.cpp
new file mode 100644 (file)
index 0000000..d8bce29
--- /dev/null
+++ b/src/motif/dialog.cpp
@@ -0,0 +1,294 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dialog.cpp
+// Purpose:     wxDialog class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dialog.h"
+#endif
+
+#include "wx/dialog.h"
+#include "wx/utils.h"
+#include "wx/frame.h"
+#include "wx/app.h"
+#include "wx/settings.h"
+
+// Lists to keep track of windows, so we can disable/enable them
+// for modal dialogs
+wxList wxModalDialogs;
+wxList wxModelessWindows;  // Frames and modeless dialogs
+extern wxList wxPendingDelete;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel)
+
+BEGIN_EVENT_TABLE(wxDialog, wxPanel)
+  EVT_BUTTON(wxID_OK, wxDialog::OnOK)
+  EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
+  EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
+  EVT_CHAR_HOOK(wxDialog::OnCharHook)
+  EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
+  EVT_CLOSE(wxDialog::OnCloseWindow)
+END_EVENT_TABLE()
+
+#endif
+
+wxDialog::wxDialog()
+{
+    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+}
+
+bool wxDialog::Create(wxWindow *parent, wxWindowID id,
+           const wxString& title,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+  m_windowStyle = style;
+
+  SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+  SetName(name);
+  
+  if (!parent)
+    wxTopLevelWindows.Append(this);
+
+  if (parent) parent->AddChild(this);
+
+  if ( id == -1 )
+       m_windowId = (int)NewControlId();
+  else
+       m_windowId = id;
+
+  // TODO: create dialog
+
+  return FALSE;
+}
+
+void wxDialog::SetModal(bool flag)
+{
+       if ( flag )
+               m_windowStyle |= wxDIALOG_MODAL ;
+       else
+               if ( m_windowStyle & wxDIALOG_MODAL )
+                       m_windowStyle -= wxDIALOG_MODAL ;
+  
+  wxModelessWindows.DeleteObject(this);
+  if (!flag)
+    wxModelessWindows.Append(this);
+}
+
+wxDialog::~wxDialog()
+{
+    // TODO
+    wxTopLevelWindows.DeleteObject(this);
+
+    if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL )
+      wxModelessWindows.DeleteObject(this);
+
+    // If this is the last top-level window, exit.
+    if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+    {
+      wxTheApp->SetTopWindow(NULL);
+
+      if (wxTheApp->GetExitOnFrameDelete())
+      {
+         // TODO: exit
+      }
+    }
+}
+
+// By default, pressing escape cancels the dialog
+void wxDialog::OnCharHook(wxKeyEvent& event)
+{
+  if (event.m_keyCode == WXK_ESCAPE)
+  {
+               // Behaviour changed in 2.0: we'll send a Cancel message
+               // to the dialog instead of Close.
+               wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
+               cancelEvent.SetEventObject( this );
+               GetEventHandler()->ProcessEvent(cancelEvent);
+
+               return;
+  }
+  // We didn't process this event.
+  event.Skip();
+}
+
+void wxDialog::Iconize(bool WXUNUSED(iconize))
+{
+    // TODO
+}
+
+bool wxDialog::IsIconized() const
+{
+    // TODO
+    return FALSE;
+}
+
+void wxDialog::SetClientSize(int width, int height)
+{
+    // TODO
+}
+
+void wxDialog::GetPosition(int *x, int *y) const
+{
+    // TODO
+}
+
+bool wxDialog::Show(bool show)
+{
+    // TODO
+    return FALSE;
+}
+
+void wxDialog::SetTitle(const wxString& title)
+{
+    // TODO
+}
+
+wxString wxDialog::GetTitle() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxDialog::Centre(int direction)
+{
+  int x_offset,y_offset ;
+  int display_width, display_height;
+  int  width, height, x, y;
+  wxFrame *frame ;
+  if (direction & wxCENTER_FRAME)
+  {
+    frame = (wxFrame*)GetParent() ;
+    if (frame)
+    {
+      frame->GetPosition(&x_offset,&y_offset) ;
+      frame->GetSize(&display_width,&display_height) ;
+    }
+  }
+  else
+    frame = NULL ;
+
+  if (frame==NULL)
+  {
+    wxDisplaySize(&display_width, &display_height);
+    x_offset = 0 ;
+    y_offset = 0 ;
+  }
+
+  GetSize(&width, &height);
+  GetPosition(&x, &y);
+
+  if (direction & wxHORIZONTAL)
+    x = (int)((display_width - width)/2);
+  if (direction & wxVERTICAL)
+    y = (int)((display_height - height)/2);
+
+  SetSize(x+x_offset, y+y_offset, width, height);
+}
+
+// Replacement for Show(TRUE) for modal dialogs - returns return code
+int wxDialog::ShowModal()
+{
+    m_windowStyle |= wxDIALOG_MODAL;
+    // TODO: modal showing
+       Show(TRUE);
+       return GetReturnCode();
+}
+
+void wxDialog::EndModal(int retCode)
+{
+       SetReturnCode(retCode);
+    // TODO modal un-showing
+       Show(FALSE);
+}
+
+// Standard buttons
+void wxDialog::OnOK(wxCommandEvent& event)
+{
+       if ( Validate() && TransferDataFromWindow() )
+       {
+        if ( IsModal() )
+            EndModal(wxID_OK);
+        else
+        {
+                   SetReturnCode(wxID_OK);
+                   this->Show(FALSE);
+        }
+       }
+}
+
+void wxDialog::OnApply(wxCommandEvent& event)
+{
+       if (Validate())
+               TransferDataFromWindow();
+       // TODO probably need to disable the Apply button until things change again
+}
+
+void wxDialog::OnCancel(wxCommandEvent& event)
+{
+    if ( IsModal() )
+        EndModal(wxID_CANCEL);
+    else
+    {
+        SetReturnCode(wxID_CANCEL);
+               this->Show(FALSE);
+    }
+}
+
+bool wxDialog::OnClose()
+{
+       // Behaviour changed in 2.0: we'll send a Cancel message by default,
+    // which may close the dialog.
+    // Check for looping if the Cancel event handler calls Close()
+
+    static wxList closing;
+
+    if ( closing.Member(this) )
+        return FALSE;
+
+    closing.Append(this);
+
+       wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
+       cancelEvent.SetEventObject( this );
+       GetEventHandler()->ProcessEvent(cancelEvent);
+
+    closing.DeleteObject(this);
+
+       return FALSE;
+}
+
+void wxDialog::OnCloseWindow(wxCloseEvent& event)
+{
+    // Compatibility
+    if ( GetEventHandler()->OnClose() || event.GetForce())
+    {
+        this->Destroy();
+    }
+}
+
+// Destroy the window (delayed, if a managed window)
+bool wxDialog::Destroy()
+{
+  if (!wxPendingDelete.Member(this))
+    wxPendingDelete.Append(this);
+  return TRUE;
+}
+
+void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event)
+{
+  SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+  Refresh();
+}
+
+void wxDialog::Fit()
+{
+}

diff --git a/src/motif/dirdlg.cpp b/src/motif/dirdlg.cpp
new file mode 100644 (file)
index 0000000..56828d8
--- /dev/null
+++ b/src/motif/dirdlg.cpp
@@ -0,0 +1,42 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dirdlg.cpp
+// Purpose:     wxDirDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dirdlg.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/utils.h"
+#include "wx/dialog.h"
+#include "wx/dirdlg.h"
+
+#include "wx/cmndata.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_CLASS(wxDirDialog, wxDialog)
+#endif
+
+wxDirDialog::wxDirDialog(wxWindow *parent, const wxString& message,
+        const wxString& defaultPath,
+        long style, const wxPoint& pos)
+{
+    m_message = message;
+    m_dialogStyle = style;
+    m_parent = parent;
+       m_path = defaultPath;
+}
+
+int wxDirDialog::ShowModal()
+{
+    // TODO
+       return wxID_CANCEL;
+}
+

diff --git a/src/motif/dnd.cpp b/src/motif/dnd.cpp
new file mode 100644 (file)
index 0000000..5a3941a
--- /dev/null
+++ b/src/motif/dnd.cpp
@@ -0,0 +1,133 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        dnd.cpp
+// Purpose:     wxDropTarget, wxDropSource, wxDataObject implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "dnd.h"
+#endif
+
+#include "wx/dnd.h"
+#include "wx/window.h"
+#include "wx/app.h"
+#include "wx/gdicmn.h"
+
+// ----------------------------------------------------------------------------
+// global
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// wxDropTarget
+// ----------------------------------------------------------------------------
+
+wxDropTarget::wxDropTarget()
+{
+};
+
+wxDropTarget::~wxDropTarget()
+{
+};
+
+// ----------------------------------------------------------------------------
+// wxTextDropTarget
+// ----------------------------------------------------------------------------
+
+bool wxTextDropTarget::OnDrop( long x, long y, const void *pData )
+{
+  OnDropText( x, y, (const char*)pData );
+  return TRUE;
+};
+
+bool wxTextDropTarget::OnDropText( long x, long y, const char *psz )
+{
+  printf( "Got dropped text: %s.\n", psz );
+  printf( "At x: %d, y: %d.\n", (int)x, (int)y );
+  return TRUE;
+};
+
+size_t wxTextDropTarget::GetFormatCount() const
+{
+  return 1;
+}
+
+wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
+{
+  return wxDF_TEXT;
+}
+
+// ----------------------------------------------------------------------------
+// wxFileDropTarget
+// ----------------------------------------------------------------------------
+
+bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] )
+{
+  printf( "Got %d dropped files.\n", (int)nFiles );
+  printf( "At x: %d, y: %d.\n", (int)x, (int)y );
+  return TRUE;
+}
+
+bool wxFileDropTarget::OnDrop(long x, long y, const void *WXUNUSED(pData) )
+{
+  char *str = "/this/is/a/path.txt";
+
+  return OnDropFiles(x, y, 1, &str ); 
+}
+
+size_t wxFileDropTarget::GetFormatCount() const
+{
+  return 1;
+}
+
+wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
+{
+  return wxDF_FILENAME;
+}
+
+//-------------------------------------------------------------------------
+// wxDropSource
+//-------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// drag request
+
+wxDropSource::wxDropSource( wxWindow *win )
+{
+    // TODO
+  //    m_window = win;
+    m_data = NULL;
+
+    //    m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
+    //    m_goaheadCursor = wxCursor( wxCURSOR_HAND );
+};
+
+wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
+{
+    // TODO
+  //    m_window = win;
+    m_data = &data;
+
+    //    m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
+    //    m_goaheadCursor = wxCursor( wxCURSOR_HAND );
+};
+
+void wxDropSource::SetData( wxDataObject &data )
+{
+    m_data = &data;
+};
+
+wxDropSource::~wxDropSource(void)
+{
+};
+   
+wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
+{
+    // TODO
+    return wxDragError;
+};
+

diff --git a/src/motif/filedlg.cpp b/src/motif/filedlg.cpp
new file mode 100644 (file)
index 0000000..fdd54ea
--- /dev/null
+++ b/src/motif/filedlg.cpp
@@ -0,0 +1,143 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        filedlg.cpp
+// Purpose:     wxFileDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "filedlg.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/utils.h"
+#include "wx/dialog.h"
+#include "wx/filedlg.h"
+#include "wx/intl.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_CLASS(wxFileDialog, wxDialog)
+#endif
+
+char *wxFileSelector(const char *title,
+                     const char *defaultDir, const char *defaultFileName,
+                     const char *defaultExtension, const char *filter, int flags,
+                     wxWindow *parent, int x, int y)
+{
+    // If there's a default extension specified but no filter, we create a suitable
+    // filter.
+
+    wxString filter2("");
+    if ( defaultExtension && !filter )
+        filter2 = wxString("*.") + wxString(defaultExtension) ;
+    else if ( filter )
+        filter2 = filter;
+
+    wxString defaultDirString;
+    if (defaultDir)
+        defaultDirString = defaultDir;
+    else
+        defaultDirString = "";
+
+    wxString defaultFilenameString;
+    if (defaultFileName)
+        defaultFilenameString = defaultFileName;
+    else
+        defaultFilenameString = "";
+
+    wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
+
+    if ( fileDialog.ShowModal() == wxID_OK )
+    {
+        strcpy(wxBuffer, (const char *)fileDialog.GetPath());
+        return wxBuffer;
+    }
+    else
+        return NULL;
+}
+
+char *wxFileSelectorEx(const char *title,
+                       const char *defaultDir,
+                       const char *defaultFileName,
+                       int* defaultFilterIndex,
+                       const char *filter,
+                       int       flags,
+                       wxWindow* parent,
+                       int       x,
+                       int       y)
+
+{
+    wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
+        defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
+
+    if ( fileDialog.ShowModal() == wxID_OK )
+    {
+        *defaultFilterIndex = fileDialog.GetFilterIndex();
+        strcpy(wxBuffer, (const char *)fileDialog.GetPath());
+        return wxBuffer;
+    }
+    else
+        return NULL;
+}
+
+wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
+        const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
+        long style, const wxPoint& pos)
+{
+    m_message = message;
+    m_dialogStyle = style;
+    m_parent = parent;
+    m_path = "";
+    m_fileName = defaultFileName;
+    m_dir = defaultDir;
+    m_wildCard = wildCard;
+    m_filterIndex = 1;
+}
+
+int wxFileDialog::ShowModal()
+{
+    // TODO
+    return wxID_CANCEL;
+}
+
+// Generic file load/save dialog
+static char *
+wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent)
+{
+  char *ext = (char *)extension;
+  
+  char prompt[50];
+  wxString str;
+  if (load)
+    str = "Load %s file";
+  else
+    str = "Save %s file";
+  sprintf(prompt, wxGetTranslation(str), what);
+
+  if (*ext == '.') ext++;
+  char wild[60];
+  sprintf(wild, "*.%s", ext);
+
+  return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
+}
+
+// Generic file load dialog
+char *
+wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
+{
+  return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
+}
+
+
+// Generic file save dialog
+char *
+wxSaveFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
+{
+  return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
+}
+
+

diff --git a/src/motif/font.cpp b/src/motif/font.cpp
new file mode 100644 (file)
index 0000000..c485b71
--- /dev/null
+++ b/src/motif/font.cpp
@@ -0,0 +1,244 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        font.cpp
+// Purpose:     wxFont class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "font.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/font.h"
+#include "wx/gdicmn.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
+#endif
+
+wxFontRefData::wxFontRefData()
+{
+       m_style = 0;
+       m_pointSize = 0;
+       m_family = 0;
+       m_style = 0;
+       m_weight = 0;
+       m_underlined = 0;
+       m_faceName = "";
+/* TODO
+       m_hFont = 0;
+*/
+}
+
+wxFontRefData::wxFontRefData(const wxFontRefData& data)
+{
+       m_style = data.m_style;
+       m_pointSize = data.m_pointSize;
+       m_family = data.m_family;
+       m_style = data.m_style;
+       m_weight = data.m_weight;
+       m_underlined = data.m_underlined;
+       m_faceName = data.m_faceName;
+/* TODO
+       m_hFont = 0;
+*/
+}
+
+wxFontRefData::~wxFontRefData()
+{
+    // TODO: delete font data
+}
+
+wxFont::wxFont()
+{
+    if ( wxTheFontList )
+        wxTheFontList->Append(this);
+}
+
+wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
+{
+    Create(pointSize, family, style, weight, underlined, faceName);
+
+    if ( wxTheFontList )
+        wxTheFontList->Append(this);
+}
+
+bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
+{
+    UnRef();
+    m_refData = new wxFontRefData;
+
+    M_FONTDATA->m_family = family;
+    M_FONTDATA->m_style = style;
+    M_FONTDATA->m_weight = weight;
+    M_FONTDATA->m_pointSize = pointSize;
+    M_FONTDATA->m_underlined = underlined;
+    M_FONTDATA->m_faceName = faceName;
+
+    RealizeResource();
+
+    return TRUE;
+}
+
+wxFont::~wxFont()
+{
+    if (wxTheFontList)
+        wxTheFontList->DeleteObject(this);
+}
+
+bool wxFont::RealizeResource()
+{
+    // TODO: create the font (if there is a native font object)
+    return FALSE;
+}
+
+void wxFont::Unshare()
+{
+       // Don't change shared data
+       if (!m_refData)
+    {
+               m_refData = new wxFontRefData();
+       }
+    else
+    {
+               wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
+               UnRef();
+               m_refData = ref;
+       }
+}
+
+void wxFont::SetPointSize(int pointSize)
+{
+    Unshare();
+
+    M_FONTDATA->m_pointSize = pointSize;
+
+    RealizeResource();
+}
+
+void wxFont::SetFamily(int family)
+{
+    Unshare();
+
+    M_FONTDATA->m_family = family;
+
+    RealizeResource();
+}
+
+void wxFont::SetStyle(int style)
+{
+    Unshare();
+
+    M_FONTDATA->m_style = style;
+
+    RealizeResource();
+}
+
+void wxFont::SetWeight(int weight)
+{
+    Unshare();
+
+    M_FONTDATA->m_weight = weight;
+
+    RealizeResource();
+}
+
+void wxFont::SetFaceName(const wxString& faceName)
+{
+    Unshare();
+
+    M_FONTDATA->m_faceName = faceName;
+
+    RealizeResource();
+}
+
+void wxFont::SetUnderlined(bool underlined)
+{
+    Unshare();
+
+    M_FONTDATA->m_underlined = underlined;
+
+    RealizeResource();
+}
+
+wxString wxFont::GetFamilyString() const
+{
+  wxString fam("");
+  switch (GetFamily())
+  {
+    case wxDECORATIVE:
+      fam = "wxDECORATIVE";
+      break;
+    case wxROMAN:
+      fam = "wxROMAN";
+      break;
+    case wxSCRIPT:
+      fam = "wxSCRIPT";
+      break;
+    case wxSWISS:
+      fam = "wxSWISS";
+      break;
+    case wxMODERN:
+      fam = "wxMODERN";
+      break;
+    case wxTELETYPE:
+      fam = "wxTELETYPE";
+      break;
+    default:
+      fam = "wxDEFAULT";
+      break;
+  }
+  return fam;
+}
+
+/* New font system */
+wxString wxFont::GetFaceName() const
+{
+    wxString str("");
+    if (M_FONTDATA)
+           str = M_FONTDATA->m_faceName ;
+    return str;
+}
+
+wxString wxFont::GetStyleString() const
+{
+    wxString styl("");
+    switch (GetStyle())
+    {
+        case wxITALIC:
+            styl = "wxITALIC";
+            break;
+        case wxSLANT:
+            styl = "wxSLANT";
+            break;
+        default:
+            styl = "wxNORMAL";
+            break;
+    }
+    return styl;
+}
+
+wxString wxFont::GetWeightString() const
+{
+    wxString w("");
+    switch (GetWeight())
+    {
+        case wxBOLD:
+            w = "wxBOLD";
+            break;
+        case wxLIGHT:
+            w = "wxLIGHT";
+            break;
+        default:
+            w = "wxNORMAL";
+            break;
+    }
+    return w;
+}
+

diff --git a/src/motif/fontdlg.cpp b/src/motif/fontdlg.cpp
new file mode 100644 (file)
index 0000000..66da67a
--- /dev/null
+++ b/src/motif/fontdlg.cpp
@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        fontdlg.cpp
+// Purpose:     wxFontDialog class. NOTE: you can use the generic class
+//              if you wish, instead of implementing this.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "fontdlg.h"
+#endif
+
+#include "wx/stubs/fontdlg.h"
+#include "wx/cmndata.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
+#endif
+
+/*
+ * wxFontDialog
+ */
+
+wxFontDialog::wxFontDialog()
+{
+    m_dialogParent = NULL;
+}
+
+wxFontDialog::wxFontDialog(wxWindow *parent, wxFontData *data)
+{
+    Create(parent, data);
+}
+
+bool wxFontDialog::Create(wxWindow *parent, wxFontData *data)
+{
+    m_dialogParent = parent;
+
+    if (data)
+        m_fontData = *data;
+
+    // TODO: you may need to do dialog creation here, unless it's
+    // done in ShowModal.
+    return TRUE;
+}
+
+int wxFontDialog::ShowModal()
+{
+    // TODO: show (maybe create) the dialog
+    return wxID_CANCEL;
+}
+

diff --git a/src/motif/frame.cpp b/src/motif/frame.cpp
new file mode 100644 (file)
index 0000000..43727d9
--- /dev/null
+++ b/src/motif/frame.cpp
@@ -0,0 +1,1059 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        frame.cpp
+// Purpose:     wxFrame
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "frame.h"
+#endif
+
+#include "wx/frame.h"
+#include "wx/statusbr.h"
+#include "wx/toolbar.h"
+#include "wx/menuitem.h"
+#include "wx/menu.h"
+#include "wx/dcclient.h"
+#include "wx/dialog.h"
+#include "wx/settings.h"
+#include "wx/app.h"
+#include "wx/utils.h"
+
+#if defined(__ultrix) || defined(__sgi)
+#include <Xm/Frame.h>
+#endif
+
+#include <Xm/Xm.h>
+#include <X11/Shell.h>
+#if XmVersion >= 1002
+#include <Xm/XmAll.h>
+#else
+#include <Xm/Frame.h>
+#endif
+#include <Xm/MwmUtil.h>
+#include <Xm/BulletinB.h>
+#include <Xm/Form.h>
+#include <Xm/MainW.h>
+#include <Xm/RowColumn.h>
+#include <Xm/Label.h>
+#include <Xm/AtomMgr.h>
+#include <Xm/LabelG.h>
+#include <Xm/Frame.h>
+#if   XmVersion > 1000
+#include <Xm/Protocols.h>
+#endif
+
+#include "wx/motif/private.h"
+
+void wxCloseFrameCallback(Widget, XtPointer, XmAnyCallbackStruct *cbs);
+static void wxFrameFocusProc(Widget workArea, XtPointer clientData, 
+                      XmAnyCallbackStruct *cbs);
+static void wxFrameMapProc(Widget frameShell, XtPointer clientData, 
+                          XCrossingEvent * event);
+
+extern wxList wxModelessWindows;
+extern wxList wxPendingDelete;
+
+// TODO: this should be tidied so that any frame can be the
+// top frame
+static bool wxTopLevelUsed = FALSE;
+
+#if !USE_SHARED_LIBRARY
+BEGIN_EVENT_TABLE(wxFrame, wxWindow)
+  EVT_SIZE(wxFrame::OnSize)
+  EVT_ACTIVATE(wxFrame::OnActivate)
+  EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
+  EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
+  EVT_IDLE(wxFrame::OnIdle)
+  EVT_CLOSE(wxFrame::OnCloseWindow)
+END_EVENT_TABLE()
+
+IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif
+
+#if USE_NATIVE_STATUSBAR
+bool wxFrame::m_useNativeStatusBar = TRUE;
+#else
+bool wxFrame::m_useNativeStatusBar = FALSE;
+#endif
+
+wxFrame::wxFrame()
+{
+    m_frameToolBar = NULL ;
+    m_frameMenuBar = NULL;
+    m_frameStatusBar = NULL;
+
+    m_windowParent = NULL;
+    m_iconized = FALSE;
+
+    //// Motif-specific
+    m_frameShell = (WXWidget) NULL;
+    m_frameWidget = (WXWidget) NULL;;
+    m_workArea = (WXWidget) NULL;;
+    m_clientArea = (WXWidget) NULL;;
+    m_visibleStatus = TRUE;
+    m_title = "";
+}
+
+bool wxFrame::Create(wxWindow *parent,
+           wxWindowID id,
+           const wxString& title,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+  if (!parent)
+      wxTopLevelWindows.Append(this);
+
+  SetName(name);
+
+  m_windowStyle = style;
+  m_frameMenuBar = NULL;
+  m_frameToolBar = NULL ;
+  m_frameStatusBar = NULL;
+
+  //// Motif-specific
+  m_frameShell = (WXWidget) NULL;
+  m_frameWidget = (WXWidget) NULL;;
+  m_workArea = (WXWidget) NULL;;
+  m_clientArea = (WXWidget) NULL;;
+  m_visibleStatus = TRUE;
+  m_title = "";
+
+  SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+
+  if ( id > -1 )
+    m_windowId = id;
+  else
+    m_windowId = (int)NewControlId();
+
+  if (parent) parent->AddChild(this);
+
+  wxModelessWindows.Append(this);
+
+  int x = pos.x; int y = pos.y;
+  int width = size.x; int height = size.y;
+
+  if (wxTopLevelUsed)
+    // Change suggested by Matthew Flatt
+    m_frameShell = (WXWidget) XtAppCreateShell(name, wxTheApp->GetClassName(), topLevelShellWidgetClass, (Display*) wxGetDisplay(), NULL, 0);
+  else
+  {
+    m_frameShell = wxTheApp->GetTopLevelWidget();
+    wxTopLevelUsed = TRUE;
+  }
+
+  XtVaSetValues((Widget) m_frameShell, 
+                 // Allows menu to resize
+                 XmNallowShellResize, True,
+                 XmNdeleteResponse, XmDO_NOTHING,
+                 XmNmappedWhenManaged, False,
+                 XmNiconic, (style & wxICONIZE) ? TRUE : FALSE,
+                 NULL);
+
+  if (!title.IsNull())
+    XtVaSetValues((Widget) m_frameShell, 
+                  XmNtitle, (const char*) title,
+                  NULL);
+
+  m_frameWidget = (WXWidget) XtVaCreateManagedWidget("main_window",
+                    xmMainWindowWidgetClass, (Widget) m_frameShell,
+                    XmNresizePolicy, XmRESIZE_NONE,
+                    NULL);
+
+  m_workArea = (WXWidget) XtVaCreateWidget("form",
+                    xmFormWidgetClass, (Widget) m_frameWidget,
+                    XmNresizePolicy, XmRESIZE_NONE,
+                    NULL);
+
+  m_clientArea = (WXWidget) XtVaCreateWidget("client",
+                    xmBulletinBoardWidgetClass, (Widget) m_workArea,
+                    XmNmarginWidth, 0,
+                    XmNmarginHeight, 0,
+                    XmNrightAttachment, XmATTACH_FORM,
+                    XmNleftAttachment, XmATTACH_FORM,
+                    XmNtopAttachment, XmATTACH_FORM,
+                    XmNbottomAttachment, XmATTACH_FORM,
+//                    XmNresizePolicy, XmRESIZE_ANY,
+                    NULL);
+
+  XtVaSetValues((Widget) m_frameWidget,
+    XmNworkWindow, (Widget) m_workArea,
+    NULL);
+
+
+  XtManageChild((Widget) m_clientArea);
+  XtManageChild((Widget) m_workArea);
+
+  wxASSERT_MSG ((wxWidgetHashTable->Get((long)m_workArea) == (wxObject*) NULL), "Widget table clash in frame.cpp") ;
+
+  wxAddWindowToTable((Widget) m_workArea, this);
+
+  XtTranslations ptr ;
+
+  XtOverrideTranslations((Widget) m_workArea,
+              ptr = XtParseTranslationTable("<Configure>: resize()"));
+
+  XtFree((char *)ptr);
+
+  XtAddCallback((Widget) m_workArea, XmNfocusCallback, 
+                (XtCallbackProc)wxFrameFocusProc, (XtPointer)this);
+
+  /* Part of show-&-hide fix */
+  XtAddEventHandler((Widget) m_frameShell, StructureNotifyMask,
+                   False, (XtEventHandler)wxFrameMapProc,
+                   (XtPointer)m_workArea);
+
+  if (x > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNx, x, NULL);
+  if (y > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNy, y, NULL);
+  if (width > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNwidth, width, NULL);
+  if (height > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNheight, height, NULL);
+
+  m_mainWidget = m_frameWidget;
+
+  // This patch comes from Torsten Liermann lier@lier1.muc.de
+  if (XmIsMotifWMRunning( (Widget) wxTheApp->GetTopLevelWidget()))
+  {
+    int decor = 0 ;
+    if (style & wxRESIZE_BORDER)
+      decor |= MWM_DECOR_RESIZEH ;
+    if (style & wxSYSTEM_MENU)
+      decor |= MWM_DECOR_MENU;
+    if ((style & wxCAPTION) ||
+        (style & wxTINY_CAPTION_HORIZ) ||
+        (style & wxTINY_CAPTION_VERT))
+      decor |= MWM_DECOR_TITLE;
+    if (style & wxTHICK_FRAME)
+      decor |= MWM_DECOR_BORDER;
+    if (style & wxTHICK_FRAME)
+      decor |= MWM_DECOR_BORDER;
+    if (style & wxMINIMIZE_BOX)
+      decor |= MWM_DECOR_MINIMIZE;
+    if (style & wxMAXIMIZE_BOX)
+      decor |= MWM_DECOR_MAXIMIZE;
+    XtVaSetValues((Widget) m_frameShell,XmNmwmDecorations,decor,NULL) ;
+  }
+  // This allows non-Motif window managers to support at least the
+  // no-decorations case.
+  else
+  {
+    if (style == 0)
+      XtVaSetValues((Widget) m_frameShell,XmNoverrideRedirect,TRUE,NULL);
+  }
+  XtRealizeWidget((Widget) m_frameShell);
+
+  // Intercept CLOSE messages from the window manager
+  Atom WM_DELETE_WINDOW = XmInternAtom(XtDisplay((Widget) m_frameShell), "WM_DELETE_WINDOW", False);
+#if (XmREVISION > 1 || XmVERSION > 1)
+  XmAddWMProtocolCallback((Widget) m_frameShell, WM_DELETE_WINDOW, (XtCallbackProc) wxCloseFrameCallback, (XtPointer)this);
+#else
+#if XmREVISION == 1
+  XmAddWMProtocolCallback((Widget) m_frameShell, WM_DELETE_WINDOW, (XtCallbackProc) wxCloseFrameCallback, (caddr_t)this);
+#else
+  XmAddWMProtocolCallback((Widget) m_frameShell, WM_DELETE_WINDOW, (void (*)())wxCloseFrameCallback, (caddr_t)this);
+#endif
+#endif
+
+  PreResize();
+
+  wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+  sizeEvent.SetEventObject(this);
+
+  GetEventHandler()->ProcessEvent(sizeEvent);
+
+  return TRUE;
+}
+
+wxFrame::~wxFrame()
+{
+  if (GetMainWidget())
+    Show(FALSE);
+
+  if (m_frameMenuBar)
+  {
+// Hack to stop core dump on Ultrix, OSF, for some strange reason.
+#if MOTIF_MENUBAR_DELETE_FIX
+    GetMenuBar()->SetMainWidget((WXWidget) NULL);
+#endif
+    delete m_frameMenuBar;
+    m_frameMenuBar = NULL;
+  }
+
+  wxTopLevelWindows.DeleteObject(this);
+  wxModelessWindows.DeleteObject(this);
+
+  if (m_frameStatusBar)
+    delete m_frameStatusBar;
+
+  DestroyChildren();
+
+/*
+  int i;
+  for (i = 0; i < wxMAX_STATUS; i++)
+    if (statusTextWidget[i])
+      XtDestroyWidget (statusTextWidget[i]);
+
+  if (statusLineForm)
+    XtDestroyWidget (statusLineForm);
+
+  if (statusLineWidget)
+    XtDestroyWidget (statusLineWidget);
+ */
+
+  wxDeleteWindowFromTable((Widget) m_workArea);
+
+  XtDestroyWidget ((Widget) m_workArea);
+  XtDestroyWidget ((Widget) m_frameWidget);
+
+  wxDeleteWindowFromTable((Widget) m_frameWidget);
+
+  XtDestroyWidget ((Widget) m_frameShell);
+
+  SetMainWidget((WXWidget) NULL);
+
+/* Check if it's the last top-level window */
+
+  if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+  {
+    wxTheApp->SetTopWindow(NULL);
+
+    if (wxTheApp->GetExitOnFrameDelete())
+    {
+       // TODO signal to the app that we're going to close
+       wxTheApp->ExitMainLoop();
+    }
+  }
+
+}
+
+// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
+void wxFrame::GetClientSize(int *x, int *y) const
+{
+  Dimension xx, yy;
+  XtVaGetValues((Widget) m_workArea, XmNwidth, &xx, XmNheight, &yy, NULL);
+
+  /* TODO
+  if (status_line_exists)
+  {
+    Dimension ys;
+    XtVaGetValues(statusLineWidget, XmNheight, &ys, NULL);
+    yy -= ys;
+  }
+  */
+
+  if (GetMenuBar() != (wxMenuBar*) NULL)
+  {
+    // it seems that if a frame holds a panel, the menu bar size
+    // gets automatically taken care of --- grano@cs.helsinki.fi 4.4.95
+    bool hasSubPanel = FALSE;
+    for(wxNode* node = GetChildren()->First(); node; node = node->Next())
+    {
+     wxWindow *win = (wxWindow *)node->Data();
+     hasSubPanel = (win->IsKindOf(CLASSINFO(wxPanel)) && !win->IsKindOf(CLASSINFO(wxDialog)));
+
+      if (hasSubPanel)
+          break;
+    }
+    if (! hasSubPanel) {
+      Dimension ys;
+      XtVaGetValues((Widget) GetMenuBarWidget(), XmNheight, &ys, NULL);
+      yy -= ys;
+    }
+  }
+
+  *x = xx; *y = yy;
+}
+
+// Set the client size (i.e. leave the calculation of borders etc.
+// to wxWindows)
+void wxFrame::SetClientSize(int width, int height)
+{
+  // Calculate how large the new main window should be
+  // by finding the difference between the client area and the
+  // main window area, and adding on to the new client area
+  if (width > -1)
+    XtVaSetValues((Widget) m_workArea, XmNwidth, width, NULL);
+
+  if (height > -1)
+  {
+    /* TODO
+    if (status_line_exists)
+    {
+      Dimension ys;
+      XtVaGetValues(statusLineWidget, XmNheight, &ys, NULL);
+      height += ys;
+    }
+    */
+    XtVaSetValues((Widget) m_workArea, XmNheight, height, NULL);
+  }
+  PreResize();
+
+  wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+  sizeEvent.SetEventObject(this);
+
+  GetEventHandler()->ProcessEvent(sizeEvent);
+
+}
+
+void wxFrame::GetSize(int *width, int *height) const
+{
+  Dimension xx, yy;
+  XtVaGetValues((Widget) m_frameShell, XmNwidth, &xx, XmNheight, &yy, NULL);
+  *width = xx; *height = yy;
+}
+
+void wxFrame::GetPosition(int *x, int *y) const
+{
+    Window parent_window = XtWindow((Widget) m_frameShell),
+          next_parent   = XtWindow((Widget) m_frameShell),
+          root          = RootWindowOfScreen(XtScreen((Widget) m_frameShell));
+
+    // search for the parent that is child of ROOT, because the WM may
+    // reparent twice and notify only the next parent (like FVWM)
+    while (next_parent != root) {
+       Window *theChildren; unsigned int n;
+       parent_window = next_parent;
+       XQueryTree(XtDisplay((Widget) m_frameShell), parent_window, &root,
+                  &next_parent, &theChildren, &n);
+       XFree(theChildren); // not needed
+    }
+    int xx, yy; unsigned int dummy;
+    XGetGeometry(XtDisplay((Widget) m_frameShell), parent_window, &root,
+                &xx, &yy, &dummy, &dummy, &dummy, &dummy);
+    if (x) *x = xx;
+    if (y) *y = yy;
+}
+
+void wxFrame::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+  if (x > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNx, x, NULL);
+  if (y > -1)
+    XtVaSetValues((Widget) m_frameShell, XmNy, y, NULL);
+  if (width > -1)
+    XtVaSetValues((Widget) m_frameWidget, XmNwidth, width, NULL);
+  if (height > -1)
+    XtVaSetValues((Widget) m_frameWidget, XmNheight, height, NULL);
+
+  if (!(height == -1 && width == -1))
+  {
+    PreResize();
+    wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+    sizeEvent.SetEventObject(this);
+
+    GetEventHandler()->ProcessEvent(sizeEvent);
+  }
+}
+
+bool wxFrame::Show(bool show)
+{
+  m_visibleStatus = show; /* show-&-hide fix */
+
+  m_isShown = show;
+  if (show) {
+    XtMapWidget((Widget) m_frameShell);
+    XRaiseWindow(XtDisplay((Widget) m_frameShell), XtWindow((Widget) m_frameShell));
+  } else {
+    XtUnmapWidget((Widget) m_frameShell);
+//    XmUpdateDisplay(wxTheApp->topLevel); // Experimental: may be responsible for crashes
+  }
+  return TRUE;
+}
+
+void wxFrame::Iconize(bool iconize)
+{
+  if (!iconize)
+    Show(TRUE);
+
+  XtVaSetValues((Widget) m_frameShell, XmNiconic, (Boolean)iconize, NULL);
+}
+
+// Equivalent to maximize/restore in Windows
+void wxFrame::Maximize(bool maximize)
+{
+  Show(TRUE);
+
+  if (maximize)
+    XtVaSetValues((Widget) m_frameShell, XmNiconic, FALSE, NULL);
+}
+
+bool wxFrame::IsIconized() const
+{
+  Boolean iconic;
+  XtVaGetValues((Widget) m_frameShell, XmNiconic, &iconic, NULL);
+  return iconic;
+}
+
+void wxFrame::SetTitle(const wxString& title)
+{
+  if (title == m_title)
+    return;
+    
+  m_title = title;
+
+  if (!title.IsNull())
+    XtVaSetValues((Widget) m_frameShell, 
+                  XmNtitle, (const char*) title,
+                  XmNiconName, (const char*) title,
+                  NULL);
+}
+
+void wxFrame::SetIcon(const wxIcon& icon)
+{
+  m_icon = icon;
+
+  // TODO
+  /*
+  if (!icon.Ok() || !icon.GetPixmap())
+    return;
+
+  XtVaSetValues((Widget) m_frameShell, XtNiconPixmap, icon->.GetPixmap(), NULL);
+  */
+}
+
+wxStatusBar *wxFrame::OnCreateStatusBar(int number, long style, wxWindowID id,
+    const wxString& name)
+{
+    wxStatusBar *statusBar = NULL;
+
+    statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20),
+        style, name);
+
+    // Set the height according to the font and the border size
+    wxClientDC dc(statusBar);
+    dc.SetFont(* statusBar->GetFont());
+
+    long x, y;
+    dc.GetTextExtent("X", &x, &y);
+
+    int height = (int)( (y  * 1.1) + 2* statusBar->GetBorderY());
+
+    statusBar->SetSize(-1, -1, 100, height);
+
+    statusBar->SetFieldsCount(number);
+    return statusBar;
+}
+
+wxStatusBar* wxFrame::CreateStatusBar(int number, long style, wxWindowID id,
+    const wxString& name)
+{
+  // Calling CreateStatusBar twice is an error.
+  wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, 
+               "recreating status bar in wxFrame" );
+
+  m_frameStatusBar = OnCreateStatusBar(number, style, id,
+    name);
+  if ( m_frameStatusBar )
+  {
+    PositionStatusBar();
+    return m_frameStatusBar;
+  }
+  else
+    return NULL;
+}
+
+void wxFrame::SetStatusText(const wxString& text, int number)
+{
+  wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
+
+  m_frameStatusBar->SetStatusText(text, number);
+}
+
+void wxFrame::SetStatusWidths(int n, const int widths_field[])
+{
+  wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
+
+  m_frameStatusBar->SetStatusWidths(n, widths_field);
+  PositionStatusBar();
+}
+
+void wxFrame::PositionStatusBar()
+{
+    int w, h;
+    GetClientSize(&w, &h);
+    int sw, sh;
+    m_frameStatusBar->GetSize(&sw, &sh);
+
+    // Since we wish the status bar to be directly under the client area,
+    // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
+    m_frameStatusBar->SetSize(0, h, w, sh);
+}
+
+WXWidget wxFrame::GetMenuBarWidget() const
+{
+  /* TODO
+  if (GetMenuBar())
+    return GetMenuBar()->GetMainWidget();
+  else
+  */
+    return (WXWidget) NULL;
+}
+
+void wxFrame::SetMenuBar(wxMenuBar *menuBar)
+{
+    if (!menuBar)
+    {
+        m_frameMenuBar = NULL;
+        return;
+    }
+
+    // Currently can't set it twice
+    wxASSERT_MSG( (m_frameMenuBar == (wxMenuBar*) NULL), "Cannot set the menubar more than once");
+  
+    m_frameMenuBar = menuBar;
+
+    // TODO
+#if 0
+  Widget menuBarW = XmCreateMenuBar ((Widget) m_frameWidget, "MenuBar", NULL, 0);
+  m_frameMenuBar->SetMainWidget( (WXWidget) menuBarW);
+
+  int i;
+  for (i = 0; i < menuBar->GetMenuCount(); i++)
+    {
+      wxMenu *menu = menuBar->GetMenu(i);
+      menu->SetButtonWidget(menu->CreateMenu (menuBar, menuBarW, menu, menuBar->m_titles[i], TRUE);
+
+      /*
+       * COMMENT THIS OUT IF YOU DON'T LIKE A RIGHT-JUSTIFIED HELP MENU
+       */
+      wxStripMenuCodes (menuBar->m_titles[i], wxBuffer);
+
+      if (strcmp (wxBuffer, "Help") == 0)
+       XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);
+    }
+
+  XtRealizeWidget ((Widget) menuBarW);
+  XtManageChild ((Widget) menuBarW);
+  menuBar->SetMenuBarFrame(this);
+#endif
+}
+
+void wxFrame::Fit()
+{
+  // Work out max. size
+  wxNode *node = GetChildren()->First();
+  int max_width = 0;
+  int max_height = 0;
+  while (node)
+  {
+    // Find a child that's a subwindow, but not a dialog box.
+    wxWindow *win = (wxWindow *)node->Data();
+
+    if (!win->IsKindOf(CLASSINFO(wxFrame)) &&
+         !win->IsKindOf(CLASSINFO(wxDialog)))
+    {
+      int width, height;
+      int x, y;
+      win->GetSize(&width, &height);
+      win->GetPosition(&x, &y);
+
+      if ((x + width) > max_width)
+        max_width = x + width;
+      if ((y + height) > max_height)
+        max_height = y + height;
+    }
+    node = node->Next();
+  }
+  SetClientSize(max_width, max_height);
+}
+
+// Responds to colour changes, and passes event on to children.
+void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
+{
+    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+    Refresh();
+
+    if ( m_frameStatusBar )
+    {
+        wxSysColourChangedEvent event2;
+        event2.SetEventObject( m_frameStatusBar );
+        m_frameStatusBar->ProcessEvent(event2);
+    }
+
+    // Propagate the event to the non-top-level children
+    wxWindow::OnSysColourChanged(event);
+}
+
+// Default resizing behaviour - if only ONE subwindow,
+// resize to client rectangle size
+void wxFrame::OnSize(wxSizeEvent& event)
+{
+  // if we're using constraints - do use them
+  #if USE_CONSTRAINTS
+    if ( GetAutoLayout() ) {
+      Layout();
+      return;
+    }
+  #endif
+
+  // do we have _exactly_ one child?
+  wxWindow *child = NULL;
+  for ( wxNode *node = GetChildren()->First(); node; node = node->Next() )
+  {
+    wxWindow *win = (wxWindow *)node->Data();
+    if ( !win->IsKindOf(CLASSINFO(wxFrame))  &&
+         !win->IsKindOf(CLASSINFO(wxDialog)) && 
+         (win != GetStatusBar()) &&
+         (win != GetToolBar()) )
+    {
+      if ( child )
+        return;     // it's our second subwindow - nothing to do
+      child = win;
+    }
+  }
+
+  if ( child ) {
+    // we have exactly one child - set it's size to fill the whole frame
+    int clientW, clientH;
+    GetClientSize(&clientW, &clientH);
+
+    int x = 0;
+    int y = 0;
+
+    child->SetSize(x, y, clientW, clientH);
+  }
+}
+
+// Default activation behaviour - set the focus for the first child
+// subwindow found.
+void wxFrame::OnActivate(wxActivateEvent& event)
+{
+  for(wxNode *node = GetChildren()->First(); node; node = node->Next())
+  {
+    // Find a child that's a subwindow, but not a dialog box.
+    wxWindow *child = (wxWindow *)node->Data();
+    if (!child->IsKindOf(CLASSINFO(wxFrame)) &&
+         !child->IsKindOf(CLASSINFO(wxDialog)))
+    {
+#if WXDEBUG > 1
+      wxDebugMsg("wxFrame::OnActivate: about to set the child's focus.\n");
+#endif
+      child->SetFocus();
+      return;
+    }
+  }
+}
+
+// The default implementation for the close window event - calls
+// OnClose for backward compatibility.
+
+void wxFrame::OnCloseWindow(wxCloseEvent& event)
+{
+    // Compatibility
+    if ( GetEventHandler()->OnClose() || event.GetForce())
+    {
+        this->Destroy();
+    }
+}
+
+bool wxFrame::OnClose()
+{
+    return TRUE;
+}
+
+// Destroy the window (delayed, if a managed window)
+bool wxFrame::Destroy()
+{
+  if (!wxPendingDelete.Member(this))
+    wxPendingDelete.Append(this);
+  return TRUE;
+}
+
+// Default menu selection behaviour - display a help string
+void wxFrame::OnMenuHighlight(wxMenuEvent& event)
+{
+  if (GetStatusBar())
+  {
+    if (event.GetMenuId() == -1)
+      SetStatusText("");
+    else
+    {
+      wxMenuBar *menuBar = GetMenuBar();
+      if (menuBar)
+      {
+        wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
+        if (helpString != "")
+          SetStatusText(helpString);
+      }
+    }
+  }
+}
+
+wxMenuBar *wxFrame::GetMenuBar() const
+{
+  return m_frameMenuBar;
+}
+
+void wxFrame::Centre(int direction)
+{
+  int display_width, display_height, width, height, x, y;
+  wxDisplaySize(&display_width, &display_height);
+
+  GetSize(&width, &height);
+  GetPosition(&x, &y);
+
+  if (direction & wxHORIZONTAL)
+    x = (int)((display_width - width)/2);
+  if (direction & wxVERTICAL)
+    y = (int)((display_height - height)/2);
+
+  SetSize(x, y, width, height);
+}
+
+// Call this to simulate a menu command
+void wxFrame::Command(int id)
+{
+  ProcessCommand(id);
+}
+
+void wxFrame::ProcessCommand(int id)
+{
+  wxCommandEvent commandEvent(wxEVENT_TYPE_MENU_COMMAND, id);
+  commandEvent.SetInt( id );
+  commandEvent.SetEventObject( this );
+
+  wxMenuBar *bar = GetMenuBar() ;
+  if (!bar)
+    return;
+
+/* TODO: check the menu item if required
+  wxMenuItem *item = bar->FindItemForId(id) ;
+  if (item && item->IsCheckable())
+  {
+    bar->Check(id,!bar->Checked(id)) ;
+  }
+*/
+
+  GetEventHandler()->ProcessEvent(commandEvent);
+}
+
+// Checks if there is a toolbar, and returns the first free client position
+wxPoint wxFrame::GetClientAreaOrigin() const
+{
+    wxPoint pt(0, 0);
+    if (GetToolBar())
+    {
+        int w, h;
+        GetToolBar()->GetSize(& w, & h);
+
+        if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
+        {
+            pt.x += w;
+        }
+        else
+        {
+            pt.y += h;
+        }
+    }
+    return pt;
+}
+
+wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
+{
+    wxCHECK_MSG( m_frameToolBar == NULL, FALSE,
+               "recreating toolbar in wxFrame" );
+
+    wxToolBar* toolBar = OnCreateToolBar(style, id, name);
+    if (toolBar)
+    {
+        SetToolBar(toolBar);
+        PositionToolBar();
+        return toolBar;
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+wxToolBar* wxFrame::OnCreateToolBar(long style, wxWindowID id, const wxString& name)
+{
+    return new wxToolBar(this, id, wxDefaultPosition, wxDefaultSize, style, name);
+}
+
+void wxFrame::PositionToolBar()
+{
+    int cw, ch;
+
+    // TODO: we actually need to use the low-level client size, before
+    // the toolbar/status bar were added.
+    // So DEFINITELY replace the line below with something appropriate.
+
+    GetClientSize(& cw, &ch);
+
+    if ( GetStatusBar() )
+    {
+      int statusX, statusY;
+      GetStatusBar()->GetClientSize(&statusX, &statusY);
+      ch -= statusY;
+    }
+
+    if (GetToolBar())
+    {
+        int tw, th;
+        GetToolBar()->GetSize(& tw, & th);
+
+        if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
+        {
+            // Use the 'real' position. wxSIZE_NO_ADJUSTMENTS
+            // means, pretend we don't have toolbar/status bar, so we
+            // have the original client size.
+            GetToolBar()->SetSize(0, 0, tw, ch, wxSIZE_NO_ADJUSTMENTS);
+        }
+        else
+        {
+            // Use the 'real' position
+            GetToolBar()->SetSize(0, 0, cw, th, wxSIZE_NO_ADJUSTMENTS);
+        }
+    }
+}
+
+void wxFrame::CaptureMouse()
+{
+  if (m_winCaptured)
+    return;
+    
+  if (GetMainWidget())
+    XtAddGrab((Widget) m_frameShell, TRUE, FALSE);
+  m_winCaptured = TRUE;
+}
+
+void wxFrame::ReleaseMouse()
+{
+  if (!m_winCaptured)
+    return;
+    
+  if (GetMainWidget())
+    XtRemoveGrab((Widget) m_frameShell);
+  m_winCaptured = FALSE;
+}
+
+void wxFrame::Raise(void)
+{
+    Window parent_window = XtWindow((Widget) m_frameShell),
+          next_parent   = XtWindow((Widget) m_frameShell),
+          root          = RootWindowOfScreen(XtScreen((Widget) m_frameShell));
+    // search for the parent that is child of ROOT, because the WM may
+    // reparent twice and notify only the next parent (like FVWM)
+    while (next_parent != root) {
+       Window *theChildren; unsigned int n;
+       parent_window = next_parent;
+       XQueryTree(XtDisplay((Widget) m_frameShell), parent_window, &root,
+                  &next_parent, &theChildren, &n);
+       XFree(theChildren); // not needed
+    }
+    XRaiseWindow(XtDisplay((Widget) m_frameShell), parent_window);
+}
+
+void wxFrame::Lower(void)
+{
+    Window parent_window = XtWindow((Widget) m_frameShell),
+          next_parent   = XtWindow((Widget) m_frameShell),
+          root          = RootWindowOfScreen(XtScreen((Widget) m_frameShell));
+    // search for the parent that is child of ROOT, because the WM may
+    // reparent twice and notify only the next parent (like FVWM)
+    while (next_parent != root) {
+       Window *theChildren; unsigned int n;
+       parent_window = next_parent;
+       XQueryTree(XtDisplay((Widget) m_frameShell), parent_window, &root,
+                  &next_parent, &theChildren, &n);
+       XFree(theChildren); // not needed
+    }
+    XLowerWindow(XtDisplay((Widget) m_frameShell), parent_window);
+}
+
+void wxFrame::SetToolBar(wxToolBar *toolbar)
+{ m_frameToolBar = toolbar; }
+
+wxToolBar *wxFrame::GetToolBar() const
+{ return m_frameToolBar; }
+
+static void wxFrameFocusProc(Widget workArea, XtPointer clientData, 
+                      XmAnyCallbackStruct *cbs)
+{
+  wxFrame *frame = (wxFrame *)clientData;
+
+  // wxDebugMsg("focus proc from frame %ld\n",(long)frame);
+  // TODO
+  //  frame->GetEventHandler()->OnSetFocus();
+}
+
+/* MATTEW: Used to insure that hide-&-show within an event cycle works */
+static void wxFrameMapProc(Widget frameShell, XtPointer clientData, 
+                          XCrossingEvent * event)
+{
+  wxFrame *frame = (wxFrame *)wxWidgetHashTable->Get((long)clientData);
+
+  if (frame) {
+    XEvent *e = (XEvent *)event;
+
+    if (e->xany.type == MapNotify)
+    {
+      // Iconize fix
+      XtVaSetValues(frameShell, XmNiconic, (Boolean)False, NULL);
+      if (!frame->GetVisibleStatus())
+      {
+       /* We really wanted this to be hidden! */
+       XtUnmapWidget((Widget) frame->GetShellWidget());
+      }
+    }
+    else if (e->xany.type == UnmapNotify)
+      // Iconize fix
+      XtVaSetValues(frameShell, XmNiconic, (Boolean)True, NULL);
+  }
+}
+
+//// Motif-specific
+bool wxFrame::PreResize()
+{
+  /* TODO
+  // Set status line, if any
+  if (status_line_exists)
+  {
+    Dimension clientW, clientH;
+    XtVaGetValues(clientArea, XmNwidth, &clientW, XmNheight, &clientH, NULL);
+    Dimension xx, yy;
+    XtVaGetValues(statusLineWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
+
+    XtUnmanageChild(statusLineWidget);
+    XtVaSetValues(statusLineWidget, XmNx, 0, XmNy, clientH - yy, XmNwidth, clientW, NULL);
+
+    if (statusLineForm)
+      XtVaSetValues(statusLineForm,  XmNwidth, clientW, NULL);
+
+    XtManageChild(statusLineWidget);
+  }
+
+  int width, height;
+  GetSize(&width, &height);
+
+  if (width == lastWidth && height == lastHeight)
+    return FALSE;
+  else
+  {
+    return TRUE;
+  }
+  */
+  return TRUE;
+}
+
+void wxCloseFrameCallback(Widget widget, XtPointer client_data, XmAnyCallbackStruct *cbs)
+{
+  wxFrame *frame = (wxFrame *)client_data;
+
+  wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW, frame->GetId());
+  closeEvent.SetEventObject(frame);
+
+  // May delete the frame (with delayed deletion)
+  frame->GetEventHandler()->ProcessEvent(closeEvent);
+}

diff --git a/src/motif/gauge.cpp b/src/motif/gauge.cpp
new file mode 100644 (file)
index 0000000..d756fc4
--- /dev/null
+++ b/src/motif/gauge.cpp
@@ -0,0 +1,95 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        gauge.cpp
+// Purpose:     wxGauge class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "gauge.h"
+#endif
+
+#include "wx/gauge.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
+#endif
+
+bool wxGauge::Create(wxWindow *parent, wxWindowID id,
+           int range,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+    m_rangeMax = range;
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+
+    // TODO
+    return FALSE;
+}
+
+void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxGauge::SetShadowWidth(int w)
+{
+    // TODO optional
+}
+
+void wxGauge::SetBezelFace(int w)
+{
+    // TODO optional
+}
+
+void wxGauge::SetRange(int r)
+{
+    m_rangeMax = r;
+    // TODO
+}
+
+void wxGauge::SetValue(int pos)
+{
+    m_gaugePos = pos;
+    // TODO
+}
+
+int wxGauge::GetShadowWidth() const
+{
+    // TODO optional
+    return 0;
+}
+
+int wxGauge::GetBezelFace() const
+{
+    // TODO optional
+    return 0;
+}
+
+int wxGauge::GetRange() const
+{
+    return m_rangeMax;
+}
+
+int wxGauge::GetValue() const
+{
+    return m_gaugePos;
+}
+

diff --git a/src/motif/gdiobj.cpp b/src/motif/gdiobj.cpp
new file mode 100644 (file)
index 0000000..0d9e4fe
--- /dev/null
+++ b/src/motif/gdiobj.cpp
@@ -0,0 +1,22 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        gdiobj.cpp
+// Purpose:     wxGDIObject class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "gdiobj.h"
+#endif
+
+#include "wx/gdiobj.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject)
+#endif
+
+// TODO: Nothing to do, unless you want to.

diff --git a/src/motif/helpxxxx.cpp b/src/motif/helpxxxx.cpp
new file mode 100644 (file)
index 0000000..0214bc2
--- /dev/null
+++ b/src/motif/helpxxxx.cpp
@@ -0,0 +1,83 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpxxxx.cpp
+// Purpose:     Help system: native implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "helpxxxx.h"
+#endif
+
+#include "wx/stubs/helpxxxx.h"
+
+#include <string.h>
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxXXXXHelpController, wxHelpControllerBase)
+#endif
+
+wxXXXXHelpController::wxXXXXHelpController()
+{
+    m_helpFile = "";
+}
+
+wxXXXXHelpController::~wxXXXXHelpController()
+{
+}
+
+bool wxXXXXHelpController::Initialize(const wxString& filename)
+{
+    m_helpFile = filename;
+    // TODO any other inits
+    return TRUE;
+}
+
+bool wxXXXXHelpController::LoadFile(const wxString& file)
+{
+    m_helpFile = file;
+    // TODO
+    return TRUE;
+}
+
+bool wxXXXXHelpController::DisplayContents()
+{
+    // TODO
+       return FALSE;
+}
+
+bool wxXXXXHelpController::DisplaySection(int section)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxXXXXHelpController::DisplayBlock(long block)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxXXXXHelpController::KeywordSearch(const wxString& k)
+{
+    if (m_helpFile == "") return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+// Can't close the help window explicitly in WinHelp
+bool wxXXXXHelpController::Quit()
+{
+    // TODO
+    return FALSE;
+}
+
+void wxXXXXHelpController::OnQuit()
+{
+}
+

diff --git a/src/motif/icon.cpp b/src/motif/icon.cpp
new file mode 100644 (file)
index 0000000..834c9ff
--- /dev/null
+++ b/src/motif/icon.cpp
@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        icon.cpp
+// Purpose:     wxIcon class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "icon.h"
+#endif
+
+#include "wx/icon.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
+#endif
+
+/*
+ * Icons
+ */
+
+
+wxIconRefData::wxIconRefData()
+{
+    // TODO: init icon handle
+}
+
+wxIconRefData::~wxIconRefData()
+{
+    // TODO: destroy icon handle
+}
+
+wxIcon::wxIcon()
+{
+}
+
+wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
+{
+}
+
+wxIcon::wxIcon(const wxString& icon_file, long flags,
+    int desiredWidth, int desiredHeight)
+
+{
+    LoadFile(icon_file, flags, desiredWidth, desiredHeight);
+}
+
+wxIcon::~wxIcon()
+{
+}
+
+bool wxIcon::LoadFile(const wxString& filename, long type,
+    int desiredWidth, int desiredHeight)
+{
+  UnRef();
+
+  m_refData = new wxIconRefData;
+
+  wxBitmapHandler *handler = FindHandler(type);
+
+  if ( handler )
+       return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
+  else
+       return FALSE;
+}
+

diff --git a/src/motif/imaglist.cpp b/src/motif/imaglist.cpp
new file mode 100644 (file)
index 0000000..81ec051
--- /dev/null
+++ b/src/motif/imaglist.cpp
@@ -0,0 +1,118 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        imaglist.cpp
+// Purpose:     wxImageList. You may wish to use the generic version.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "imaglist.h"
+#endif
+
+#include "wx/stubs/imaglist.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
+#endif
+
+wxImageList::wxImageList()
+{
+    // TODO: init image list handle, if any
+}
+
+wxImageList::~wxImageList()
+{
+    // TODO: destroy image list handle, if any
+}
+
+
+// Attributes
+////////////////////////////////////////////////////////////////////////////
+
+// Returns the number of images in the image list.
+int wxImageList::GetImageCount() const
+{
+    // TODO
+       return 0;
+}
+
+// Operations
+////////////////////////////////////////////////////////////////////////////
+
+// Creates an image list
+bool wxImageList::Create(int width, int height, bool mask, int initial)
+{
+    // TODO
+    return FALSE;
+}
+
+// Adds a bitmap, and optionally a mask bitmap.
+// Note that wxImageList creates new bitmaps, so you may delete
+// 'bitmap' and 'mask'.
+int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
+{
+    // TODO
+    return 0;
+}
+
+// Adds a bitmap, using the specified colour to create the mask bitmap
+// Note that wxImageList creates new bitmaps, so you may delete
+// 'bitmap'.
+int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
+{
+    // TODO
+    return 0;
+}
+
+// Adds a bitmap and mask from an icon.
+int wxImageList::Add(const wxIcon& icon)
+{
+    // TODO
+    return 0;
+}
+
+// Replaces a bitmap, optionally passing a mask bitmap.
+// Note that wxImageList creates new bitmaps, so you may delete
+// 'bitmap' and 'mask'.
+bool wxImageList::Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask)
+{
+    // TODO
+    return 0;
+}
+
+// Replaces a bitmap and mask from an icon.
+bool wxImageList::Replace(int index, const wxIcon& icon)
+{
+    // TODO
+    return 0;
+}
+
+// Removes the image at the given index.
+bool wxImageList::Remove(int index)
+{
+    // TODO
+    return FALSE;
+}
+
+// Remove all images
+bool wxImageList::RemoveAll()
+{
+    // TODO
+    return FALSE;
+}
+
+// Draws the given image on a dc at the specified position.
+// If 'solidBackground' is TRUE, Draw sets the image list background
+// colour to the background colour of the wxDC, to speed up
+// drawing by eliminating masked drawing where possible.
+bool wxImageList::Draw(int index, wxDC& dc, int x, int y,
+    int flags, bool solidBackground)
+{
+    // TODO
+    return FALSE;
+}
+

diff --git a/src/motif/joystick.cpp b/src/motif/joystick.cpp
new file mode 100644 (file)
index 0000000..d6fc022
--- /dev/null
+++ b/src/motif/joystick.cpp
@@ -0,0 +1,279 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        joystick.cpp
+// Purpose:     wxJoystick class
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "joystick.h"
+#endif
+
+#include <wx/joystick.h>
+
+IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
+
+// Attributes
+////////////////////////////////////////////////////////////////////////////
+
+wxPoint wxJoystick::GetPosition() const
+{
+    // TODO
+    return wxPoint(0, 0);
+}
+
+int wxJoystick::GetZPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetButtonState() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetPOVPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetPOVCTSPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetRudderPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetUPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetVPosition() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetMovementThreshold() const
+{
+    // TODO
+    return 0;
+}
+
+void wxJoystick::SetMovementThreshold(int threshold)
+{
+    // TODO
+}
+
+// Capabilities
+////////////////////////////////////////////////////////////////////////////
+
+bool wxJoystick::IsOk() const
+{
+    // TODO
+    return FALSE;
+}
+
+int wxJoystick::GetNumberJoysticks() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetManufacturerId() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetProductId() const
+{
+    // TODO
+    return 0;
+}
+
+wxString wxJoystick::GetProductName() const
+{
+    // TODO
+    return wxString("");
+}
+
+int wxJoystick::GetXMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetYMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetZMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetXMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetYMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetZMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetNumberButtons() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetNumberAxes() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetMaxButtons() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetMaxAxes() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetPollingMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetPollingMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetRudderMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetRudderMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetUMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetUMax() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetVMin() const
+{
+    // TODO
+    return 0;
+}
+
+int wxJoystick::GetVMax() const
+{
+    // TODO
+    return 0;
+}
+
+bool wxJoystick::HasRudder() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasZ() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasU() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasV() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasPOV() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasPOV4Dir() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::HasPOVCTS() const
+{
+    // TODO
+    return FALSE;
+}
+
+// Operations
+////////////////////////////////////////////////////////////////////////////
+
+bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxJoystick::ReleaseCapture()
+{
+    // TODO
+    return FALSE;
+}
+

diff --git a/src/motif/listbox.cpp b/src/motif/listbox.cpp
new file mode 100644 (file)
index 0000000..9352c32
--- /dev/null
+++ b/src/motif/listbox.cpp
@@ -0,0 +1,235 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        listbox.cpp
+// Purpose:     wxListBox
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "listbox.h"
+#endif
+
+#include "wx/listbox.h"
+#include "wx/settings.h"
+#include "wx/dynarray.h"
+#include "wx/log.h"
+
+#if !USE_SHARED_LIBRARY
+  IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
+#endif
+
+// ============================================================================
+// list box control implementation
+// ============================================================================
+
+// Listbox item
+wxListBox::wxListBox()
+{
+  m_noItems = 0;
+  m_selected = 0;
+}
+
+bool wxListBox::Create(wxWindow *parent, wxWindowID id,
+                       const wxPoint& pos,
+                       const wxSize& size,
+                       int n, const wxString choices[],
+                       long style,
+                       const wxValidator& validator,
+                       const wxString& name)
+{
+  m_noItems = n;
+  m_selected = 0;
+
+  SetName(name);
+  SetValidator(validator);
+
+  if (parent) parent->AddChild(this);
+
+  wxSystemSettings settings;
+  SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+
+  m_windowId = ( id == -1 ) ? (int)NewControlId() : id;
+
+  // TODO create listbox
+
+  return FALSE;
+}
+
+wxListBox::~wxListBox()
+{
+}
+
+void wxListBox::SetFirstItem(int N)
+{
+    // TODO
+}
+
+void wxListBox::SetFirstItem(const wxString& s)
+{
+    // TODO
+}
+
+void wxListBox::Delete(int N)
+{
+  m_noItems --;
+    // TODO
+}
+
+void wxListBox::Append(const wxString& item)
+{
+  m_noItems ++;
+
+  // TODO
+}
+
+void wxListBox::Append(const wxString& item, char *Client_data)
+{
+  m_noItems ++;
+
+  // TODO
+}
+
+void wxListBox::Set(int n, const wxString *choices, char** clientData)
+{
+  m_noItems = n;
+
+  // TODO
+}
+
+int wxListBox::FindString(const wxString& s) const
+{
+    // TODO
+    return -1;
+}
+
+void wxListBox::Clear()
+{
+  m_noItems = 0;
+  // TODO
+}
+
+void wxListBox::SetSelection(int N, bool select)
+{
+    // TODO
+}
+
+bool wxListBox::Selected(int N) const
+{
+    // TODO
+    return FALSE;
+}
+
+void wxListBox::Deselect(int N)
+{
+    // TODO
+}
+
+char *wxListBox::GetClientData(int N) const
+{
+    // TODO
+    return (char *)NULL;
+}
+
+void wxListBox::SetClientData(int N, char *Client_data)
+{
+    // TODO
+}
+
+// Return number of selections and an array of selected integers
+int wxListBox::GetSelections(wxArrayInt& aSelections) const
+{
+    aSelections.Empty();
+
+/* TODO
+    if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
+    {
+        int no_sel = ??
+        for ( int n = 0; n < no_sel; n++ )
+            aSelections.Add(??);
+
+        return no_sel;
+    }
+    else  // single-selection listbox
+    {
+        aSelections.Add(??);
+
+        return 1;
+    }
+*/
+    return 0;
+}
+
+// Get single selection, for single choice list items
+int wxListBox::GetSelection() const
+{
+    // TODO
+    return -1;
+}
+
+// Find string for position
+wxString wxListBox::GetString(int N) const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxListBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxListBox::InsertItems(int nItems, const wxString items[], int pos)
+{
+    m_noItems += nItems;
+
+    // TODO
+}
+
+void wxListBox::SetString(int N, const wxString& s)
+{
+    // TODO
+}
+
+int wxListBox::Number () const
+{
+  return m_noItems;
+}
+
+// For single selection items only
+wxString wxListBox::GetStringSelection () const
+{
+  int sel = GetSelection ();
+  if (sel > -1)
+    return this->GetString (sel);
+  else
+    return wxString("");
+}
+
+bool wxListBox::SetStringSelection (const wxString& s, bool flag)
+{
+  int sel = FindString (s);
+  if (sel > -1)
+    {
+      SetSelection (sel, flag);
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+void wxListBox::Command (wxCommandEvent & event)
+{
+  if (event.m_extraLong)
+    SetSelection (event.m_commandInt);
+  else
+    {
+      Deselect (event.m_commandInt);
+      return;
+    }
+  ProcessCommand (event);
+}
+

diff --git a/src/motif/listctrl.cpp b/src/motif/listctrl.cpp
new file mode 100644 (file)
index 0000000..f82c2fd
--- /dev/null
+++ b/src/motif/listctrl.cpp
@@ -0,0 +1,596 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        listctrl.cpp
+// Purpose:     wxListCtrl. See also Robert's generic wxListCtrl
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "listctrl.h"
+#endif
+
+#include "wx/stubs/textctrl.h"
+#include "wx/stubs/listctrl.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
+
+#endif
+
+wxListCtrl::wxListCtrl()
+{
+       m_imageListNormal = NULL;
+       m_imageListSmall = NULL;
+       m_imageListState = NULL;
+       m_baseStyle = 0;
+    m_colCount = 0;
+}
+
+bool wxListCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxValidator& validator, const wxString& name)
+{
+    m_imageListNormal = NULL;
+    m_imageListSmall = NULL;
+    m_imageListState = NULL;
+    m_colCount = 0;
+
+    SetValidator(validator);
+    SetName(name);
+
+    m_windowStyle = style;
+
+    SetParent(parent);
+
+    m_windowId = (id == -1) ? NewControlId() : id;
+
+    if (parent) parent->AddChild(this);
+
+    // TODO create list control
+    return TRUE;
+}
+
+wxListCtrl::~wxListCtrl()
+{
+}
+
+// Add or remove a single window style
+void wxListCtrl::SetSingleStyle(long style, bool add)
+{
+       long flag = GetWindowStyleFlag();
+
+       // Get rid of conflicting styles
+       if ( add )
+       {
+               if ( style & wxLC_MASK_TYPE)
+                       flag = flag & ~wxLC_MASK_TYPE ;
+               if ( style & wxLC_MASK_ALIGN )
+                       flag = flag & ~wxLC_MASK_ALIGN ;
+               if ( style & wxLC_MASK_SORT )
+                       flag = flag & ~wxLC_MASK_SORT ;
+        }
+
+       if ( flag & style )
+       {
+               if ( !add )
+                       flag -= style;
+       }
+       else
+       {
+               if ( add )
+               {
+                       flag |= style;
+               }
+       }
+
+       m_windowStyle = flag;
+
+       /* TODO RecreateWindow(); */
+}
+
+// Set the whole window style
+void wxListCtrl::SetWindowStyleFlag(long flag)
+{
+       m_windowStyle = flag;
+
+       /* TODO RecreateWindow(); */
+}
+
+
+// Gets information about this column
+bool wxListCtrl::GetColumn(int col, wxListItem& item) const
+{
+       // TODO
+    return FALSE;
+}
+
+// Sets information about this column
+bool wxListCtrl::SetColumn(int col, wxListItem& item)
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the column width
+int wxListCtrl::GetColumnWidth(int col) const
+{
+       // TODO
+    return 0;
+}
+
+// Sets the column width
+bool wxListCtrl::SetColumnWidth(int col, int width)
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the number of items that can fit vertically in the
+// visible area of the list control (list or report view)
+// or the total number of items in the list control (icon
+// or small icon view)
+int wxListCtrl::GetCountPerPage() const
+{
+       // TODO
+    return 0;
+}
+
+// Gets the edit control for editing labels.
+wxTextCtrl* wxListCtrl::GetEditControl() const
+{
+       return m_textCtrl;
+}
+
+// Gets information about the item
+bool wxListCtrl::GetItem(wxListItem& info) const
+{
+       // TODO
+    return FALSE;
+}
+
+// Sets information about the item
+bool wxListCtrl::SetItem(wxListItem& info)
+{
+       // TODO
+    return FALSE;
+}
+
+long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
+{
+       wxListItem info;
+       info.m_text = label;
+       info.m_mask = wxLIST_MASK_TEXT;
+       info.m_itemId = index;
+       info.m_col = col;
+       if ( imageId > -1 )
+       {
+               info.m_image = imageId;
+               info.m_mask |= wxLIST_MASK_IMAGE;
+       }
+       return SetItem(info);
+}
+
+
+// Gets the item state
+int wxListCtrl::GetItemState(long item, long stateMask) const
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_STATE ;
+       info.m_stateMask = stateMask;
+       info.m_itemId = item;
+
+       if (!GetItem(info))
+               return 0;
+
+       return info.m_state;
+}
+
+// Sets the item state
+bool wxListCtrl::SetItemState(long item, long state, long stateMask)
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_STATE ;
+       info.m_state = state;
+       info.m_stateMask = stateMask;
+       info.m_itemId = item;
+
+       return SetItem(info);
+}
+
+// Sets the item image
+bool wxListCtrl::SetItemImage(long item, int image, int selImage)
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_IMAGE ;
+       info.m_image = image;
+       info.m_itemId = item;
+
+       return SetItem(info);
+}
+
+// Gets the item text
+wxString wxListCtrl::GetItemText(long item) const
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_TEXT ;
+       info.m_itemId = item;
+
+       if (!GetItem(info))
+               return wxString("");
+       return info.m_text;
+}
+
+// Sets the item text
+void wxListCtrl::SetItemText(long item, const wxString& str)
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_TEXT ;
+       info.m_itemId = item;
+       info.m_text = str;
+
+       SetItem(info);
+}
+
+// Gets the item data
+long wxListCtrl::GetItemData(long item) const
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_DATA ;
+       info.m_itemId = item;
+
+       if (!GetItem(info))
+               return 0;
+       return info.m_data;
+}
+
+// Sets the item data
+bool wxListCtrl::SetItemData(long item, long data)
+{
+       wxListItem info;
+
+       info.m_mask = wxLIST_MASK_DATA ;
+       info.m_itemId = item;
+       info.m_data = data;
+
+       return SetItem(info);
+}
+
+// Gets the item rectangle
+bool wxListCtrl::GetItemRect(long item, wxRectangle& rect, int code) const
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the item position
+bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
+{
+       // TODO
+    return FALSE;
+}
+
+// Sets the item position.
+bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the number of items in the list control
+int wxListCtrl::GetItemCount() const
+{
+       // TODO
+    return FALSE;
+}
+
+// Retrieves the spacing between icons in pixels.
+// If small is TRUE, gets the spacing for the small icon
+// view, otherwise the large icon view.
+int wxListCtrl::GetItemSpacing(bool isSmall) const
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the number of selected items in the list control
+int wxListCtrl::GetSelectedItemCount() const
+{
+       // TODO
+    return FALSE;
+}
+
+// Gets the text colour of the listview
+wxColour wxListCtrl::GetTextColour() const
+{
+       // TODO
+    return wxColour();
+}
+
+// Sets the text colour of the listview
+void wxListCtrl::SetTextColour(const wxColour& col)
+{
+       // TODO
+}
+
+// Gets the index of the topmost visible item when in
+// list or report view
+long wxListCtrl::GetTopItem() const
+{
+       // TODO
+    return 0;
+}
+
+// Searches for an item, starting from 'item'.
+// 'geometry' is one of
+// wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
+// 'state' is a state bit flag, one or more of
+// wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
+// item can be -1 to find the first item that matches the
+// specified flags.
+// Returns the item or -1 if unsuccessful.
+long wxListCtrl::GetNextItem(long item, int geom, int state) const
+{
+       // TODO
+    return 0;
+}
+
+wxImageList *wxListCtrl::GetImageList(int which) const
+{
+       if ( which == wxIMAGE_LIST_NORMAL )
+    {
+               return m_imageListNormal;
+       }
+       else if ( which == wxIMAGE_LIST_SMALL )
+    {
+               return m_imageListSmall;
+       }
+       else if ( which == wxIMAGE_LIST_STATE )
+    {
+               return m_imageListState;
+       }
+       return NULL;
+}
+
+void wxListCtrl::SetImageList(wxImageList *imageList, int which)
+{
+       int flags = 0;
+       if ( which == wxIMAGE_LIST_NORMAL )
+    {
+               m_imageListNormal = imageList;
+       }
+       else if ( which == wxIMAGE_LIST_SMALL )
+    {
+               m_imageListSmall = imageList;
+       }
+       else if ( which == wxIMAGE_LIST_STATE )
+    {
+               m_imageListState = imageList;
+       }
+       // TODO set image list
+}
+
+// Operations
+////////////////////////////////////////////////////////////////////////////
+
+// Arranges the items
+bool wxListCtrl::Arrange(int flag)
+{
+       // TODO
+    return FALSE;
+}
+
+// Deletes an item
+bool wxListCtrl::DeleteItem(long item)
+{
+       // TODO
+    return FALSE;
+}
+
+// Deletes all items
+bool wxListCtrl::DeleteAllItems()
+{
+       // TODO
+    return FALSE;
+}
+
+// Deletes all items
+bool wxListCtrl::DeleteAllColumns()
+{
+       // TODO
+    return FALSE;
+}
+
+// Deletes a column
+bool wxListCtrl::DeleteColumn(int col)
+{
+       // TODO
+    return FALSE;
+}
+
+// Clears items, and columns if there are any.
+void wxListCtrl::ClearAll()
+{
+    DeleteAllItems();
+    if ( m_colCount > 0 )
+        DeleteAllColumns();
+}
+
+// Edit the label
+wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
+{
+    // TODO
+    return NULL;
+}
+
+// End label editing, optionally cancelling the edit
+bool wxListCtrl::EndEditLabel(bool cancel)
+{
+    // TODO
+    return FALSE;
+}
+
+// Ensures this item is visible
+bool wxListCtrl::EnsureVisible(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+// Find an item whose label matches this string, starting from the item after 'start'
+// or the beginning if 'start' is -1.
+long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
+{
+    // TODO
+    return FALSE;
+}
+
+// Find an item whose data matches this data, starting from the item after 'start'
+// or the beginning if 'start' is -1.
+long wxListCtrl::FindItem(long start, long data)
+{
+    // TODO
+    return 0;
+}
+
+// Find an item nearest this position in the specified direction, starting from
+// the item after 'start' or the beginning if 'start' is -1.
+long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
+{
+    // TODO
+    return 0;
+}
+
+// Determines which item (if any) is at the specified point,
+// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
+long wxListCtrl::HitTest(const wxPoint& point, int& flags)
+{
+    // TODO
+    return 0;
+}
+
+// Inserts an item, returning the index of the new item if successful,
+// -1 otherwise.
+long wxListCtrl::InsertItem(wxListItem& info)
+{
+    // TODO
+    return 0;
+}
+
+long wxListCtrl::InsertItem(long index, const wxString& label)
+{
+       wxListItem info;
+       info.m_text = label;
+       info.m_mask = wxLIST_MASK_TEXT;
+       info.m_itemId = index;
+       return InsertItem(info);
+}
+
+// Inserts an image item
+long wxListCtrl::InsertItem(long index, int imageIndex)
+{
+       wxListItem info;
+       info.m_image = imageIndex;
+       info.m_mask = wxLIST_MASK_IMAGE;
+       info.m_itemId = index;
+       return InsertItem(info);
+}
+
+// Inserts an image/string item
+long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
+{
+       wxListItem info;
+       info.m_image = imageIndex;
+       info.m_text = label;
+       info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
+       info.m_itemId = index;
+       return InsertItem(info);
+}
+
+// For list view mode (only), inserts a column.
+long wxListCtrl::InsertColumn(long col, wxListItem& item)
+{
+    // TODO
+    return 0;
+}
+
+long wxListCtrl::InsertColumn(long col, const wxString& heading, int format,
+    int width)
+{
+       wxListItem item;
+       item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
+       item.m_text = heading;
+       if ( width > -1 )
+       {
+               item.m_mask |= wxLIST_MASK_WIDTH;
+               item.m_width = width;
+       }
+       item.m_format = format;
+
+       return InsertColumn(col, item);
+}
+
+// Scrolls the list control. If in icon, small icon or report view mode,
+// x specifies the number of pixels to scroll. If in list view mode, x
+// specifies the number of columns to scroll.
+// If in icon, small icon or list view mode, y specifies the number of pixels
+// to scroll. If in report view mode, y specifies the number of lines to scroll.
+bool wxListCtrl::ScrollList(int dx, int dy)
+{
+    // TODO
+    return FALSE;
+}
+
+// Sort items.
+
+// fn is a function which takes 3 long arguments: item1, item2, data.
+// item1 is the long data associated with a first item (NOT the index).
+// item2 is the long data associated with a second item (NOT the index).
+// data is the same value as passed to SortItems.
+// The return value is a negative number if the first item should precede the second
+// item, a positive number of the second item should precede the first,
+// or zero if the two items are equivalent.
+
+// data is arbitrary data to be passed to the sort function.
+bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
+{
+    // TODO
+    return FALSE;
+}
+
+// List item structure
+wxListItem::wxListItem()
+{
+    m_mask = 0;
+    m_itemId = 0;
+    m_col = 0;
+    m_state = 0;
+    m_stateMask = 0;
+    m_image = 0;
+       m_data = 0;
+
+       m_format = wxLIST_FORMAT_CENTRE;
+       m_width = 0;
+}
+
+// List event
+IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxCommandEvent)
+
+wxListEvent::wxListEvent(wxEventType commandType, int id):
+  wxCommandEvent(commandType, id)
+{
+       m_code = 0;
+       m_itemIndex = 0;
+       m_col = 0;
+       m_cancelled = FALSE;
+}
+

diff --git a/src/motif/main.cpp b/src/motif/main.cpp
new file mode 100644 (file)
index 0000000..dc27c4a
--- /dev/null
+++ b/src/motif/main.cpp
@@ -0,0 +1,18 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        main.cpp
+// Purpose:     Entry point
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/app.h"
+
+int main(int argc, char* argv[])
+{
+  return wxEntry(argc, argv);
+}
+

diff --git a/src/motif/mdi.cpp b/src/motif/mdi.cpp
new file mode 100644 (file)
index 0000000..b168519
--- /dev/null
+++ b/src/motif/mdi.cpp
@@ -0,0 +1,265 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        mdi.cpp
+// Purpose:     MDI classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "mdi.h"
+#endif
+
+#include "wx/mdi.h"
+#include "wx/menu.h"
+#include "wx/settings.h"
+
+extern wxList wxModelessWindows;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
+
+BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
+  EVT_SIZE(wxMDIParentFrame::OnSize)
+  EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
+  EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
+END_EVENT_TABLE()
+
+BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
+  EVT_SCROLL(wxMDIClientWindow::OnScroll)
+END_EVENT_TABLE()
+
+#endif
+
+// Parent frame
+
+wxMDIParentFrame::wxMDIParentFrame()
+{
+}
+
+bool wxMDIParentFrame::Create(wxWindow *parent,
+           wxWindowID id,
+           const wxString& title,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+    if (!parent)
+        wxTopLevelWindows.Append(this);
+
+    SetName(name);
+    m_windowStyle = style;
+
+    if (parent) parent->AddChild(this);
+
+    if ( id > -1 )
+        m_windowId = id;
+    else
+        m_windowId = (int)NewControlId();
+
+    // TODO: create MDI parent frame
+
+    wxModelessWindows.Append(this);
+
+    return TRUE;
+}
+
+wxMDIParentFrame::~wxMDIParentFrame()
+{
+}
+
+// Get size *available for subwindows* i.e. excluding menu bar.
+void wxMDIParentFrame::GetClientSize(int *x, int *y) const
+{
+    // TODO
+}
+
+void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
+{
+    // TODO
+    if (!menu_bar)
+    {
+        m_frameMenuBar = NULL;
+        return;
+    }
+  
+    if (menu_bar->m_menuBarFrame)
+           return;
+
+    m_frameMenuBar = menu_bar;
+}
+
+void wxMDIParentFrame::OnSize(wxSizeEvent& event)
+{
+#if USE_CONSTRAINTS
+    if (GetAutoLayout())
+      Layout();
+#endif
+    int x = 0;
+    int y = 0;
+    int width, height;
+    GetClientSize(&width, &height);
+
+    if ( GetClientWindow() )
+        GetClientWindow()->SetSize(x, y, width, height);
+}
+
+void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
+{
+       // Do nothing
+}
+
+// Returns the active MDI child window
+wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
+{
+    // TODO
+    return NULL;
+}
+
+// Create the client window class (don't Create the window,
+// just return a new class)
+wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
+{
+       return new wxMDIClientWindow ;
+}
+
+// Responds to colour changes, and passes event on to children.
+void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
+{
+    // TODO
+
+    // Propagate the event to the non-top-level children
+    wxFrame::OnSysColourChanged(event);
+}
+
+// MDI operations
+void wxMDIParentFrame::Cascade()
+{
+    // TODO
+}
+
+void wxMDIParentFrame::Tile()
+{
+    // TODO
+}
+
+void wxMDIParentFrame::ArrangeIcons()
+{
+    // TODO
+}
+
+void wxMDIParentFrame::ActivateNext()
+{
+    // TODO
+}
+
+void wxMDIParentFrame::ActivatePrevious()
+{
+    // TODO
+}
+
+// Child frame
+
+wxMDIChildFrame::wxMDIChildFrame()
+{
+}
+
+bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
+           wxWindowID id,
+           const wxString& title,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+    SetName(name);
+
+    if ( id > -1 )
+        m_windowId = id;
+    else
+        m_windowId = (int)NewControlId();
+
+    if (parent) parent->AddChild(this);
+
+    // TODO: create child frame
+
+    wxModelessWindows.Append(this);
+    return FALSE;
+}
+
+wxMDIChildFrame::~wxMDIChildFrame()
+{
+}
+
+// Set the client size (i.e. leave the calculation of borders etc.
+// to wxWindows)
+void wxMDIChildFrame::SetClientSize(int width, int height)
+{
+    // TODO
+}
+
+void wxMDIChildFrame::GetPosition(int *x, int *y) const
+{
+    // TODO
+}
+
+void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
+{
+    // TODO
+    if (!menu_bar)
+    {
+        m_frameMenuBar = NULL;
+        return;
+    }
+  
+    if (menu_bar->m_menuBarFrame)
+           return;
+    m_frameMenuBar = menu_bar;
+}
+
+// MDI operations
+void wxMDIChildFrame::Maximize()
+{
+    // TODO
+}
+
+void wxMDIChildFrame::Restore()
+{
+    // TODO
+}
+
+void wxMDIChildFrame::Activate()
+{
+    // TODO
+}
+
+// Client window
+
+wxMDIClientWindow::wxMDIClientWindow()
+{
+}
+
+wxMDIClientWindow::~wxMDIClientWindow()
+{
+}
+
+bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
+{
+    // TODO create client window
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
+
+    return FALSE;
+}
+
+// Explicitly call default scroll behaviour
+void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
+{
+    Default(); // Default processing
+}
+

diff --git a/src/motif/menu.cpp b/src/motif/menu.cpp
new file mode 100644 (file)
index 0000000..468ed19
--- /dev/null
+++ b/src/motif/menu.cpp
@@ -0,0 +1,598 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        menu.cpp
+// Purpose:     wxMenu, wxMenuBar, wxMenuItem
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+// ============================================================================
+// headers & declarations
+// ============================================================================
+
+// wxWindows headers
+// -----------------
+
+#ifdef __GNUG__
+#pragma implementation "menu.h"
+#pragma implementation "menuitem.h"
+#endif
+
+#include "wx/menu.h"
+#include "wx/menuitem.h"
+#include "wx/log.h"
+#include "wx/utils.h"
+
+#include <Xm/Label.h>
+#include <Xm/LabelG.h>
+#include <Xm/CascadeBG.h>
+#include <Xm/CascadeB.h>
+#include <Xm/SeparatoG.h>
+#include <Xm/PushBG.h>
+#include <Xm/ToggleB.h>
+#include <Xm/ToggleBG.h>
+#include <Xm/RowColumn.h>
+
+// other standard headers
+// ----------------------
+#include <string.h>
+
+void wxMenuItemCallback (Widget w, XtPointer clientData,
+                        XtPointer ptr);
+void wxMenuItemArmCallback (Widget w, XtPointer clientData,
+                           XtPointer ptr);
+void wxMenuItemDisarmCallback (Widget w, XtPointer clientData,
+                              XtPointer ptr);
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
+#endif
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// Menus
+
+// Construct a menu with optional title (then use append)
+wxMenu::wxMenu(const wxString& title, const wxFunction func)
+{
+    m_title = title;
+    m_parent = (wxEvtHandler*) NULL;
+    m_eventHandler = this;
+    m_noItems = 0;
+    m_menuBar = NULL;
+
+    //// Motif-specific members
+    m_numColumns = 1;
+    m_menuWidget = (WXWidget) NULL;
+    m_popupShell = (WXWidget) NULL;
+    m_buttonWidget = (WXWidget) NULL;
+    m_menuId = 0;
+    m_topMenu  = (wxMenu*) NULL;
+    m_ownedByMenuBar = FALSE;
+    m_menuParent = (wxMenu*) NULL;
+
+    if (m_title != "")
+    {
+        Append(-2, m_title) ;
+        AppendSeparator() ;
+    }
+
+    Callback(func);
+
+    // TODO create menu
+}
+
+// The wxWindow destructor will take care of deleting the submenus.
+wxMenu::~wxMenu()
+{
+    // TODO destroy menu and children
+
+    wxNode *node = m_menuItems.First();
+    while (node)
+    {
+        wxMenuItem *item = (wxMenuItem *)node->Data();
+
+        // Delete child menus.
+        // Beware: they must not be appended to children list!!!
+        // (because order of delete is significant)
+        if (item->GetSubMenu())
+            item->DeleteSubMenu();
+
+        wxNode *next = node->Next();
+        delete item;
+        delete node;
+        node = next;
+    }
+}
+
+void wxMenu::Break()
+{
+    // TODO
+}
+
+// function appends a new item or submenu to the menu
+void wxMenu::Append(wxMenuItem *pItem)
+{
+    // TODO
+
+    wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
+
+    m_menuItems.Append(pItem);
+
+    m_noItems++;
+}
+
+void wxMenu::AppendSeparator()
+{
+    // TODO
+    Append(new wxMenuItem(this, ID_SEPARATOR));
+}
+
+// Pullright item
+void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu, 
+                    const wxString& helpString)
+{
+    Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
+}
+
+// Ordinary menu item
+void wxMenu::Append(int Id, const wxString& label, 
+                    const wxString& helpString, bool checkable)
+{
+  // 'checkable' parameter is useless for Windows.
+    Append(new wxMenuItem(this, Id, label, helpString, checkable));
+}
+
+void wxMenu::Delete(int id)
+{
+    wxNode *node;
+    wxMenuItem *item;
+    int pos;
+
+    for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
+        item = (wxMenuItem *)node->Data();
+        if (item->GetId() == id)
+               break;
+    }
+
+    if (!node)
+       return;
+
+    m_menuItems.DeleteNode(node);
+    delete item;
+
+    // TODO
+}
+
+void wxMenu::Enable(int Id, bool Flag)
+{
+    wxMenuItem *item = FindItemForId(Id);
+    wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
+
+    item->Enable(Flag);
+}
+
+bool wxMenu::Enabled(int Id) const
+{
+    wxMenuItem *item = FindItemForId(Id);
+    wxCHECK( item != NULL, FALSE );
+
+    return item->IsEnabled();
+}
+
+void wxMenu::Check(int Id, bool Flag)
+{
+    wxMenuItem *item = FindItemForId(Id);
+    wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
+
+    item->Check(Flag);
+}
+
+bool wxMenu::Checked(int Id) const
+{
+    wxMenuItem *item = FindItemForId(Id);
+    wxCHECK( item != NULL, FALSE );
+
+    return item->IsChecked();
+}
+
+void wxMenu::SetTitle(const wxString& label)
+{
+    m_title = label ;
+    // TODO
+}
+
+const wxString wxMenu::GetTitle() const
+{
+    return m_title;
+}
+
+void wxMenu::SetLabel(int id, const wxString& label)
+{
+    wxMenuItem *item = FindItemForId(id) ;
+    if (item==NULL)
+        return;
+
+    if (item->GetSubMenu()==NULL)
+    {
+        // TODO
+    }
+    else
+    {
+        // TODO
+    }
+    item->SetName(label);
+}
+
+wxString wxMenu::GetLabel(int Id) const
+{
+    // TODO
+    return wxString("") ;
+}
+
+// Finds the item id matching the given string, -1 if not found.
+int wxMenu::FindItem (const wxString& itemString) const
+{
+    char buf1[200];
+    char buf2[200];
+    wxStripMenuCodes ((char *)(const char *)itemString, buf1);
+
+    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+    {
+      wxMenuItem *item = (wxMenuItem *) node->Data ();
+      if (item->GetSubMenu())
+      {
+        int ans = item->GetSubMenu()->FindItem(itemString);
+        if (ans > -1)
+          return ans;
+      }
+      if ( !item->IsSeparator() )
+      {
+        wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
+        if (strcmp(buf1, buf2) == 0)
+          return item->GetId();
+      }
+    }
+
+    return -1;
+}
+
+wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
+{
+    if (itemMenu)
+        *itemMenu = NULL;
+    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+    {
+        wxMenuItem *item = (wxMenuItem *) node->Data ();
+
+        if (item->GetId() == itemId)
+        {
+            if (itemMenu)
+                *itemMenu = (wxMenu *) this;
+            return item;
+        }
+
+        if (item->GetSubMenu())
+        {
+            wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
+            if (ans)
+                return ans;
+        }
+    }
+
+    if (itemMenu)
+        *itemMenu = NULL;
+    return NULL;
+}
+
+void wxMenu::SetHelpString(int itemId, const wxString& helpString)
+{
+    wxMenuItem *item = FindItemForId (itemId);
+    if (item)
+        item->SetHelp(helpString);
+}
+
+wxString wxMenu::GetHelpString (int itemId) const
+{
+    wxMenuItem *item = FindItemForId (itemId);
+    wxString str("");
+    return (item == NULL) ? str : item->GetHelp();
+}
+
+void wxMenu::ProcessCommand(wxCommandEvent & event)
+{
+    bool processed = FALSE;
+
+    // Try a callback
+    if (m_callback)
+    {
+            (void) (*(m_callback)) (*this, event);
+            processed = TRUE;
+    }
+
+    // Try the menu's event handler
+    if ( !processed && GetEventHandler())
+    {
+            processed = GetEventHandler()->ProcessEvent(event);
+    }
+/* TODO
+    // Try the window the menu was popped up from (and up
+    // through the hierarchy)
+    if ( !processed && GetInvokingWindow())
+        processed = GetInvokingWindow()->ProcessEvent(event);
+*/
+}
+
+bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
+{
+    // TODO
+    return FALSE;
+}
+
+// Menu Bar
+wxMenuBar::wxMenuBar()
+{
+    m_eventHandler = this;
+    m_menuCount = 0;
+    m_menus = NULL;
+    m_titles = NULL;
+    m_menuBarFrame = NULL;
+
+    // TODO
+}
+
+wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
+{
+    m_eventHandler = this;
+    m_menuCount = n;
+    m_menus = menus;
+    m_titles = new wxString[n];
+    int i;
+    for ( i = 0; i < n; i++ )
+       m_titles[i] = titles[i];
+    m_menuBarFrame = NULL;
+
+    // TODO
+}
+
+wxMenuBar::~wxMenuBar()
+{
+    int i;
+    for (i = 0; i < m_menuCount; i++)
+    {
+        delete m_menus[i];
+    }
+    delete[] m_menus;
+    delete[] m_titles;
+
+    // TODO
+}
+
+// Must only be used AFTER menu has been attached to frame,
+// otherwise use individual menus to enable/disable items
+void wxMenuBar::Enable(int id, bool flag)
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+    if (!item)
+        return;
+
+    // TODO
+}
+
+void wxMenuBar::EnableTop(int pos, bool flag)
+{
+    // TODO
+}
+
+// Must only be used AFTER menu has been attached to frame,
+// otherwise use individual menus
+void wxMenuBar::Check(int id, bool flag)
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+    if (!item)
+        return;
+
+    if (!item->IsCheckable())
+        return ;
+
+    // TODO
+}
+
+bool wxMenuBar::Checked(int id) const
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+    if (!item)
+        return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+bool wxMenuBar::Enabled(int id) const
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+    if (!item)
+        return FALSE;
+
+    // TODO
+    return FALSE ;
+}
+
+
+void wxMenuBar::SetLabel(int id, const wxString& label)
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+
+    if (!item)
+        return;
+
+    // TODO
+}
+
+wxString wxMenuBar::GetLabel(int id) const
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+
+    if (!item)
+        return wxString("");
+
+    // TODO
+    return wxString("") ;
+}
+
+void wxMenuBar::SetLabelTop(int pos, const wxString& label)
+{
+    // TODO
+}
+
+wxString wxMenuBar::GetLabelTop(int pos) const
+{
+    // TODO
+    return wxString("");
+}
+
+bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
+{
+    // TODO
+    return FALSE;
+}
+
+void wxMenuBar::Append (wxMenu * menu, const wxString& title)
+{
+    if (!OnAppend(menu, title))
+        return;
+
+    m_menuCount ++;
+    wxMenu **new_menus = new wxMenu *[m_menuCount];
+    wxString *new_titles = new wxString[m_menuCount];
+    int i;
+
+    for (i = 0; i < m_menuCount - 1; i++)
+       {
+        new_menus[i] = m_menus[i];
+        m_menus[i] = NULL;
+        new_titles[i] = m_titles[i];
+        m_titles[i] = "";
+    }
+    if (m_menus)
+    {
+        delete[]m_menus;
+        delete[]m_titles;
+    }
+    m_menus = new_menus;
+    m_titles = new_titles;
+
+    m_menus[m_menuCount - 1] = (wxMenu *)menu;
+    m_titles[m_menuCount - 1] = title;
+
+    // TODO
+}
+
+void wxMenuBar::Delete(wxMenu * menu, int i)
+{
+    int j;
+    int ii = (int) i;
+
+    if (menu != 0)
+    {
+           for (ii = 0; ii < m_menuCount; ii++)
+        {
+            if (m_menus[ii] == menu)
+            break;
+           }
+        if (ii >= m_menuCount)
+            return;
+    } else
+    {
+        if (ii < 0 || ii >= m_menuCount)
+            return;
+        menu = m_menus[ii];
+    }
+
+    if (!OnDelete(menu, ii))
+        return;
+
+    menu->SetParent(NULL);
+
+    -- m_menuCount;
+    for (j = ii; j < m_menuCount; j++)
+    {
+        m_menus[j] = m_menus[j + 1];
+        m_titles[j] = m_titles[j + 1];
+    }
+}
+
+// Find the menu menuString, item itemString, and return the item id.
+// Returns -1 if none found.
+int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
+{
+    char buf1[200];
+    char buf2[200];
+    wxStripMenuCodes ((char *)(const char *)menuString, buf1);
+    int i;
+    for (i = 0; i < m_menuCount; i++)
+    {
+        wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
+        if (strcmp (buf1, buf2) == 0)
+            return m_menus[i]->FindItem (itemString);
+    }
+    return -1;
+}
+
+wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
+{
+    if (itemMenu)
+        *itemMenu = NULL;
+
+    wxMenuItem *item = NULL;
+    int i;
+    for (i = 0; i < m_menuCount; i++)
+        if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
+            return item;
+    return NULL;
+}
+
+void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
+{
+    int i;
+    for (i = 0; i < m_menuCount; i++)
+    {
+        if (m_menus[i]->FindItemForId (Id))
+        {
+            m_menus[i]->SetHelpString (Id, helpString);
+            return;
+        }
+    }
+}
+
+wxString wxMenuBar::GetHelpString (int Id) const
+{
+    int i;
+    for (i = 0; i < m_menuCount; i++)
+    {
+        if (m_menus[i]->FindItemForId (Id))
+            return wxString(m_menus[i]->GetHelpString (Id));
+    }
+    return wxString("");
+}
+
+

diff --git a/src/motif/menuitem.cpp b/src/motif/menuitem.cpp
new file mode 100644 (file)
index 0000000..619ccde
--- /dev/null
+++ b/src/motif/menuitem.cpp
@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        menuitem.cpp
+// Purpose:     wxMenuItem implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// headers & declarations
+// ============================================================================
+
+#include "wx/menu.h"
+#include "wx/menuitem.h"
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// dynamic classes implementation
+// ----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARY
+  IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
+#endif  //USE_SHARED_LIBRARY
+
+// ----------------------------------------------------------------------------
+// wxMenuItem
+// ----------------------------------------------------------------------------
+
+// ctor & dtor
+// -----------
+
+wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id,
+                       const wxString& strName, const wxString& strHelp,
+                       bool bCheckable,
+                       wxMenu *pSubMenu) :
+                        m_bCheckable(bCheckable),
+                        m_strName(strName),
+                        m_strHelp(strHelp)
+{
+  wxASSERT( pParentMenu != NULL );
+
+  m_pParentMenu = pParentMenu;
+  m_pSubMenu    = pSubMenu;
+  m_idItem      = id;
+  m_bEnabled    = TRUE;
+}
+
+wxMenuItem::~wxMenuItem() 
+{
+}
+
+// misc
+// ----
+
+// delete the sub menu
+void wxMenuItem::DeleteSubMenu()
+{
+  wxASSERT( m_pSubMenu != NULL );
+
+  delete m_pSubMenu;
+  m_pSubMenu = NULL;
+}
+
+// change item state
+// -----------------
+
+void wxMenuItem::Enable(bool bDoEnable)
+{
+  if ( m_bEnabled != bDoEnable ) {
+    if ( m_pSubMenu == NULL ) {     // normal menu item
+        // TODO
+    }
+    else                            // submenu
+    {
+        // TODO
+    }
+
+    m_bEnabled = bDoEnable;
+  }
+}
+
+void wxMenuItem::Check(bool bDoCheck)
+{
+  wxCHECK_RET( IsCheckable(), "only checkable items may be checked" );
+
+  if ( m_bChecked != bDoCheck ) {
+    // TODO
+    m_bChecked = bDoCheck;
+  }
+}
\ No newline at end of file

diff --git a/src/motif/metafile.cpp b/src/motif/metafile.cpp
new file mode 100644 (file)
index 0000000..e084a9a
--- /dev/null
+++ b/src/motif/metafile.cpp
@@ -0,0 +1,239 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        metafile.cpp
+// Purpose:     wxMetaFile, wxMetaFileDC etc. These classes are optional.
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "metafile.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/dc.h"
+#include "wx/stubs/metafile.h"
+#include "wx/clipbrd.h"
+
+extern bool wxClipboardIsOpen;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC)
+#endif
+
+wxMetaFile::wxMetaFile(const wxString& file)
+{
+    // TODO
+}
+
+wxMetaFile::~wxMetaFile()
+{
+    // TODO
+}
+
+bool wxMetaFile::SetClipboard(int width, int height)
+{
+    bool alreadyOpen=wxClipboardOpen();
+    if (!alreadyOpen)
+    {
+        wxOpenClipboard();
+        if (!wxEmptyClipboard()) return FALSE;
+    }
+    bool success = wxSetClipboardData(wxDF_METAFILE,this, width,height);
+    if (!alreadyOpen) wxCloseClipboard();
+    return (bool) success;
+}
+
+bool wxMetaFile::Play(wxDC *dc)
+{
+    // TODO
+    return false;
+}
+
+/*
+ * Metafile device context
+ *
+ */
+
+// Original constructor that does not takes origin and extent. If you use this,
+// *DO* give origin/extent arguments to wxMakeMetaFilePlaceable.
+wxMetaFileDC::wxMetaFileDC(const wxString& file)
+{
+    // TODO
+}
+
+// New constructor that takes origin and extent. If you use this, don't
+// give origin/extent arguments to wxMakeMetaFilePlaceable.
+wxMetaFileDC::wxMetaFileDC(const wxString& file, int xext, int yext, int xorg, int yorg)
+{
+    // TODO
+}
+
+wxMetaFileDC::~wxMetaFileDC()
+{
+}
+
+void wxMetaFileDC::GetTextExtent(const wxString& string, float *x, float *y,
+                                 float *descent, float *externalLeading, wxFont *theFont, bool use16bit)
+{
+    // TODO
+}
+
+wxMetaFile *wxMetaFileDC::Close()
+{
+    // TODO
+    return NULL;
+}
+
+void wxMetaFileDC::SetMapMode(int mode)
+{
+    // TODO
+}
+
+#if 0
+
+#ifdef __WIN32__
+struct RECT32
+{
+  short left;
+  short top;
+  short right;
+  short bottom;
+};
+
+struct mfPLACEABLEHEADER {
+       DWORD   key;
+       short   hmf;
+       RECT32  bbox;
+       WORD    inch;
+       DWORD   reserved;
+       WORD    checksum;
+};
+#else
+struct mfPLACEABLEHEADER {
+       DWORD   key;
+       HANDLE  hmf;
+       RECT    bbox;
+       WORD    inch;
+       DWORD   reserved;
+       WORD    checksum;
+};
+#endif
+
+/*
+ * Pass filename of existing non-placeable metafile, and bounding box.
+ * Adds a placeable metafile header, sets the mapping mode to anisotropic,
+ * and sets the window origin and extent to mimic the MM_TEXT mapping mode.
+ *
+ */
+ 
+bool wxMakeMetaFilePlaceable(const wxString& filename, float scale)
+{
+  return wxMakeMetaFilePlaceable(filename, 0, 0, 0, 0, scale, FALSE);
+}
+
+bool wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale, bool useOriginAndExtent)
+{
+  // I'm not sure if this is the correct way of suggesting a scale
+  // to the client application, but it's the only way I can find.
+  int unitsPerInch = (int)(576/scale);
+  
+  mfPLACEABLEHEADER header;
+  header.key = 0x9AC6CDD7L;
+  header.hmf = 0;
+  header.bbox.left = (int)(x1);
+  header.bbox.top = (int)(y1);
+  header.bbox.right = (int)(x2);
+  header.bbox.bottom = (int)(y2);
+  header.inch = unitsPerInch;
+  header.reserved = 0;
+
+  // Calculate checksum  
+  WORD *p;
+  mfPLACEABLEHEADER *pMFHead = &header;
+  for (p =(WORD *)pMFHead,pMFHead -> checksum = 0;
+       p < (WORD *)&pMFHead ->checksum; ++p)
+       pMFHead ->checksum ^= *p;
+
+  FILE *fd = fopen((char *)(const char *)filename, "rb");
+  if (!fd) return FALSE;
+  
+  char tempFileBuf[256];
+  wxGetTempFileName("mf", tempFileBuf);
+  FILE *fHandle = fopen(tempFileBuf, "wb");
+  if (!fHandle)
+    return FALSE;
+  fwrite((void *)&header, sizeof(unsigned char), sizeof(mfPLACEABLEHEADER), fHandle);
+
+  // Calculate origin and extent
+  int originX = x1;
+  int originY = y1;
+  int extentX = x2 - x1;
+  int extentY = (y2 - y1);
+
+  // Read metafile header and write
+  METAHEADER metaHeader;
+  fread((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fd);
+  
+  if (useOriginAndExtent)
+    metaHeader.mtSize += 15;
+  else
+    metaHeader.mtSize += 5;
+    
+  fwrite((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fHandle);
+
+  // Write SetMapMode, SetWindowOrigin and SetWindowExt records
+  char modeBuffer[8];
+  char originBuffer[10];
+  char extentBuffer[10];
+  METARECORD *modeRecord = (METARECORD *)&modeBuffer;
+
+  METARECORD *originRecord = (METARECORD *)&originBuffer;
+  METARECORD *extentRecord = (METARECORD *)&extentBuffer;
+
+  modeRecord->rdSize = 4;
+  modeRecord->rdFunction = META_SETMAPMODE;
+  modeRecord->rdParm[0] = MM_ANISOTROPIC;
+
+  originRecord->rdSize = 5;
+  originRecord->rdFunction = META_SETWINDOWORG;
+  originRecord->rdParm[0] = originY;
+  originRecord->rdParm[1] = originX;
+
+  extentRecord->rdSize = 5;
+  extentRecord->rdFunction = META_SETWINDOWEXT;
+  extentRecord->rdParm[0] = extentY;
+  extentRecord->rdParm[1] = extentX;
+
+  fwrite((void *)modeBuffer, sizeof(char), 8, fHandle);
+  
+  if (useOriginAndExtent)
+  {
+    fwrite((void *)originBuffer, sizeof(char), 10, fHandle);
+    fwrite((void *)extentBuffer, sizeof(char), 10, fHandle);
+  }
+
+  int ch = -2;
+  while (ch != EOF)
+  {
+    ch = getc(fd);
+    if (ch != EOF)
+    {
+      putc(ch, fHandle);
+    }
+  }
+  fclose(fHandle);
+  fclose(fd);
+  wxRemoveFile(filename);
+  wxCopyFile(tempFileBuf, filename);
+  wxRemoveFile(tempFileBuf);
+  return TRUE;
+}
+
+#endif
+

diff --git a/src/motif/minifram.cpp b/src/motif/minifram.cpp
new file mode 100644 (file)
index 0000000..bf6c50b
--- /dev/null
+++ b/src/motif/minifram.cpp
@@ -0,0 +1,22 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        minifram.cpp
+// Purpose:     wxMiniFrame. Optional; identical to wxFrame if not supported.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "minifram.h"
+#endif
+
+#include "wx/minifram.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame, wxFrame)
+#endif
+
+

diff --git a/src/motif/msgdlg.cpp b/src/motif/msgdlg.cpp
new file mode 100644 (file)
index 0000000..3bfa6db
--- /dev/null
+++ b/src/motif/msgdlg.cpp
@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        msgdlg.cpp
+// Purpose:     wxMessageDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "msgdlg.h"
+#endif
+
+#include "wx/stubs/msgdlg.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_CLASS(wxMessageDialog, wxDialog)
+#endif
+
+wxMessageDialog::wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption,
+        long style, const wxPoint& pos)
+{
+    m_caption = caption;
+    m_message = message;
+    m_dialogStyle = style;
+    m_parent = parent;
+}
+
+int wxMessageDialog::ShowModal()
+{
+    // TODO
+    return wxID_CANCEL;
+}
+

diff --git a/src/motif/notebook.cpp b/src/motif/notebook.cpp
new file mode 100644 (file)
index 0000000..229dc45
--- /dev/null
+++ b/src/motif/notebook.cpp
@@ -0,0 +1,367 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        notebook.cpp
+// Purpose:     implementation of wxNotebook
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+#ifdef __GNUG__
+#pragma implementation "notebook.h"
+#endif
+
+#include  <wx/string.h>
+#include  <wx/log.h>
+#include  <wx/imaglist.h>
+#include  <wx/notebook.h>
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
+
+// check that the page index is valid
+#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
+
+// ----------------------------------------------------------------------------
+// event table
+// ----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARIES
+BEGIN_EVENT_TABLE(wxNotebook, wxControl)
+    EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
+
+    EVT_SIZE(wxNotebook::OnSize)
+    EVT_SET_FOCUS(wxNotebook::OnSetFocus)
+    EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
+END_EVENT_TABLE()
+
+IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
+#endif
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxNotebook construction
+// ----------------------------------------------------------------------------
+
+// common part of all ctors
+void wxNotebook::Init()
+{
+    m_pImageList = NULL;
+    m_nSelection = -1;
+}
+
+// default for dynamic class
+wxNotebook::wxNotebook()
+{
+    Init();
+}
+
+// the same arguments as for wxControl
+wxNotebook::wxNotebook(wxWindow *parent,
+                       wxWindowID id,
+                       const wxPoint& pos,
+                       const wxSize& size,
+                       long style,
+                       const wxString& name)
+{
+    Init();
+
+    Create(parent, id, pos, size, style, name);
+}
+
+// Create() function
+bool wxNotebook::Create(wxWindow *parent,
+                        wxWindowID id,
+                        const wxPoint& pos,
+                        const wxSize& size,
+                        long style,
+                        const wxString& name)
+{
+    // base init
+    SetName(name);
+    SetParent(parent);
+
+    m_windowId = id == -1 ? NewControlId() : id;
+
+    // style
+    m_windowStyle = style;
+
+    if ( parent != NULL )
+        parent->AddChild(this);
+
+    // TODO
+
+    return FALSE;
+}
+
+// dtor
+wxNotebook::~wxNotebook()
+{
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook accessors
+// ----------------------------------------------------------------------------
+int wxNotebook::GetPageCount() const
+{
+    return m_aPages.Count();
+}
+
+int wxNotebook::GetRowCount() const
+{
+    // TODO
+    return 0;
+}
+
+int wxNotebook::SetSelection(int nPage)
+{
+    wxASSERT( IS_VALID_PAGE(nPage) );
+
+    ChangePage(m_nSelection, nPage);
+
+    // TODO
+    return 0;
+}
+
+void wxNotebook::AdvanceSelection(bool bForward)
+{
+    int nSel = GetSelection();
+    int nMax = GetPageCount() - 1;
+    if ( bForward )
+        SetSelection(nSel == nMax ? 0 : nSel + 1);
+    else
+        SetSelection(nSel == 0 ? nMax : nSel - 1);
+}
+
+bool wxNotebook::SetPageText(int nPage, const wxString& strText)
+{
+    wxASSERT( IS_VALID_PAGE(nPage) );
+
+    // TODO
+    return FALSE;
+}
+
+wxString wxNotebook::GetPageText(int nPage) const
+{
+    wxASSERT( IS_VALID_PAGE(nPage) );
+
+    // TODO
+    return wxString("");
+}
+
+int wxNotebook::GetPageImage(int nPage) const
+{
+    wxASSERT( IS_VALID_PAGE(nPage) );
+
+    // TODO
+    return 0;
+}
+
+bool wxNotebook::SetPageImage(int nPage, int nImage)
+{
+    wxASSERT( IS_VALID_PAGE(nPage) );
+
+    // TODO
+    return FALSE;
+}
+
+void wxNotebook::SetImageList(wxImageList* imageList)
+{ 
+    m_pImageList = imageList;
+    // TODO
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook operations
+// ----------------------------------------------------------------------------
+
+// remove one page from the notebook
+bool wxNotebook::DeletePage(int nPage)
+{
+    wxCHECK( IS_VALID_PAGE(nPage), FALSE );
+
+    // TODO: delete native widget page
+
+    delete m_aPages[nPage];
+    m_aPages.Remove(nPage);
+
+    return TRUE;
+}
+
+// remove all pages
+bool wxNotebook::DeleteAllPages()
+{
+    // TODO: delete native widget pages
+
+    int nPageCount = GetPageCount();
+    int nPage;
+    for ( nPage = 0; nPage < nPageCount; nPage++ )
+        delete m_aPages[nPage];
+
+    m_aPages.Clear();
+
+    return TRUE;
+}
+
+// add a page to the notebook
+bool wxNotebook::AddPage(wxNotebookPage *pPage,
+                         const wxString& strText,
+                         bool bSelect,
+                         int imageId)
+{
+    return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
+}
+
+// same as AddPage() but does it at given position
+bool wxNotebook::InsertPage(int nPage,
+                            wxNotebookPage *pPage,
+                            const wxString& strText,
+                            bool bSelect,
+                            int imageId)
+{
+    wxASSERT( pPage != NULL );
+    wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
+
+    // TODO: insert native widget page
+
+    // save the pointer to the page
+    m_aPages.Insert(pPage, nPage);
+
+    // some page must be selected: either this one or the first one if there is 
+    // still no selection
+    if ( bSelect )
+        m_nSelection = nPage;
+    else if ( m_nSelection == -1 )
+        m_nSelection = 0;
+
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook callbacks
+// ----------------------------------------------------------------------------
+
+// @@@ OnSize() is used for setting the font when it's called for the first
+//     time because doing it in ::Create() doesn't work (for unknown reasons)
+void wxNotebook::OnSize(wxSizeEvent& event)
+{
+    static bool s_bFirstTime = TRUE;
+    if ( s_bFirstTime ) {
+        // TODO: any first-time-size processing.
+        s_bFirstTime = FALSE;
+    }
+
+    // TODO: all this may or may not be necessary for your platform
+
+    // emulate page change (it's esp. important to do it first time because
+    // otherwise our page would stay invisible)
+    int nSel = m_nSelection;
+    m_nSelection = -1;
+    SetSelection(nSel);
+
+    // fit the notebook page to the tab control's display area
+    int w, h;
+    GetSize(&w, &h);
+
+    unsigned int nCount = m_aPages.Count();
+    for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
+        wxNotebookPage *pPage = m_aPages[nPage];
+        pPage->SetSize(0, 0, w, h);
+        if ( pPage->GetAutoLayout() )
+            pPage->Layout();
+    }
+
+    // Processing continues to next OnSize
+    event.Skip();
+}
+
+void wxNotebook::OnSelChange(wxNotebookEvent& event)
+{
+    // is it our tab control?
+    if ( event.GetEventObject() == this )
+        ChangePage(event.GetOldSelection(), event.GetSelection());
+
+    // we want to give others a chance to process this message as well
+    event.Skip();
+}
+
+void wxNotebook::OnSetFocus(wxFocusEvent& event)
+{
+    // set focus to the currently selected page if any
+    if ( m_nSelection != -1 )
+        m_aPages[m_nSelection]->SetFocus();
+
+    event.Skip();
+}
+
+void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
+{
+    if ( event.IsWindowChange() ) {
+        // change pages
+        AdvanceSelection(event.GetDirection());
+    }
+    else {
+        // pass to the parent
+        if ( GetParent() ) {
+            event.SetCurrentFocus(this);
+            GetParent()->ProcessEvent(event);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook base class virtuals
+// ----------------------------------------------------------------------------
+
+// override these 2 functions to do nothing: everything is done in OnSize
+
+void wxNotebook::SetConstraintSizes(bool /* recurse */)
+{
+    // don't set the sizes of the pages - their correct size is not yet known
+    wxControl::SetConstraintSizes(FALSE);
+}
+
+bool wxNotebook::DoPhase(int /* nPhase */)
+{
+    return TRUE;
+}
+
+void wxNotebook::Command(wxCommandEvent& event)
+{
+    wxFAIL_MSG("wxNotebook::Command not implemented");
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook helper functions
+// ----------------------------------------------------------------------------
+
+// hide the currently active panel and show the new one
+void wxNotebook::ChangePage(int nOldSel, int nSel)
+{
+    wxASSERT( nOldSel != nSel ); // impossible
+
+    if ( nOldSel != -1 ) {
+        m_aPages[nOldSel]->Show(FALSE);
+    }
+
+    wxNotebookPage *pPage = m_aPages[nSel];
+    pPage->Show(TRUE);
+    pPage->SetFocus();
+
+    m_nSelection = nSel;
+}
+

diff --git a/src/motif/palette.cpp b/src/motif/palette.cpp
new file mode 100644 (file)
index 0000000..69e9780
--- /dev/null
+++ b/src/motif/palette.cpp
@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        palette.cpp
+// Purpose:     wxPalette
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "palette.h"
+#endif
+
+#include "wx/palette.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
+#endif
+
+/*
+ * Palette
+ *
+ */
+
+wxPaletteRefData::wxPaletteRefData()
+{
+    // TODO
+}
+
+wxPaletteRefData::~wxPaletteRefData()
+{
+    // TODO
+}
+
+wxPalette::wxPalette()
+{
+}
+
+wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
+{
+    Create(n, red, green, blue);
+}
+
+wxPalette::~wxPalette()
+{
+}
+
+bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
+{
+  UnRef();
+
+  m_refData = new wxPaletteRefData;
+
+  // TODO
+
+  return FALSE;
+}
+
+int wxPalette::GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const
+{
+    if ( !m_refData )
+       return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const
+{
+    if ( !m_refData )
+           return FALSE;
+
+    if (index < 0 || index > 255)
+        return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+

diff --git a/src/motif/pen.cpp b/src/motif/pen.cpp
new file mode 100644 (file)
index 0000000..a9536ca
--- /dev/null
+++ b/src/motif/pen.cpp
@@ -0,0 +1,229 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        pen.cpp
+// Purpose:     wxPen
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "pen.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/utils.h"
+#include "wx/pen.h"
+
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
+#endif
+
+wxPenRefData::wxPenRefData()
+{
+    m_style = wxSOLID;
+    m_width = 1;
+    m_join = wxJOIN_ROUND ;
+    m_cap = wxCAP_ROUND ;
+    m_nbDash = 0 ;
+    m_dash = 0 ;
+/* TODO: null data
+    m_hPen = 0;
+*/
+}
+
+wxPenRefData::wxPenRefData(const wxPenRefData& data)
+{
+    m_style = data.m_style;
+    m_width = data.m_width;
+    m_join = data.m_join;
+    m_cap = data.m_cap;
+    m_nbDash = data.m_nbDash;
+    m_dash = data.m_dash;
+    m_colour = data.m_colour;
+/* TODO: null data
+    m_hPen = 0;
+*/
+}
+
+wxPenRefData::~wxPenRefData()
+{
+    // TODO: delete data
+}
+
+// Pens
+
+wxPen::wxPen()
+{
+    if ( wxThePenList )
+        wxThePenList->AddPen(this);
+}
+
+wxPen::~wxPen()
+{
+    if (wxThePenList)
+        wxThePenList->RemovePen(this);
+}
+
+// Should implement Create
+wxPen::wxPen(const wxColour& col, int Width, int Style)
+{
+    m_refData = new wxPenRefData;
+
+    M_PENDATA->m_colour = col;
+    M_PENDATA->m_width = Width;
+    M_PENDATA->m_style = Style;
+    M_PENDATA->m_join = wxJOIN_ROUND ;
+    M_PENDATA->m_cap = wxCAP_ROUND ;
+    M_PENDATA->m_nbDash = 0 ;
+    M_PENDATA->m_dash = 0 ;
+
+    RealizeResource();
+
+    if ( wxThePenList )
+        wxThePenList->AddPen(this);
+}
+
+wxPen::wxPen(const wxBitmap& stipple, int Width)
+{
+    m_refData = new wxPenRefData;
+
+    M_PENDATA->m_stipple = stipple;
+    M_PENDATA->m_width = Width;
+    M_PENDATA->m_style = wxSTIPPLE;
+    M_PENDATA->m_join = wxJOIN_ROUND ;
+    M_PENDATA->m_cap = wxCAP_ROUND ;
+    M_PENDATA->m_nbDash = 0 ;
+    M_PENDATA->m_dash = 0 ;
+
+    RealizeResource();
+
+    if ( wxThePenList )
+        wxThePenList->AddPen(this);
+}
+
+wxPen::wxPen(const wxString& col, int Width, int Style)
+{
+    m_refData = new wxPenRefData;
+
+    M_PENDATA->m_colour = col;
+    M_PENDATA->m_width = Width;
+    M_PENDATA->m_style = Style;
+    M_PENDATA->m_join = wxJOIN_ROUND ;
+    M_PENDATA->m_cap = wxCAP_ROUND ;
+    M_PENDATA->m_nbDash = 0 ;
+    M_PENDATA->m_dash = 0 ;
+
+    RealizeResource();
+
+    if ( wxThePenList )
+        wxThePenList->AddPen(this);
+}
+
+void wxPen::Unshare()
+{
+       // Don't change shared data
+       if (!m_refData)
+    {
+               m_refData = new wxPenRefData();
+       }
+    else
+    {
+               wxPenRefData* ref = new wxPenRefData(*(wxPenRefData*)m_refData);
+               UnRef();
+               m_refData = ref;
+       }
+}
+
+void wxPen::SetColour(const wxColour& col)
+{
+    Unshare();
+
+    M_PENDATA->m_colour = col;
+  
+    RealizeResource();
+}
+
+void wxPen::SetColour(const wxString& col)
+{
+    Unshare();
+
+    M_PENDATA->m_colour = col;
+  
+    RealizeResource();
+}
+
+void wxPen::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
+{
+    Unshare();
+
+    M_PENDATA->m_colour.Set(r, g, b);
+  
+    RealizeResource();
+}
+
+void wxPen::SetWidth(int Width)
+{
+    Unshare();
+
+    M_PENDATA->m_width = Width;
+
+    RealizeResource();
+}
+
+void wxPen::SetStyle(int Style)
+{
+    Unshare();
+
+    M_PENDATA->m_style = Style;
+
+    RealizeResource();
+}
+
+void wxPen::SetStipple(const wxBitmap& Stipple)
+{
+    Unshare();
+
+    M_PENDATA->m_stipple = Stipple;
+    M_PENDATA->m_style = wxSTIPPLE;
+  
+    RealizeResource();
+}
+
+void wxPen::SetDashes(int nb_dashes, const wxDash *Dash)
+{
+    Unshare();
+
+    M_PENDATA->m_nbDash = nb_dashes;
+    M_PENDATA->m_dash = (wxDash *)Dash;
+  
+    RealizeResource();
+}
+
+void wxPen::SetJoin(int Join)
+{
+    Unshare();
+
+    M_PENDATA->m_join = Join;
+
+    RealizeResource();
+}
+
+void wxPen::SetCap(int Cap)
+{
+    Unshare();
+
+    M_PENDATA->m_cap = Cap;
+
+    RealizeResource();
+}
+
+bool wxPen::RealizeResource()
+{
+    // TODO: create actual pen
+    return FALSE;
+}
+
+

diff --git a/src/motif/print.cpp b/src/motif/print.cpp
new file mode 100644 (file)
index 0000000..7b8db95
--- /dev/null
+++ b/src/motif/print.cpp
@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        print.cpp
+// Purpose:     Print framework
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "print.h"
+#endif
+
+#include "wx/stubs/print.h"
+#include "wx/stubs/printdlg.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxPrinter, wxPrinterBase)
+IMPLEMENT_CLASS(wxPrintPreview, wxPrintPreviewBase)
+#endif
+
+/*
+ * Printer
+ */
+ 
+wxPrinter::wxPrinter(wxPrintData *data):
+  wxPrinterBase(data)
+{
+}
+
+wxPrinter::~wxPrinter()
+{
+}
+
+bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
+{
+    // TODO. See wxPostScriptPrinter::Print for hints.
+    return FALSE;
+}
+
+bool wxPrinter::PrintDialog(wxWindow *parent)
+{
+    wxPrintDialog dialog(parent, & m_printData);
+    return (dialog.ShowModal() == wxID_OK);
+}
+
+bool wxPrinter::Setup(wxWindow *parent)
+{
+    wxPrintDialog dialog(parent, & m_printData);
+    dialog.GetPrintData().SetSetupDialog(TRUE);
+    return (dialog.ShowModal() == wxID_OK);
+}
+
+/*
+ * Print preview
+ */
+
+wxPrintPreview::wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data):
+  wxPrintPreviewBase(printout, printoutForPrinting, data)
+{
+    DetermineScaling();
+}
+
+wxPrintPreview::~wxPrintPreview()
+{
+}
+
+bool wxPrintPreview::Print(bool interactive)
+{
+    if (!m_printPrintout)
+        return FALSE;
+    wxPrinter printer(&m_printData);
+    return printer.Print(m_previewFrame, m_printPrintout, interactive);
+}
+
+void wxPrintPreview::DetermineScaling()
+{
+    // TODO
+}
+

diff --git a/src/motif/printdlg.cpp b/src/motif/printdlg.cpp
new file mode 100644 (file)
index 0000000..aa24e6a
--- /dev/null
+++ b/src/motif/printdlg.cpp
@@ -0,0 +1,115 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        printdlg.cpp
+// Purpose:     wxPrintDialog, wxPageSetupDialog
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "printdlg.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/stubs/printdlg.h"
+#include "wx/dcprint.h"
+
+// Use generic page setup dialog: use your own native one if one exists.
+#include "wx/generic/prntdlgg.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxPrintDialog, wxDialog)
+IMPLEMENT_CLASS(wxPageSetupDialog, wxDialog)
+#endif
+
+wxPrintDialog::wxPrintDialog():
+ wxDialog()
+{
+    m_dialogParent = NULL;
+    m_printerDC = NULL;
+}
+
+wxPrintDialog::wxPrintDialog(wxWindow *p, wxPrintData* data):
+ wxDialog()
+{
+    Create(p, data);
+}
+
+bool wxPrintDialog::Create(wxWindow *p, wxPrintData* data)
+{
+    m_dialogParent = p;
+    m_printerDC = NULL;
+
+    if ( data )
+        m_printData = *data;
+
+    return TRUE;
+}
+
+wxPrintDialog::~wxPrintDialog()
+{
+    if (m_printerDC)
+        delete m_printerDC;
+}
+
+int wxPrintDialog::ShowModal()
+{
+    // TODO
+    return wxID_CANCEL;
+}
+
+wxDC *wxPrintDialog::GetPrintDC()
+{
+  if (m_printerDC)
+  {
+    wxDC* dc = m_printerDC;
+    m_printerDC = NULL;
+    return dc;
+  }
+  else
+    return NULL;
+}
+
+/*
+ * wxPageSetupDialog
+ */
+
+wxPageSetupDialog::wxPageSetupDialog():
+ wxDialog()
+{
+  m_dialogParent = NULL;
+}
+
+wxPageSetupDialog::wxPageSetupDialog(wxWindow *p, wxPageSetupData *data):
+ wxDialog()
+{
+    Create(p, data);
+}
+
+bool wxPageSetupDialog::Create(wxWindow *p, wxPageSetupData *data)
+{
+    m_dialogParent = p;
+
+    if (data)
+        m_pageSetupData = (*data);
+
+    return TRUE;
+}
+
+wxPageSetupDialog::~wxPageSetupDialog()
+{
+}
+
+int wxPageSetupDialog::ShowModal()
+{
+    // Uses generic page setup dialog
+    wxGenericPageSetupDialog *genericPageSetupDialog = new wxGenericPageSetupDialog(GetParent(), & m_pageSetupData);
+    int ret = genericPageSetupDialog->ShowModal();
+    m_pageSetupData = genericPageSetupDialog->GetPageSetupData();
+    genericPageSetupDialog->Close(TRUE);
+    return ret;
+}
+

diff --git a/src/motif/radiobox.cpp b/src/motif/radiobox.cpp
new file mode 100644 (file)
index 0000000..ee9c66c
--- /dev/null
+++ b/src/motif/radiobox.cpp
@@ -0,0 +1,194 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        radiobox.cpp
+// Purpose:     wxRadioBox
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "radiobox.h"
+#endif
+
+#include "wx/radiobox.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
+#endif
+
+// Radio box item
+wxRadioBox::wxRadioBox()
+{
+    m_selectedButton = -1;
+    m_noItems = 0;
+    m_noRowsOrCols = 0;
+    m_majorDim = 0 ;
+}
+
+bool wxRadioBox::Create(wxWindow *parent, wxWindowID id, const wxString& title,
+             const wxPoint& pos, const wxSize& size,
+             int n, const wxString choices[],
+             int majorDim, long style,
+             const wxValidator& val, const wxString& name)
+{
+    m_selectedButton = -1;
+    m_noItems = n;
+
+    SetName(name);
+    SetValidator(val);
+
+    parent->AddChild(this);
+
+    m_windowStyle = (long&)style;
+
+    if (id == -1)
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    m_noRowsOrCols = majorDim;
+
+    if (majorDim==0)
+        m_majorDim = n ;
+    else
+        m_majorDim = majorDim ;
+
+
+    // TODO create radiobox
+    return FALSE;
+}
+
+
+wxRadioBox::~wxRadioBox()
+{
+    // TODO
+}
+
+wxString wxRadioBox::GetLabel(int item) const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxRadioBox::SetLabel(int item, const wxString& label)
+{
+    // TODO
+}
+
+int wxRadioBox::FindString(const wxString& s) const
+{
+    // TODO
+    return -1;
+}
+
+void wxRadioBox::SetSelection(int n)
+{
+    if ((n < 0) || (n >= m_noItems))
+        return;
+    // TODO
+
+    m_selectedButton = n;
+}
+
+// Get single selection, for single choice list items
+int wxRadioBox::GetSelection() const
+{
+    return m_selectedButton;
+}
+
+// Find string for position
+wxString wxRadioBox::GetString(int n) const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxRadioBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxRadioBox::GetSize(int *width, int *height) const
+{
+    // TODO
+}
+
+void wxRadioBox::GetPosition(int *x, int *y) const
+{
+    // TODO
+}
+
+wxString wxRadioBox::GetLabel() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxRadioBox::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+void wxRadioBox::SetFocus()
+{
+    // TODO
+}
+
+bool wxRadioBox::Show(bool show)
+{
+    // TODO
+    return FALSE;
+}
+
+// Enable a specific button
+void wxRadioBox::Enable(int item, bool enable)
+{
+    // TODO
+}
+
+// Enable all controls
+void wxRadioBox::Enable(bool enable)
+{
+    wxControl::Enable(enable);
+
+    // TODO
+}
+
+// Show a specific button
+void wxRadioBox::Show(int item, bool show)
+{
+    // TODO
+}
+
+// For single selection items only
+wxString wxRadioBox::GetStringSelection () const
+{
+    int sel = GetSelection ();
+    if (sel > -1)
+        return this->GetString (sel);
+    else
+        return wxString("");
+}
+
+bool wxRadioBox::SetStringSelection (const wxString& s)
+{
+    int sel = FindString (s);
+    if (sel > -1)
+    {
+        SetSelection (sel);
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+void wxRadioBox::Command (wxCommandEvent & event)
+{
+    SetSelection (event.m_commandInt);
+    ProcessCommand (event);
+}
+
+

diff --git a/src/motif/radiobut.cpp b/src/motif/radiobut.cpp
new file mode 100644 (file)
index 0000000..31c7504
--- /dev/null
+++ b/src/motif/radiobut.cpp
@@ -0,0 +1,68 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        radiobut.cpp
+// Purpose:     wxRadioButton
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "radiobut.h"
+#endif
+
+#include "wx/radiobut.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
+#endif
+
+bool wxRadioButton::Create(wxWindow *parent, wxWindowID id,
+                  const wxString& label,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    m_windowStyle = style ;
+
+    // TODO create radiobutton
+    return FALSE;
+}
+
+void wxRadioButton::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+void wxRadioButton::SetValue(bool value)
+{
+    // TODO
+}
+
+// Get single selection, for single choice list items
+bool wxRadioButton::GetValue() const
+{
+    // TODO
+    return FALSE;
+}
+
+void wxRadioButton::Command (wxCommandEvent & event)
+{
+  SetValue ( (event.m_commandInt != 0) );
+  ProcessCommand (event);
+}
+
+

diff --git a/src/motif/region.cpp b/src/motif/region.cpp
new file mode 100644 (file)
index 0000000..fcc58d3
--- /dev/null
+++ b/src/motif/region.cpp
@@ -0,0 +1,363 @@
+/////////////////////////////////////////////////////////////////////////////
+// File:      region.cpp
+// Purpose:   Region class
+// Author:    Markus Holzem/Julian Smart/Julian Smart
+// Created:   Fri Oct 24 10:46:34 MET 1997
+// RCS-ID:       $Id$
+// Copyright: (c) 1997 Markus Holzem/Julian Smart/Julian Smart
+// Licence:   wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "region.h"
+#endif
+
+#include "wx/region.h"
+#include "wx/gdicmn.h"
+
+#if !USE_SHARED_LIBRARY
+       IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
+       IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
+#endif
+
+//-----------------------------------------------------------------------------
+// wxRegionRefData implementation
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
+public:
+       wxRegionRefData()
+       {
+       }
+
+       wxRegionRefData(const wxRegionRefData& data)
+       {
+        // TODO
+       }
+
+       ~wxRegionRefData()
+       {
+        // TODO
+       }
+};
+
+
+//-----------------------------------------------------------------------------
+// wxRegion
+//-----------------------------------------------------------------------------
+
+/*!
+ * Create an empty region.
+ */
+wxRegion::wxRegion()
+{
+    m_refData = new wxRegionRefData;
+    // TODO create empty region
+}
+
+wxRegion::wxRegion(long x, long y, long w, long h)
+{
+    m_refData = new wxRegionRefData;
+    // TODO create rect region
+}
+
+wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
+{
+    m_refData = new wxRegionRefData;
+    // TODO create rect region
+}
+
+wxRegion::wxRegion(const wxRect& rect)
+{
+    m_refData = new wxRegionRefData;
+    // TODO create rect region
+}
+
+/*!
+ * Destroy the region.
+ */
+wxRegion::~wxRegion()
+{
+    // m_refData unrefed in ~wxObject
+}
+
+//-----------------------------------------------------------------------------
+//# Modify region
+//-----------------------------------------------------------------------------
+
+//! Clear current region
+void wxRegion::Clear()
+{
+    UnRef();
+}
+
+//! Combine rectangle (x, y, w, h) with this.
+bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op)
+{
+       // Don't change shared data
+       if (!m_refData) {
+               m_refData = new wxRegionRefData();
+       } else if (m_refData->GetRefCount() > 1) {
+               wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+               UnRef();
+               m_refData = new wxRegionRefData(*ref);
+       }
+    // If ref count is 1, that means it's 'ours' anyway so no action.
+
+    // TODO create rect region
+
+    int mode = 0; // TODO platform-specific code
+    switch (op)
+    {
+        case wxRGN_AND:
+            // TODO
+            break ;
+        case wxRGN_OR:
+            // TODO
+            break ;
+        case wxRGN_XOR:
+            // TODO
+            break ;
+        case wxRGN_DIFF:
+            // TODO
+            break ;
+        case wxRGN_COPY:
+        default:
+            // TODO
+            break ;
+    }
+
+    // TODO do combine region
+
+    return FALSE;
+}
+
+//! Union /e region with this.
+bool wxRegion::Combine(const wxRegion& region, wxRegionOp op)
+{
+       if (region.Empty())
+               return FALSE;
+
+       // Don't change shared data
+       if (!m_refData) {
+               m_refData = new wxRegionRefData();
+       } else  if (m_refData->GetRefCount() > 1) {
+               wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+               UnRef();
+               m_refData = new wxRegionRefData(*ref);
+       }
+
+    int mode = 0; // TODO platform-specific code
+    switch (op)
+    {
+        case wxRGN_AND:
+            // TODO
+            break ;
+        case wxRGN_OR:
+            // TODO
+            break ;
+        case wxRGN_XOR:
+            // TODO
+            break ;
+        case wxRGN_DIFF:
+            // TODO
+            break ;
+        case wxRGN_COPY:
+        default:
+            // TODO
+            break ;
+    }
+
+    // TODO combine region
+
+       return FALSE;
+}
+
+bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
+{
+    return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
+}
+
+//-----------------------------------------------------------------------------
+//# Information on region
+//-----------------------------------------------------------------------------
+
+// Outer bounds of region
+void wxRegion::GetBox(long& x, long& y, long&w, long &h) const
+{
+       if (m_refData) {
+        // TODO get box
+       } else {
+               x = y = w = h = 0;
+       }
+}
+
+wxRect wxRegion::GetBox() const
+{
+    long x, y, w, h;
+    GetBox(x, y, w, h);
+    return wxRect(x, y, w, h);
+}
+
+// Is region empty?
+bool wxRegion::Empty() const
+{
+    // TODO
+    return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+//# Tests
+//-----------------------------------------------------------------------------
+
+// Does the region contain the point (x,y)?
+wxRegionContain wxRegion::Contains(long x, long y) const
+{
+       if (!m_refData)
+               return wxOutRegion;
+
+    // TODO. Return wxInRegion if within region.
+    if (0)
+        return wxInRegion;
+    return wxOutRegion;
+}
+
+// Does the region contain the point pt?
+wxRegionContain wxRegion::Contains(const wxPoint& pt) const
+{
+       if (!m_refData)
+               return wxOutRegion;
+
+    // TODO. Return wxInRegion if within region.
+    if (0)
+        return wxInRegion;
+    else
+        return wxOutRegion;
+}
+
+// Does the region contain the rectangle (x, y, w, h)?
+wxRegionContain wxRegion::Contains(long x, long y, long w, long h) const
+{
+       if (!m_refData)
+               return wxOutRegion;
+
+    // TODO. Return wxInRegion if within region.
+    if (0)
+        return wxInRegion;
+    else
+        return wxOutRegion;
+}
+
+// Does the region contain the rectangle rect
+wxRegionContain wxRegion::Contains(const wxRect& rect) const
+{
+       if (!m_refData)
+               return wxOutRegion;
+
+    long x, y, w, h;
+    x = rect.x;
+    y = rect.y;
+    w = rect.GetWidth();
+    h = rect.GetHeight();
+    return Contains(x, y, w, h);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                                                                                                      //
+//                                                        wxRegionIterator                                                              //
+//                                                                                                                                                      //
+///////////////////////////////////////////////////////////////////////////////
+
+/*!
+ * Initialize empty iterator
+ */
+wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL)
+{
+}
+
+wxRegionIterator::~wxRegionIterator()
+{
+    if (m_rects)
+        delete[] m_rects;
+}
+
+/*!
+ * Initialize iterator for region
+ */
+wxRegionIterator::wxRegionIterator(const wxRegion& region)
+{
+    m_rects = NULL;
+
+       Reset(region);
+}
+
+/*!
+ * Reset iterator for a new /e region.
+ */
+void wxRegionIterator::Reset(const wxRegion& region)
+{
+       m_current = 0;
+       m_region = region;
+
+    if (m_rects)
+        delete[] m_rects;
+
+    m_rects = NULL;
+
+       if (m_region.Empty())
+               m_numRects = 0;
+       else
+    {
+        // TODO create m_rects and fill with rectangles for this region
+        m_numRects = 0;
+    }
+}
+
+/*!
+ * Increment iterator. The rectangle returned is the one after the
+ * incrementation.
+ */
+void wxRegionIterator::operator ++ ()
+{
+       if (m_current < m_numRects)
+               ++m_current;
+}
+
+/*!
+ * Increment iterator. The rectangle returned is the one before the
+ * incrementation.
+ */
+void wxRegionIterator::operator ++ (int)
+{
+       if (m_current < m_numRects)
+               ++m_current;
+}
+
+long wxRegionIterator::GetX() const
+{
+       if (m_current < m_numRects)
+               return m_rects[m_current].x;
+       return 0;
+}
+
+long wxRegionIterator::GetY() const
+{
+       if (m_current < m_numRects)
+               return m_rects[m_current].y;
+       return 0;
+}
+
+long wxRegionIterator::GetW() const
+{
+       if (m_current < m_numRects)
+               return m_rects[m_current].width ;
+       return 0;
+}
+
+long wxRegionIterator::GetH() const
+{
+       if (m_current < m_numRects)
+               return m_rects[m_current].height;
+       return 0;
+}
+

diff --git a/src/motif/scrolbar.cpp b/src/motif/scrolbar.cpp
new file mode 100644 (file)
index 0000000..99e5316
--- /dev/null
+++ b/src/motif/scrolbar.cpp
@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        scrolbar.cpp
+// Purpose:     wxScrollBar
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "scrolbar.h"
+#endif
+
+#include "wx/scrolbar.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
+
+#endif
+
+// Scrollbar
+bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    if (!parent)
+        return FALSE;
+    parent->AddChild(this);
+    SetName(name);
+       SetValidator(validator);
+    
+    m_windowStyle = style;
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    // TODO create scrollbar
+    return TRUE;
+}
+
+wxScrollBar::~wxScrollBar()
+{
+}
+
+void wxScrollBar::SetPosition(int viewStart)
+{
+    // TODO
+}
+
+int wxScrollBar::GetPosition() const
+{
+    // TODO
+    return 0;
+}
+
+void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageSize,
+    bool refresh)
+{
+    m_viewSize = pageSize;
+    m_pageSize = thumbSize;
+    m_objectSize = range;
+
+    // TODO
+}
+
+
+void wxScrollBar::Command(wxCommandEvent& event)
+{
+    SetPosition(event.m_commandInt);
+    ProcessCommand(event);
+}
+

diff --git a/src/motif/settings.cpp b/src/motif/settings.cpp
new file mode 100644 (file)
index 0000000..17f57f9
--- /dev/null
+++ b/src/motif/settings.cpp
@@ -0,0 +1,151 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        settings.cpp
+// Purpose:     wxSettings
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "settings.h"
+#endif
+
+#include "wx/settings.h"
+
+wxColour wxSystemSettings::GetSystemColour(int index)
+{
+    // TODO
+       return wxColour();
+}
+
+wxFont wxSystemSettings::GetSystemFont(int index)
+{
+    // TODO
+    return wxFont();
+}
+
+// Get a system metric, e.g. scrollbar size
+int wxSystemSettings::GetSystemMetric(int index)
+{
+       switch ( index)
+       {
+        case wxSYS_MOUSE_BUTTONS:
+            // TODO
+                       return 0;
+        case wxSYS_BORDER_X:
+            // TODO
+                       return 0;
+        case wxSYS_BORDER_Y:
+            // TODO
+                       return 0;
+        case wxSYS_CURSOR_X:
+            // TODO
+                       return 0;
+        case wxSYS_CURSOR_Y:
+            // TODO
+                       return 0;
+        case wxSYS_DCLICK_X:
+            // TODO
+                       return 0;
+        case wxSYS_DCLICK_Y:
+            // TODO
+                       return 0;
+        case wxSYS_DRAG_X:
+            // TODO
+                       return 0;
+        case wxSYS_DRAG_Y:
+            // TODO
+                       return 0;
+        case wxSYS_EDGE_X:
+            // TODO
+                       return 0;
+        case wxSYS_EDGE_Y:
+            // TODO
+                       return 0;
+        case wxSYS_HSCROLL_ARROW_X:
+            // TODO
+                       return 0;
+        case wxSYS_HSCROLL_ARROW_Y:
+            // TODO
+                       return 0;
+        case wxSYS_HTHUMB_X:
+            // TODO
+                       return 0;
+        case wxSYS_ICON_X:
+            // TODO
+                       return 0;
+        case wxSYS_ICON_Y:
+            // TODO
+                       return 0;
+        case wxSYS_ICONSPACING_X:
+            // TODO
+                       return 0;
+        case wxSYS_ICONSPACING_Y:
+            // TODO
+                       return 0;
+        case wxSYS_WINDOWMIN_X:
+            // TODO
+                       return 0;
+        case wxSYS_WINDOWMIN_Y:
+            // TODO
+                       return 0;
+        case wxSYS_SCREEN_X:
+            // TODO
+                       return 0;
+        case wxSYS_SCREEN_Y:
+            // TODO
+                       return 0;
+        case wxSYS_FRAMESIZE_X:
+            // TODO
+                       return 0;
+        case wxSYS_FRAMESIZE_Y:
+            // TODO
+                       return 0;
+        case wxSYS_SMALLICON_X:
+            // TODO
+                       return 0;
+        case wxSYS_SMALLICON_Y:
+            // TODO
+                       return 0;
+        case wxSYS_HSCROLL_Y:
+            // TODO
+                       return 0;
+        case wxSYS_VSCROLL_X:
+            // TODO
+                       return 0;
+        case wxSYS_VSCROLL_ARROW_X:
+            // TODO
+                       return 0;
+        case wxSYS_VSCROLL_ARROW_Y:
+            // TODO
+                       return 0;
+        case wxSYS_VTHUMB_Y:
+            // TODO
+                       return 0;
+        case wxSYS_CAPTION_Y:
+            // TODO
+                       return 0;
+        case wxSYS_MENU_Y:
+            // TODO
+                       return 0;
+        case wxSYS_NETWORK_PRESENT:
+            // TODO
+                       return 0;
+        case wxSYS_PENWINDOWS_PRESENT:
+            // TODO
+                       return 0;
+        case wxSYS_SHOW_SOUNDS:
+            // TODO
+                       return 0;
+        case wxSYS_SWAP_BUTTONS:
+            // TODO
+                       return 0;
+               default:
+                       return 0;
+       }
+       return 0;
+}
+

diff --git a/src/motif/slider.cpp b/src/motif/slider.cpp
new file mode 100644 (file)
index 0000000..a7c3788
--- /dev/null
+++ b/src/motif/slider.cpp
@@ -0,0 +1,190 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        slider.cpp
+// Purpose:     wxSlider
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "slider.h"
+#endif
+
+#include "wx/slider.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
+
+BEGIN_EVENT_TABLE(wxSlider, wxControl)
+END_EVENT_TABLE()
+#endif
+
+
+
+// Slider
+wxSlider::wxSlider()
+{
+  m_pageSize = 1;
+  m_lineSize = 1;
+  m_rangeMax = 0;
+  m_rangeMin = 0;
+  m_tickFreq = 0;
+}
+
+bool wxSlider::Create(wxWindow *parent, wxWindowID id,
+           int value, int minValue, int maxValue,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+
+    if (parent) parent->AddChild(this);
+
+    m_lineSize = 1;
+    m_windowStyle = style;
+    m_tickFreq = 0;
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    m_rangeMax = maxValue;
+    m_rangeMin = minValue;
+
+    m_pageSize = (int)((maxValue-minValue)/10);
+
+    // TODO create slider
+
+    return FALSE;
+}
+
+wxSlider::~wxSlider()
+{
+}
+
+int wxSlider::GetValue() const
+{
+    // TODO
+    return 0;
+}
+
+void wxSlider::SetValue(int value)
+{
+    // TODO
+}
+
+void wxSlider::GetSize(int *width, int *height) const
+{
+    // TODO
+}
+
+void wxSlider::GetPosition(int *x, int *y) const
+{
+    // TODO
+}
+
+void wxSlider::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxSlider::SetRange(int minValue, int maxValue)
+{
+    m_rangeMin = minValue;
+    m_rangeMax = maxValue;
+
+    // TODO
+}
+
+// For trackbars only
+void wxSlider::SetTickFreq(int n, int pos)
+{
+    // TODO
+    m_tickFreq = n;
+}
+
+void wxSlider::SetPageSize(int pageSize)
+{
+    // TODO
+    m_pageSize = pageSize;
+}
+
+int wxSlider::GetPageSize() const
+{
+    return m_pageSize;
+}
+
+void wxSlider::ClearSel()
+{
+    // TODO
+}
+
+void wxSlider::ClearTicks()
+{
+    // TODO
+}
+
+void wxSlider::SetLineSize(int lineSize)
+{
+    m_lineSize = lineSize;
+    // TODO
+}
+
+int wxSlider::GetLineSize() const
+{
+    // TODO
+    return 0;
+}
+
+int wxSlider::GetSelEnd() const
+{
+    // TODO
+    return 0;
+}
+
+int wxSlider::GetSelStart() const
+{
+    // TODO
+    return 0;
+}
+
+void wxSlider::SetSelection(int minPos, int maxPos)
+{
+    // TODO
+}
+
+void wxSlider::SetThumbLength(int len)
+{
+    // TODO
+}
+
+int wxSlider::GetThumbLength() const
+{
+    // TODO
+    return 0;
+}
+
+void wxSlider::SetTick(int tickPos)
+{
+    // TODO
+}
+
+void wxSlider::Command (wxCommandEvent & event)
+{
+  SetValue (event.GetInt());
+  ProcessCommand (event);
+}
+
+bool wxSlider::Show(bool show)
+{
+    // TODO
+    return TRUE;
+}
+

diff --git a/src/motif/spinbutt.cpp b/src/motif/spinbutt.cpp
new file mode 100644 (file)
index 0000000..5111233
--- /dev/null
+++ b/src/motif/spinbutt.cpp
@@ -0,0 +1,78 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        spinbutt.cpp
+// Purpose:     wxSpinButton
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "spinbutt.h"
+#endif
+
+#include "wx/spinbutt.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxSpinButton, wxControl)
+#endif
+
+wxSpinButton::wxSpinButton()
+{
+       m_min = 0;
+       m_max = 100;
+}
+
+bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxString& name)
+{
+    SetName(name);
+
+    m_windowStyle = style;
+
+    SetParent(parent);
+
+    m_min = 0;
+    m_max = 100;
+
+    m_windowId = (id == -1) ? NewControlId() : id;
+
+    // TODO create spin button
+    return FALSE;
+}
+
+wxSpinButton::~wxSpinButton()
+{
+}
+
+// Attributes
+////////////////////////////////////////////////////////////////////////////
+
+int wxSpinButton::GetValue() const
+{
+       // TODO
+    return 0;
+}
+
+void wxSpinButton::SetValue(int val)
+{
+       // TODO
+}
+
+void wxSpinButton::SetRange(int minVal, int maxVal)
+{
+       m_min = minVal;
+       m_max = maxVal;
+       // TODO
+}
+
+// Spin event
+IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxScrollEvent)
+
+wxSpinEvent::wxSpinEvent(wxEventType commandType, int id):
+  wxScrollEvent(commandType, id)
+{
+}
+

diff --git a/src/motif/statbmp.cpp b/src/motif/statbmp.cpp
new file mode 100644 (file)
index 0000000..05acdc7
--- /dev/null
+++ b/src/motif/statbmp.cpp
@@ -0,0 +1,59 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        statbmp.cpp
+// Purpose:     wxStaticBitmap
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "statbmp.h"
+#endif
+
+#include "wx/statbmp.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
+#endif
+
+/*
+ * wxStaticBitmap
+ */
+
+bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
+           const wxBitmap& bitmap,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+    m_messageBitmap = bitmap;
+    SetName(name);
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    m_windowStyle = style;
+
+    // TODO: create static bitmap control
+    return FALSE;
+}
+
+void wxStaticBitmap::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
+{
+    m_messageBitmap = bitmap;
+
+    // TODO: redraw bitmap
+}
+

diff --git a/src/motif/statbox.cpp b/src/motif/statbox.cpp
new file mode 100644 (file)
index 0000000..9b46697
--- /dev/null
+++ b/src/motif/statbox.cpp
@@ -0,0 +1,62 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        statbox.cpp
+// Purpose:     wxStaticBox
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "statbox.h"
+#endif
+
+#include "wx/statbox.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
+
+BEGIN_EVENT_TABLE(wxStaticBox, wxControl)
+       EVT_ERASE_BACKGROUND(wxStaticBox::OnEraseBackground)
+END_EVENT_TABLE()
+
+#endif
+
+/*
+ * Static box
+ */
+ 
+bool wxStaticBox::Create(wxWindow *parent, wxWindowID id,
+           const wxString& label,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+    SetName(name);
+
+    if (parent) parent->AddChild(this);
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    m_windowStyle = style;
+
+    // TODO: create static box
+    return FALSE;
+}
+
+void wxStaticBox::SetLabel(const wxString& label)
+{
+    // TODO
+}
+
+void wxStaticBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+

diff --git a/src/motif/stattext.cpp b/src/motif/stattext.cpp
new file mode 100644 (file)
index 0000000..294f510
--- /dev/null
+++ b/src/motif/stattext.cpp
@@ -0,0 +1,60 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        stattext.cpp
+// Purpose:     wxStaticText
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "stattext.h"
+#endif
+
+#include "wx/app.h"
+#include "wx/stattext.h"
+
+#include <stdio.h>
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
+#endif
+
+bool wxStaticText::Create(wxWindow *parent, wxWindowID id,
+           const wxString& label,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+  SetName(name);
+  if (parent) parent->AddChild(this);
+
+  SetBackgroundColour(parent->GetDefaultBackgroundColour()) ;
+  SetForegroundColour(parent->GetDefaultForegroundColour()) ;
+
+  if ( id == -1 )
+       m_windowId = (int)NewControlId();
+  else
+       m_windowId = id;
+
+  m_windowStyle = style;
+
+  SetFont(* parent->GetFont());
+
+  // TODO
+  return FALSE;
+}
+
+void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+void wxStaticText::SetLabel(const wxString& label)
+{
+    // TODO
+}
+

diff --git a/src/motif/statusbr.cpp b/src/motif/statusbr.cpp
new file mode 100644 (file)
index 0000000..9785132
--- /dev/null
+++ b/src/motif/statusbr.cpp
@@ -0,0 +1,162 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        statbar.cpp
+// Purpose:     native implementation of wxStatusBar (optional)
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 Julian Smart
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "statusbr.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/stubs/statusbr.h"
+
+#if     !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStatusBarXX, wxStatusBar);
+
+BEGIN_EVENT_TABLE(wxStatusBarXX, wxStatusBar)
+    EVT_SIZE(wxStatusBarXX::OnSize)
+END_EVENT_TABLE()
+#endif  //USE_SHARED_LIBRARY
+
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxStatusBarXX class
+// ----------------------------------------------------------------------------
+
+wxStatusBarXX::wxStatusBarXX()
+{
+    SetParent(NULL);
+}
+
+wxStatusBarXX::wxStatusBarXX(wxWindow *parent, wxWindowID id, long style)
+{
+    Create(parent, id, style);
+}
+
+bool wxStatusBarXX::Create(wxWindow *parent, wxWindowID id, long style)
+{
+    SetParent(parent);
+
+    if (id == -1)
+        m_windowId = NewControlId();
+    else
+        m_windowId = id;
+
+    // TODO: create status bar
+    return FALSE;
+}
+
+void wxStatusBarXX::SetFieldsCount(int nFields, const int widths[])
+{
+  wxASSERT( (nFields > 0) && (nFields < 255) );
+
+  m_nFields = nFields;
+
+  CopyFieldsWidth(widths);
+  SetFieldsWidth();
+}
+
+void wxStatusBarXX::SetStatusWidths(int n, const int widths[])
+{
+  wxASSERT( n == m_nFields );
+
+  CopyFieldsWidth(widths);
+  SetFieldsWidth();
+}
+
+void wxStatusBarXX::CopyFieldsWidth(const int widths[])
+{
+  if (widths && !m_statusWidths)
+    m_statusWidths = new int[m_nFields];
+
+  if ( widths != NULL ) {
+    for ( int i = 0; i < m_nFields; i++ )
+      m_statusWidths[i] = widths[i];
+  }
+  else {
+    delete [] m_statusWidths;
+    m_statusWidths = NULL;
+  }
+}
+
+void wxStatusBarXX::SetFieldsWidth()
+{
+  int *pWidths = new int[m_nFields];
+
+  int nWindowWidth, y;
+  GetClientSize(&nWindowWidth, &y);
+
+  if ( m_statusWidths == NULL ) {
+    // default: all fields have the same width
+    int nWidth = nWindowWidth / m_nFields;
+    for ( int i = 0; i < m_nFields; i++ )
+      pWidths[i] = (i + 1) * nWidth;
+  }
+  else {
+    // -1 doesn't mean the same thing for wxWindows and Win32, recalc
+    int nTotalWidth = 0, 
+        nVarCount = 0, 
+        i;
+    for ( i = 0; i < m_nFields; i++ ) {
+      if ( m_statusWidths[i] == -1 )
+        nVarCount++;
+      else
+        nTotalWidth += m_statusWidths[i];
+    }
+
+    if ( nVarCount == 0 ) {
+      // wrong! at least one field must be of variable width
+      wxFAIL;
+
+      nVarCount++;
+    }
+
+    int nVarWidth = (nWindowWidth - nTotalWidth) / nVarCount;
+
+    // do fill the array
+    int nCurPos = 0;
+    for ( i = 0; i < m_nFields; i++ ) {
+      if ( m_statusWidths[i] == -1 )
+        nCurPos += nVarWidth;
+      else
+        nCurPos += m_statusWidths[i];
+      pWidths[i] = nCurPos;
+    }
+  }
+
+  // TODO: set widths
+
+  delete [] pWidths;
+}
+
+void wxStatusBarXX::SetStatusText(const wxString& strText, int nField)
+{
+    // TODO
+}
+
+wxString wxStatusBarXX::GetStatusText(int nField) const
+{
+    wxASSERT( (nField > -1) && (nField < m_nFields) );
+
+    // TODO
+    return wxString("");
+}
+
+void wxStatusBarXX::OnSize(wxSizeEvent& event)
+{
+    // adjust fields widths to the new size
+    SetFieldsWidth();
+}

diff --git a/src/motif/tabctrl.cpp b/src/motif/tabctrl.cpp
new file mode 100644 (file)
index 0000000..07216d2
--- /dev/null
+++ b/src/motif/tabctrl.cpp
@@ -0,0 +1,201 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        tabctrl.cpp
+// Purpose:     wxTabCtrl
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "tabctrl.h"
+#endif
+
+#include "wx/control.h"
+#include "wx/tabctrl.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxTabCtrl, wxControl)
+
+BEGIN_EVENT_TABLE(wxTabCtrl, wxControl)
+END_EVENT_TABLE()
+#endif
+
+wxTabCtrl::wxTabCtrl()
+{
+    m_imageList = NULL;
+}
+
+bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxString& name)
+{
+    m_imageList = NULL;
+
+    SetName(name);
+
+    m_windowStyle = style;
+
+    SetParent(parent);
+
+    m_windowId = (id < 0 ? NewControlId() : id);
+
+    if (parent) parent->AddChild(this);
+
+    // TODO: create tab control
+    return FALSE;
+}
+
+wxTabCtrl::~wxTabCtrl()
+{
+}
+
+void wxTabCtrl::Command(wxCommandEvent& event)
+{
+}
+
+// Delete all items
+bool wxTabCtrl::DeleteAllItems()
+{
+    // TODO
+    return FALSE;
+}
+
+// Delete an item
+bool wxTabCtrl::DeleteItem(int item)
+{
+    // TODO
+    return FALSE;
+}
+
+// Get the selection
+int wxTabCtrl::GetSelection() const
+{
+    // TODO
+    return 0;
+}
+
+// Get the tab with the current keyboard focus
+int wxTabCtrl::GetCurFocus() const
+{
+    // TODO
+    return 0;
+}
+
+// Get the associated image list
+wxImageList* wxTabCtrl::GetImageList() const
+{
+    return m_imageList;
+}
+
+// Get the number of items
+int wxTabCtrl::GetItemCount() const
+{
+    // TODO
+    return 0;
+}
+
+// Get the rect corresponding to the tab
+bool wxTabCtrl::GetItemRect(int item, wxRect& wxrect) const
+{
+    // TODO
+    return FALSE;
+}
+
+// Get the number of rows
+int wxTabCtrl::GetRowCount() const
+{
+    // TODO
+    return 0;
+}
+
+// Get the item text
+wxString wxTabCtrl::GetItemText(int item) const
+{
+    // TODO
+    return wxString("");
+}
+
+// Get the item image
+int wxTabCtrl::GetItemImage(int item) const
+{
+    // TODO
+    return 0;
+}
+
+// Get the item data
+void* wxTabCtrl::GetItemData(int item) const
+{
+    // TODO
+    return NULL;
+}
+
+// Hit test
+int wxTabCtrl::HitTest(const wxPoint& pt, long& flags)
+{
+    // TODO
+    return 0;
+}
+
+// Insert an item
+bool wxTabCtrl::InsertItem(int item, const wxString& text, int imageId, void* data)
+{
+    // TODO
+    return FALSE;
+}
+
+// Set the selection
+int wxTabCtrl::SetSelection(int item)
+{
+    // TODO
+    return 0;
+}
+
+// Set the image list
+void wxTabCtrl::SetImageList(wxImageList* imageList)
+{
+    // TODO
+}
+
+// Set the text for an item
+bool wxTabCtrl::SetItemText(int item, const wxString& text)
+{
+    // TODO
+    return FALSE;
+}
+
+// Set the image for an item
+bool wxTabCtrl::SetItemImage(int item, int image)
+{
+    // TODO
+    return FALSE;
+}
+
+// Set the data for an item
+bool wxTabCtrl::SetItemData(int item, void* data)
+{
+    // TODO
+    return FALSE;
+}
+
+// Set the size for a fixed-width tab control
+void wxTabCtrl::SetItemSize(const wxSize& size)
+{
+    // TODO
+}
+
+// Set the padding between tabs
+void wxTabCtrl::SetPadding(const wxSize& padding)
+{
+    // TODO
+}
+
+// Tab event
+IMPLEMENT_DYNAMIC_CLASS(wxTabEvent, wxCommandEvent)
+
+wxTabEvent::wxTabEvent(wxEventType commandType, int id):
+  wxCommandEvent(commandType, id)
+{
+}
+

diff --git a/src/motif/taskbar.cpp b/src/motif/taskbar.cpp
new file mode 100644 (file)
index 0000000..75f12c0
--- /dev/null
+++ b/src/motif/taskbar.cpp
@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////////
+// File:        taskbar.cpp
+// Purpose:        Implements wxTaskBarIcon class for manipulating icons on
+//              the task bar. Optional.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c)
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "taskbar.h"
+#endif
+
+#include <wx/taskbar.h>
+
+wxTaskBarIcon::wxTaskBarIcon()
+{
+    // TODO
+}
+
+wxTaskBarIcon::~wxTaskBarIcon()
+{
+    // TODO
+}
+
+// Operations
+bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTaskBarIcon::RemoveIcon()
+{
+    // TODO
+    return FALSE;
+}
+
+// Overridables
+void wxTaskBarIcon::OnMouseMove()
+{
+}
+
+void wxTaskBarIcon::OnLButtonDown()
+{
+}
+
+void wxTaskBarIcon::OnLButtonUp()
+{
+}
+
+void wxTaskBarIcon::OnRButtonDown()
+{
+}
+
+void wxTaskBarIcon::OnRButtonUp()
+{
+}
+
+void wxTaskBarIcon::OnLButtonDClick()
+{
+}
+
+void wxTaskBarIcon::OnRButtonDClick()
+{
+}
+

diff --git a/src/motif/textctrl.cpp b/src/motif/textctrl.cpp
new file mode 100644 (file)
index 0000000..6727160
--- /dev/null
+++ b/src/motif/textctrl.cpp
@@ -0,0 +1,438 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        textctrl.cpp
+// Purpose:     wxTextCtrl
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "textctrl.h"
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fstream.h>
+
+#include "wx/textctrl.h"
+#include "wx/settings.h"
+#include "wx/filefn.h"
+#include "wx/utils.h"
+
+#if defined(__BORLANDC__) && !defined(__WIN32__)
+#include <alloc.h>
+#else
+#ifndef __GNUWIN32__
+#include <malloc.h>
+#endif
+#endif
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
+
+BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
+       EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
+END_EVENT_TABLE()
+#endif
+
+// Text item
+wxTextCtrl::wxTextCtrl()
+#ifndef NO_TEXT_WINDOW_STREAM
+ :streambuf()
+#endif
+{
+    m_fileName = "";
+}
+
+bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
+                  const wxString& value,
+           const wxPoint& pos,
+           const wxSize& size, long style,
+           const wxValidator& validator,
+           const wxString& name)
+{
+    m_fileName = "";
+    SetName(name);
+    SetValidator(validator);
+    if (parent) parent->AddChild(this);
+
+    m_windowStyle = style;
+
+    if ( id == -1 )
+           m_windowId = (int)NewControlId();
+    else
+           m_windowId = id;
+
+    return TRUE;
+}
+
+wxString wxTextCtrl::GetValue() const
+{
+    // TODO
+    return wxString("");
+}
+
+void wxTextCtrl::SetValue(const wxString& value)
+{
+    // TODO
+}
+
+void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // TODO
+}
+
+// Clipboard operations
+void wxTextCtrl::Copy()
+{
+    // TODO
+}
+
+void wxTextCtrl::Cut()
+{
+    // TODO
+}
+
+void wxTextCtrl::Paste()
+{
+    // TODO
+}
+
+void wxTextCtrl::SetEditable(bool editable)
+{
+    // TODO
+}
+
+void wxTextCtrl::SetInsertionPoint(long pos)
+{
+    // TODO
+}
+
+void wxTextCtrl::SetInsertionPointEnd()
+{
+    long pos = GetLastPosition();
+    SetInsertionPoint(pos);
+}
+
+long wxTextCtrl::GetInsertionPoint() const
+{
+    // TODO
+    return 0;
+}
+
+long wxTextCtrl::GetLastPosition() const
+{
+    // TODO
+    return 0;
+}
+
+void wxTextCtrl::Replace(long from, long to, const wxString& value)
+{
+    // TODO
+}
+
+void wxTextCtrl::Remove(long from, long to)
+{
+    // TODO
+}
+
+void wxTextCtrl::SetSelection(long from, long to)
+{
+    // TODO
+}
+
+bool wxTextCtrl::LoadFile(const wxString& file)
+{
+    if (!wxFileExists(file))
+        return FALSE;
+
+    m_fileName = file;
+
+    Clear();
+
+    ifstream input((char*) (const char*) file, ios::nocreate | ios::in);
+
+    if (!input.bad())
+    {
+        struct stat stat_buf;
+        if (stat(file, &stat_buf) < 0)
+            return FALSE;
+        // This may need to be a bigger buffer than the file size suggests,
+        // if it's a UNIX file. Give it an extra 1000 just in case.
+        char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000));
+        long no_lines = 0;
+        long pos = 0;
+        while (!input.eof() && input.peek() != EOF)
+        {
+            input.getline(wxBuffer, 500);
+               int len = strlen(wxBuffer);
+               wxBuffer[len] = 13;
+               wxBuffer[len+1] = 10;
+               wxBuffer[len+2] = 0;
+               strcpy(tmp_buffer+pos, wxBuffer);
+               pos += strlen(wxBuffer);
+               no_lines++;
+         }
+
+         // TODO add line
+
+         free(tmp_buffer);
+
+         return TRUE;
+    }
+    return FALSE;
+}
+
+// If file is null, try saved file name first
+// Returns TRUE if succeeds.
+bool wxTextCtrl::SaveFile(const wxString& file)
+{
+    wxString theFile(file);
+    if (theFile == "")
+        theFile = m_fileName;
+    if (theFile == "")
+        return FALSE;
+    m_fileName = theFile;
+
+    ofstream output((char*) (const char*) theFile);
+    if (output.bad())
+           return FALSE;
+
+    // TODO get and save text
+
+    return FALSE;
+}
+
+void wxTextCtrl::WriteText(const wxString& text)
+{
+    // TODO write text to control
+}
+
+void wxTextCtrl::Clear()
+{
+    // TODO
+}
+
+bool wxTextCtrl::IsModified() const
+{
+    // TODO
+    return FALSE;
+}
+
+// Makes 'unmodified'
+void wxTextCtrl::DiscardEdits()
+{
+    // TODO
+}
+
+int wxTextCtrl::GetNumberOfLines() const
+{
+    // TODO
+    return 0;
+}
+
+long wxTextCtrl::XYToPosition(long x, long y) const
+{
+    // TODO
+    return 0;
+}
+
+void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
+{
+    // TODO
+}
+
+void wxTextCtrl::ShowPosition(long pos)
+{
+    // TODO
+}
+
+int wxTextCtrl::GetLineLength(long lineNo) const
+{
+    // TODO
+    return 0;
+}
+
+wxString wxTextCtrl::GetLineText(long lineNo) const
+{
+    // TODO
+    return wxString("");
+}
+
+/*
+ * Text item
+ */
+ 
+void wxTextCtrl::Command(wxCommandEvent & event)
+{
+    SetValue (event.GetString());
+    ProcessCommand (event);
+}
+
+void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
+{
+    // By default, load the first file into the text window.
+    if (event.GetNumberOfFiles() > 0)
+    {
+        LoadFile(event.GetFiles()[0]);
+    }
+}
+
+// The streambuf code was partly taken from chapter 3 by Jerry Schwarz of
+// AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers
+
+//=========================================================================
+// Called then the buffer is full (gcc 2.6.3) 
+// or when "endl" is output (Borland 4.5)
+//=========================================================================
+// Class declaration using multiple inheritance doesn't work properly for
+// Borland. See note in wb_text.h.
+#ifndef NO_TEXT_WINDOW_STREAM
+int wxTextCtrl::overflow(int c)
+{
+  // Make sure there is a holding area
+  if ( allocate()==EOF )
+  {
+    wxError("Streambuf allocation failed","Internal error");
+    return EOF;
+  }
+  
+  // Verify that there are no characters in get area
+  if ( gptr() && gptr() < egptr() )
+  {
+     wxError("Who's trespassing my get area?","Internal error");
+     return EOF;
+  }
+
+  // Reset get area
+  setg(0,0,0);
+
+  // Make sure there is a put area
+  if ( ! pptr() )
+  {
+/* This doesn't seem to be fatal so comment out error message */
+//    wxError("Put area not opened","Internal error");
+    setp( base(), base() );
+  }
+
+  // Determine how many characters have been inserted but no consumed
+  int plen = pptr() - pbase();
+
+  // Now Jerry relies on the fact that the buffer is at least 2 chars
+  // long, but the holding area "may be as small as 1" ???
+  // And we need an additional \0, so let's keep this inefficient but
+  // safe copy.
+
+  // If c!=EOF, it is a character that must also be comsumed
+  int xtra = c==EOF? 0 : 1;
+
+  // Write temporary C-string to wxTextWindow
+  {
+  char *txt = new char[plen+xtra+1];
+  memcpy(txt, pbase(), plen);
+  txt[plen] = (char)c;     // append c
+  txt[plen+xtra] = '\0';   // append '\0' or overwrite c
+    // If the put area already contained \0, output will be truncated there
+  WriteText(txt);
+    delete[] txt;
+  }
+
+  // Reset put area
+  setp(pbase(), epptr());
+
+#if defined(__WATCOMC__)
+  return __NOT_EOF;
+#elif defined(zapeof)     // HP-UX (all cfront based?)
+  return zapeof(c);
+#else
+  return c!=EOF ? c : 0;  // this should make everybody happy
+#endif
+}
+
+//=========================================================================
+// called then "endl" is output (gcc) or then explicit sync is done (Borland)
+//=========================================================================
+int wxTextCtrl::sync()
+{
+  // Verify that there are no characters in get area
+  if ( gptr() && gptr() < egptr() )
+  {
+     wxError("Who's trespassing my get area?","Internal error");
+     return EOF;
+  }
+
+  if ( pptr() && pptr() > pbase() ) return overflow(EOF);
+
+  return 0;
+/* OLD CODE
+  int len = pptr() - pbase();
+  char *txt = new char[len+1];
+  strncpy(txt, pbase(), len);
+  txt[len] = '\0';
+  (*this) << txt;
+  setp(pbase(), epptr());
+  delete[] txt;
+  return 0;
+*/
+}
+
+//=========================================================================
+// Should not be called by a "ostream". Used by a "istream"
+//=========================================================================
+int wxTextCtrl::underflow()
+{
+  return EOF;
+}
+#endif
+
+wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
+{
+    WriteText(s);
+    return *this;
+}
+
+wxTextCtrl& wxTextCtrl::operator<<(float f)
+{
+    wxString str;
+    str.Printf("%.2f", f);
+    WriteText(str);
+    return *this;
+}
+
+wxTextCtrl& wxTextCtrl::operator<<(double d)
+{
+    wxString str;
+    str.Printf("%.2f", d);
+    WriteText(str);
+    return *this;
+}
+
+wxTextCtrl& wxTextCtrl::operator<<(int i)
+{
+    wxString str;
+    str.Printf("%d", i);
+    WriteText(str);
+    return *this;
+}
+
+wxTextCtrl& wxTextCtrl::operator<<(long i)
+{
+    wxString str;
+    str.Printf("%ld", i);
+    WriteText(str);
+    return *this;
+}
+
+wxTextCtrl& wxTextCtrl::operator<<(const char c)
+{
+    char buf[2];
+
+    buf[0] = c;
+    buf[1] = 0;
+    WriteText(buf);
+    return *this;
+}
+

diff --git a/src/motif/thread.cpp b/src/motif/thread.cpp
new file mode 100644 (file)
index 0000000..c197787
--- /dev/null
+++ b/src/motif/thread.cpp
@@ -0,0 +1,257 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        thread.cpp
+// Purpose:     wxThread Implementation. For Unix ports, see e.g. src/gtk
+// Author:      Original from Wolfram Gloger/Guilhem Lavaux
+// Modified by:
+// Created:     04/22/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "thread.h"
+#endif
+
+#include "wx/module.h"
+#include "wx/thread.h"
+#include "wx/utils.h"
+
+enum thread_state {
+  STATE_IDLE = 0,
+  STATE_RUNNING,
+  STATE_CANCELED,
+  STATE_EXITED
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Static variables
+/////////////////////////////////////////////////////////////////////////////
+
+wxMutex wxMainMutex; // controls access to all GUI functions
+
+/////////////////////////////////////////////////////////////////////////////
+// Windows implementation
+/////////////////////////////////////////////////////////////////////////////
+
+class wxMutexInternal {
+public:
+  // TODO: internal mutex handle
+};
+
+wxMutex::wxMutex()
+{
+    p_internal = new wxMutexInternal;
+    // TODO: create internal mutext handle
+    m_locked = 0;
+}
+
+wxMutex::~wxMutex()
+{
+    if (m_locked > 0)
+        wxDebugMsg("wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked);
+    // TODO: free internal mutext handle
+}
+
+wxMutexError wxMutex::Lock()
+{
+    // TODO
+    m_locked++;
+    return MUTEX_NO_ERROR;
+}
+
+wxMutexError wxMutex::TryLock()
+{
+    // TODO
+    m_locked++;
+    return MUTEX_NO_ERROR;
+}
+
+wxMutexError wxMutex::Unlock()
+{
+    if (m_locked > 0)
+        m_locked--;
+
+    // TODO
+    return MUTEX_NO_ERROR;
+}
+
+class wxConditionInternal {
+public:
+  // TODO: internal handle
+  int waiters;
+};
+
+wxCondition::wxCondition()
+{
+    p_internal = new wxConditionInternal;
+    // TODO: create internal handle
+    p_internal->waiters = 0;
+}
+
+wxCondition::~wxCondition()
+{
+    // TODO: destroy internal handle
+}
+
+void wxCondition::Wait(wxMutex& mutex)
+{
+    mutex.Unlock();
+    p_internal->waiters++;
+    // TODO wait here
+    p_internal->waiters--;
+    mutex.Lock();
+}
+
+bool wxCondition::Wait(wxMutex& mutex, unsigned long sec,
+                       unsigned long nsec)
+{
+    mutex.Unlock();
+    p_internal->waiters++;
+
+    // TODO wait here
+    p_internal->waiters--;
+    mutex.Lock();
+
+    return FALSE;
+}
+
+void wxCondition::Signal()
+{
+    // TODO
+}
+
+void wxCondition::Broadcast()
+{
+    // TODO
+}
+
+class wxThreadInternal {
+public:
+    // TODO
+};
+
+wxThreadError wxThread::Create()
+{
+    // TODO
+    return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Destroy()
+{
+    // TODO
+    return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+    // TODO
+    return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+    // TODO
+    return THREAD_NO_ERROR;
+}
+
+void wxThread::Exit(void *status)
+{
+    // TODO
+}
+
+void wxThread::SetPriority(int prio)
+{
+    // TODO
+}
+
+int wxThread::GetPriority() const
+{
+    // TODO
+    return 0;
+}
+
+void wxThread::DeferDestroy(bool on)
+{
+    // TODO
+}
+
+void wxThread::TestDestroy()
+{
+    // TODO
+}
+
+void *wxThread::Join()
+{
+    // TODO
+    return (void*) NULL;
+}
+
+unsigned long wxThread::GetID() const
+{
+    // TODO
+    return 0;
+}
+
+wxThread *wxThread::GetThreadFromID(unsigned long id)
+{
+    // TODO
+    return NULL;
+}
+
+bool wxThread::IsAlive() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxThread::IsRunning() const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxThread::IsMain()
+{
+    // TODO
+    return FALSE;
+}
+
+wxThread::wxThread()
+{
+    p_internal = new wxThreadInternal();
+
+    // TODO
+}
+
+wxThread::~wxThread()
+{
+    Destroy();
+    Join();
+    delete p_internal;
+}
+
+// The default callback just joins the thread and throws away the result.
+void wxThread::OnExit()
+{
+    Join();
+}
+
+// Automatic initialization
+class wxThreadModule : public wxModule {
+  DECLARE_DYNAMIC_CLASS(wxThreadModule)
+public:
+  virtual bool OnInit() {
+    /* TODO p_mainid = GetCurrentThread(); */
+    wxMainMutex.Lock();
+    return TRUE;
+  }
+
+  // Global cleanup
+  virtual void OnExit() {
+    wxMainMutex.Unlock();
+  }
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
+

diff --git a/src/motif/timer.cpp b/src/motif/timer.cpp
new file mode 100644 (file)
index 0000000..bca8e00
--- /dev/null
+++ b/src/motif/timer.cpp
@@ -0,0 +1,52 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        timer.cpp
+// Purpose:     wxTimer implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "timer.h"
+#endif
+
+#include "wx/timer.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
+#endif
+
+wxTimer::wxTimer()
+{
+    m_milli = 0 ;
+    m_id = 0;
+    m_oneShot = FALSE;
+}
+
+wxTimer::~wxTimer()
+{
+    Stop();
+}
+
+bool wxTimer::Start(int milliseconds,bool mode)
+{
+    m_oneShot = mode ;
+    if (milliseconds <= 0)
+        return FALSE;
+
+    m_milli = milliseconds;
+
+    // TODO: set the timer going.
+    return FALSE;
+}
+
+void wxTimer::Stop()
+{
+    m_id = 0 ;
+    m_milli = 0 ;
+}
+
+

diff --git a/src/motif/toolbar.cpp b/src/motif/toolbar.cpp
new file mode 100644 (file)
index 0000000..85b09f9
--- /dev/null
+++ b/src/motif/toolbar.cpp
@@ -0,0 +1,145 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        toolbar.cpp
+// Purpose:     wxToolBar
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "toolbar.h"
+#endif
+
+#include "wx/wx.h"
+#include "wx/toolbar.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
+
+BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
+END_EVENT_TABLE()
+#endif
+
+wxToolBar::wxToolBar()
+{
+  m_maxWidth = -1;
+  m_maxHeight = -1;
+  m_defaultWidth = 24;
+  m_defaultHeight = 22;
+  // TODO
+}
+
+bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxString& name)
+{
+    m_maxWidth = -1;
+    m_maxHeight = -1;
+  
+    m_defaultWidth = 24;
+    m_defaultHeight = 22;
+    SetName(name);
+
+    m_windowStyle = style;
+
+    SetParent(parent);
+
+    if (parent) parent->AddChild(this);
+
+    // TODO create toolbar
+  
+    return FALSE;
+}
+
+wxToolBar::~wxToolBar()
+{
+    // TODO
+}
+
+bool wxToolBar::CreateTools()
+{
+    if (m_tools.Number() == 0)
+        return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+void wxToolBar::SetToolBitmapSize(const wxSize& size)
+{
+    m_defaultWidth = size.x; m_defaultHeight = size.y;
+    // TODO
+}
+
+wxSize wxToolBar::GetMaxSize() const
+{
+    // TODO
+    return wxSize(0, 0);
+}
+
+// The button size is bigger than the bitmap size
+wxSize wxToolBar::GetToolSize() const
+{
+    // TODO
+    return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
+}
+
+void wxToolBar::EnableTool(int toolIndex, bool enable)
+{
+    wxNode *node = m_tools.Find((long)toolIndex);
+    if (node)
+    {
+        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
+        tool->m_enabled = enable;
+        // TODO enable button
+    }
+}
+
+void wxToolBar::ToggleTool(int toolIndex, bool toggle)
+{
+    wxNode *node = m_tools.Find((long)toolIndex);
+    if (node)
+    {
+        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
+        if (tool->m_isToggle)
+        {
+            tool->m_toggleState = toggle;
+            // TODO: set toggle state
+        }
+    }
+}
+
+void wxToolBar::ClearTools()
+{
+    // TODO
+    wxToolBarBase::ClearTools();
+}
+
+// If pushedBitmap is NULL, a reversed version of bitmap is
+// created and used as the pushed/toggled image.
+// If toggle is TRUE, the button toggles between the two states.
+
+wxToolBarTool *wxToolBar::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
+             bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
+{
+  wxToolBarTool *tool = new wxToolBarTool(index, bitmap, (wxBitmap *)NULL, toggle, xPos, yPos, helpString1, helpString2);
+  tool->m_clientData = clientData;
+
+  if (xPos > -1)
+    tool->m_x = xPos;
+  else
+    tool->m_x = m_xMargin;
+
+  if (yPos > -1)
+    tool->m_y = yPos;
+  else
+    tool->m_y = m_yMargin;
+
+  tool->SetSize(GetDefaultButtonWidth(), GetDefaultButtonHeight());
+
+  m_tools.Append((long)index, tool);
+  return tool;
+}
+

diff --git a/src/motif/treectrl.cpp b/src/motif/treectrl.cpp
new file mode 100644 (file)
index 0000000..7d7147e
--- /dev/null
+++ b/src/motif/treectrl.cpp
@@ -0,0 +1,418 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        treectrl.cpp
+// Purpose:     wxTreeCtrl. See also Robert's generic wxTreeCtrl.
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "treectrl.h"
+#endif
+
+#include "wx/stubs/textctrl.h"
+#include "wx/stubs/treectrl.h"
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxTreeItem, wxObject)
+
+#endif
+
+wxTreeCtrl::wxTreeCtrl()
+{
+    m_imageListNormal = NULL;
+    m_imageListState = NULL;
+    m_textCtrl = NULL;
+}
+
+bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxValidator& validator, const wxString& name)
+{
+    SetName(name);
+    SetValidator(validator);
+
+    m_imageListNormal = NULL;
+    m_imageListState = NULL;
+    m_textCtrl = NULL;
+
+    m_windowStyle = style;
+
+    SetParent(parent);
+
+    m_windowId = (id == -1) ? NewControlId() : id;
+
+    if (parent) parent->AddChild(this);
+
+    // TODO create tree control
+
+    return FALSE;
+}
+
+wxTreeCtrl::~wxTreeCtrl()
+{
+    if (m_textCtrl)
+    {
+        delete m_textCtrl;
+    }
+}
+
+// Attributes
+int wxTreeCtrl::GetCount() const
+{
+    // TODO
+    return 0;
+}
+
+int wxTreeCtrl::GetIndent() const
+{
+    // TODO
+    return 0;
+}
+
+void wxTreeCtrl::SetIndent(int indent)
+{
+    // TODO
+}
+
+wxImageList *wxTreeCtrl::GetImageList(int which) const
+{
+  if ( which == wxIMAGE_LIST_NORMAL )
+    {
+    return m_imageListNormal;
+  }
+  else if ( which == wxIMAGE_LIST_STATE )
+    {
+    return m_imageListState;
+  }
+  return NULL;
+}
+
+void wxTreeCtrl::SetImageList(wxImageList *imageList, int which)
+{
+    if ( which == wxIMAGE_LIST_NORMAL )
+    {
+        m_imageListNormal = imageList;
+    }
+    else if ( which == wxIMAGE_LIST_STATE )
+    {
+        m_imageListState = imageList;
+    }
+    // TODO
+}
+
+long wxTreeCtrl::GetNextItem(long item, int code) const
+{
+    // TODO
+    return 0;
+}
+
+bool wxTreeCtrl::ItemHasChildren(long item) const
+{
+    // TODO
+    return FALSE;
+}
+
+long wxTreeCtrl::GetChild(long item) const
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::GetParent(long item) const
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::GetFirstVisibleItem() const
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::GetNextVisibleItem(long item) const
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::GetSelection() const
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::GetRootItem() const
+{
+    // TODO
+    return 0;
+}
+
+bool wxTreeCtrl::GetItem(wxTreeItem& info) const
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTreeCtrl::SetItem(wxTreeItem& info)
+{
+    // TODO
+    return FALSE;
+}
+
+int wxTreeCtrl::GetItemState(long item, long stateMask) const
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_STATE ;
+    info.m_stateMask = stateMask;
+    info.m_itemId = item;
+
+    if (!GetItem(info))
+        return 0;
+
+    return info.m_state;
+}
+
+bool wxTreeCtrl::SetItemState(long item, long state, long stateMask)
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_STATE ;
+    info.m_state = state;
+    info.m_stateMask = stateMask;
+    info.m_itemId = item;
+
+    return SetItem(info);
+}
+
+bool wxTreeCtrl::SetItemImage(long item, int image, int selImage)
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_IMAGE ;
+    info.m_image = image;
+    if ( selImage > -1)
+    {
+        info.m_selectedImage = selImage;
+        info.m_mask |= wxTREE_MASK_SELECTED_IMAGE;
+    }
+    info.m_itemId = item;
+
+    return SetItem(info);
+}
+
+wxString wxTreeCtrl::GetItemText(long item) const
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_TEXT ;
+    info.m_itemId = item;
+
+    if (!GetItem(info))
+        return wxString("");
+    return info.m_text;
+}
+
+void wxTreeCtrl::SetItemText(long item, const wxString& str)
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_TEXT ;
+    info.m_itemId = item;
+    info.m_text = str;
+
+    SetItem(info);
+}
+
+long wxTreeCtrl::GetItemData(long item) const
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_DATA ;
+    info.m_itemId = item;
+
+    if (!GetItem(info))
+        return 0;
+    return info.m_data;
+}
+
+bool wxTreeCtrl::SetItemData(long item, long data)
+{
+    wxTreeItem info;
+
+    info.m_mask = wxTREE_MASK_DATA ;
+    info.m_itemId = item;
+    info.m_data = data;
+
+    return SetItem(info);
+}
+
+bool wxTreeCtrl::GetItemRect(long item, wxRectangle& rect, bool textOnly) const
+{
+    // TODO
+    return FALSE;
+}
+
+wxTextCtrl* wxTreeCtrl::GetEditControl() const
+{
+    return m_textCtrl;
+}
+
+// Operations
+bool wxTreeCtrl::DeleteItem(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTreeCtrl::ExpandItem(long item, int action)
+{
+    // TODO
+  switch ( action )
+  {
+    case wxTREE_EXPAND_EXPAND:
+      break;
+
+    case wxTREE_EXPAND_COLLAPSE:
+      break;
+
+    case wxTREE_EXPAND_COLLAPSE_RESET:
+      break;
+
+    case wxTREE_EXPAND_TOGGLE:
+      break;
+
+    default:
+      wxFAIL_MSG("unknown action in wxTreeCtrl::ExpandItem");
+  }
+
+  bool bOk = FALSE; // TODO expand item
+
+  // May not send messages, so emulate them
+  if ( bOk ) {
+    wxTreeEvent event(wxEVT_NULL, m_windowId);
+    event.m_item.m_itemId  = item;
+    event.m_item.m_mask      =
+    event.m_item.m_stateMask = 0xffff; // get all
+    GetItem(event.m_item);
+
+    bool bIsExpanded = (event.m_item.m_state & wxTREE_STATE_EXPANDED) != 0;
+
+    event.m_code = action;
+    event.SetEventObject(this);
+
+    // @@@ return values of {EXPAND|COLLAPS}ING event handler is discarded
+    event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDING
+                                   : wxEVT_COMMAND_TREE_ITEM_COLLAPSING);
+    GetEventHandler()->ProcessEvent(event);
+
+    event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDED
+                                   : wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
+    GetEventHandler()->ProcessEvent(event);
+  }
+
+  return bOk;
+}
+
+long wxTreeCtrl::InsertItem(long parent, wxTreeItem& info, long insertAfter)
+{
+    // TODO
+    return 0;
+}
+
+long wxTreeCtrl::InsertItem(long parent, const wxString& label, int image, int selImage,
+  long insertAfter)
+{
+    wxTreeItem info;
+    info.m_text = label;
+    info.m_mask = wxTREE_MASK_TEXT;
+    if ( image > -1 )
+    {
+        info.m_mask |= wxTREE_MASK_IMAGE | wxTREE_MASK_SELECTED_IMAGE;
+        info.m_image = image;
+        if ( selImage == -1 )
+            info.m_selectedImage = image;
+        else
+            info.m_selectedImage = selImage;
+    }
+
+    return InsertItem(parent, info, insertAfter);
+}
+
+bool wxTreeCtrl::SelectItem(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTreeCtrl::ScrollTo(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTreeCtrl::DeleteAllItems()
+{
+    // TODO
+    return FALSE;
+}
+
+wxTextCtrl* wxTreeCtrl::EditLabel(long item, wxClassInfo* textControlClass)
+{
+    // TODO
+    return NULL;
+}
+
+// End label editing, optionally cancelling the edit
+bool wxTreeCtrl::EndEditLabel(bool cancel)
+{
+    // TODO
+    return FALSE;
+}
+
+long wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
+{
+    // TODO
+    return 0;
+}
+
+bool wxTreeCtrl::SortChildren(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxTreeCtrl::EnsureVisible(long item)
+{
+    // TODO
+    return FALSE;
+}
+
+// Tree item structure
+wxTreeItem::wxTreeItem()
+{
+    m_mask = 0;
+    m_itemId = 0;
+    m_state = 0;
+    m_stateMask = 0;
+    m_image = -1;
+    m_selectedImage = -1;
+    m_children = 0;
+    m_data = 0;
+}
+
+// Tree event
+IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent)
+
+wxTreeEvent::wxTreeEvent(wxEventType commandType, int id):
+  wxCommandEvent(commandType, id)
+{
+    m_code = 0;
+    m_oldItem = 0;
+}
+

diff --git a/src/motif/utils.cpp b/src/motif/utils.cpp
new file mode 100644 (file)
index 0000000..f7a95bc
--- /dev/null
+++ b/src/motif/utils.cpp
@@ -0,0 +1,324 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        utils.cpp
+// Purpose:     Various utilities
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+// Note: this is done in utilscmn.cpp now.
+// #pragma implementation
+// #pragma implementation "utils.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/utils.h"
+#include "wx/app.h"
+
+#include <ctype.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <Xm/Xm.h>
+
+// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
+bool wxGetHostName(char *buf, int maxSize)
+{
+    // TODO
+    return FALSE;
+}
+
+// Get user ID e.g. jacs
+bool wxGetUserId(char *buf, int maxSize)
+{
+    // TODO
+    return FALSE;
+}
+
+// Get user name e.g. Julian Smart
+bool wxGetUserName(char *buf, int maxSize)
+{
+    // TODO
+    return FALSE;
+}
+
+int wxKill(long pid, int sig)
+{
+    // TODO
+    return 0;
+}
+
+//
+// Execute a program in an Interactive Shell
+//
+bool wxShell(const wxString& command)
+{
+    // TODO
+    return FALSE;
+}
+
+// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
+long wxGetFreeMemory()
+{
+    // TODO
+    return 0;
+}
+
+void wxSleep(int nSecs)
+{
+    // TODO
+}
+
+// Consume all events until no more left
+void wxFlushEvents()
+{
+}
+
+// Output a debug message, in a system dependent fashion.
+void wxDebugMsg(const char *fmt ...)
+{
+  va_list ap;
+  static char buffer[512];
+
+  if (!wxTheApp->GetWantDebugOutput())
+    return ;
+
+  va_start(ap, fmt);
+
+  // wvsprintf(buffer,fmt,ap) ;
+  // TODO: output buffer
+
+  va_end(ap);
+}
+
+// Non-fatal error: pop up message box and (possibly) continue
+void wxError(const wxString& msg, const wxString& title)
+{
+    // TODO
+    wxExit();
+}
+
+// Fatal error: pop up message box and abort
+void wxFatalError(const wxString& msg, const wxString& title)
+{
+    // TODO
+}
+
+// Emit a beeeeeep
+void wxBell()
+{
+    // TODO
+}
+
+int wxGetOsVersion(int *majorVsn, int *minorVsn)
+{
+    // TODO
+    return 0;
+}
+
+// Reading and writing resources (eg WIN.INI, .Xdefaults)
+#if USE_RESOURCES
+bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
+{
+  char buf[50];
+  sprintf(buf, "%.4f", value);
+  return wxWriteResource(section, entry, buf, file);
+}
+
+bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
+{
+  char buf[50];
+  sprintf(buf, "%ld", value);
+  return wxWriteResource(section, entry, buf, file);
+}
+
+bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
+{
+  char buf[50];
+  sprintf(buf, "%d", value);
+  return wxWriteResource(section, entry, buf, file);
+}
+
+bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
+{
+    // TODO
+    return FALSE;
+}
+
+bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
+{
+  char *s = NULL;
+  bool succ = wxGetResource(section, entry, (char **)&s, file);
+  if (succ)
+  {
+    *value = (float)strtod(s, NULL);
+    delete[] s;
+    return TRUE;
+  }
+  else return FALSE;
+}
+
+bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
+{
+  char *s = NULL;
+  bool succ = wxGetResource(section, entry, (char **)&s, file);
+  if (succ)
+  {
+    *value = strtol(s, NULL, 10);
+    delete[] s;
+    return TRUE;
+  }
+  else return FALSE;
+}
+
+bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
+{
+  char *s = NULL;
+  bool succ = wxGetResource(section, entry, (char **)&s, file);
+  if (succ)
+  {
+    *value = (int)strtol(s, NULL, 10);
+    delete[] s; 
+    return TRUE;
+  }
+  else return FALSE;
+}
+#endif // USE_RESOURCES
+
+static int wxBusyCursorCount = 0;
+
+// Set the cursor to the busy cursor for all windows
+void wxBeginBusyCursor(wxCursor *cursor)
+{
+  wxBusyCursorCount ++;
+  if (wxBusyCursorCount == 1)
+  {
+        // TODO
+  }
+  else
+  {
+        // TODO
+  }
+}
+
+// Restore cursor to normal
+void wxEndBusyCursor()
+{
+  if (wxBusyCursorCount == 0)
+    return;
+    
+  wxBusyCursorCount --;
+  if (wxBusyCursorCount == 0)
+  {
+    // TODO
+  }
+}
+
+// TRUE if we're between the above two calls
+bool wxIsBusy()
+{
+  return (wxBusyCursorCount > 0);
+}    
+
+char *wxGetUserHome (const wxString& user)
+{
+    // TODO
+    return NULL;
+}
+
+// Check whether this window wants to process messages, e.g. Stop button
+// in long calculations.
+bool wxCheckForInterrupt(wxWindow *wnd)
+{
+    // TODO
+    return FALSE;
+}
+
+void wxGetMousePosition( int* x, int* y )
+{
+    // TODO
+};
+
+// Return TRUE if we have a colour display
+bool wxColourDisplay()
+{
+    // TODO
+    return TRUE;
+}
+
+// Returns depth of screen
+int wxDisplayDepth()
+{
+    // TODO
+    return 0;
+}
+
+// Get size of display
+void wxDisplaySize(int *width, int *height)
+{
+    // TODO
+}
+
+/* Configurable display in Motif */
+static WXDisplay *gs_currentDisplay = NULL;
+static wxString gs_displayName;
+
+WXDisplay *wxGetDisplay()
+{
+  if (gs_currentDisplay)
+    return gs_currentDisplay;
+
+  return XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
+}
+
+bool wxSetDisplay(const wxString& display_name)
+{
+  gs_displayName = display_name;
+  
+  if (display_name.IsNull() || display_name.IsEmpty())
+  {
+      gs_currentDisplay = NULL;
+      return TRUE;
+  }
+  else
+  {
+    Cardinal argc = 0;
+
+    Display *display = XtOpenDisplay((XtAppContext) wxTheApp->GetAppContext(),
+                                    (const char*) display_name,
+                                    (const char*) wxTheApp->GetAppName(),
+                                    (const char*) wxTheApp->GetClassName(),
+                                    NULL,
+# if XtSpecificationRelease < 5
+                                    0, &argc, NULL);
+# else
+                                    0, (int *)&argc, NULL);
+# endif
+
+    if (display)
+    {
+      gs_currentDisplay = (WXDisplay*) display;
+      return TRUE;
+    } else
+      return FALSE;
+  }
+  return FALSE;
+}
+
+wxString wxGetDisplayName()
+{
+  return gs_displayName;
+}

diff --git a/src/motif/utilsexc.cpp b/src/motif/utilsexc.cpp
new file mode 100644 (file)
index 0000000..0f4dc11
--- /dev/null
+++ b/src/motif/utilsexc.cpp
@@ -0,0 +1,162 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        utilsexec.cpp
+// Purpose:     Execution-related utilities
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/utils.h"
+#include "wx/app.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef VMS
+/*steve*/
+#ifdef __HIDE_FORBIDDEN_NAMES
+#undefine __HIDE_FORBIDDEN_NAMES
+#endif
+#include <socket.h>
+#ifdef VAX
+/*because 'noshare' is not valid in vax C++*/
+#define CC$VAXCSHR 1
+#endif
+#include <unixlib.h>
+#define unlink DELETE
+
+#else
+
+#if defined(_AIX) || defined(__xlC__)
+#include <sys/socket.h>
+#include <sys/select.h>
+#else
+#ifndef DG
+#include <sys/syscall.h>
+#endif
+#endif
+
+#include <sys/wait.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <pwd.h>
+
+#endif
+
+#include <sys/time.h>
+
+#include <Xm/Xm.h>
+
+#define wxEXECUTE_WIN_MESSAGE 10000
+
+void xt_notify_end_process(XtPointer client, int *fid,
+                          XtInputId *id)
+{
+  Bool *flag = (Bool *) client;
+  *flag = TRUE;
+
+  XtRemoveInput(*id);
+}
+
+long wxExecute(char **argv, bool sync, wxProcess *WXUNUSED(handler))
+{
+#ifdef VMS
+  return(0);
+#else
+  if (*argv == NULL)
+    return 0;  // Nothing???
+
+  int proc_link[2];
+  if (pipe(proc_link))
+    return 0;
+
+  /* fork the process */
+#if defined(sun) || defined(__ultrix) || defined(__bsdi__)
+  pid_t pid = vfork ();
+#else
+  pid_t pid = fork ();
+#endif
+
+  if (pid == -1)
+    {
+      return 0;
+    }
+  else if (pid == 0)
+    {
+/* GUILHEM: Close all fds when sync == 0 */
+      if (sync == 0)
+        for (int fd=0;fd<FD_SETSIZE;fd++) {
+          if (proc_link[1] != fd)
+            close(fd);
+        }
+      /* child */
+#ifdef _AIX
+      execvp ((const char *)*argv, (const char **)argv);
+#else
+      execvp (*argv, argv);
+#endif
+/* GUILHEM: Reopen output stream */
+//      open("/dev/console", O_WRONLY);
+/* GUILHEM: End */
+      if (errno == ENOENT)
+       printf ("%s: command not found\n", *argv);
+      else
+       perror (*argv);
+      printf ("wxWindows: could not execute '%s'\n", *argv);
+      _exit (-1);
+    }
+
+  int end_process = 0;
+
+  close(proc_link[1]);
+  XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(), proc_link[0],
+                (XtPointer *) XtInputReadMask,
+                (XtInputCallbackProc) xt_notify_end_process,
+                (XtPointer) &end_process);
+
+  if (sync) {
+    while (!end_process)
+       XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
+
+    if (WIFEXITED(end_process) != 0)
+      return WEXITSTATUS(end_process);
+  }
+
+  return pid;
+#endif
+  // end VMS
+}
+
+long wxExecute (const wxString& command, bool sync)
+{
+#ifdef VMS
+  return(0);
+#else
+  if (command.IsNull() || command == "")
+    return 0; // Nothing to do
+
+  // Run a program the recomended way under X (XView) 
+  int argc = 0;
+  char *argv[127];
+  char tmp[1024];
+  const char *IFS = " \t\n";
+
+  // Build argument vector 
+  strncpy (tmp, (const char*) command, sizeof (tmp) / sizeof (char) - 1);
+  tmp[sizeof (tmp) / sizeof (char) - 1] = '\0';
+  argv[argc++] = strtok (tmp, IFS);
+  while ((argv[argc++] = strtok (NULL, IFS)) != NULL)
+    /* loop */ ;
+
+  return wxExecute(argv, sync);
+#endif
+  // VMS
+}

diff --git a/src/motif/wave.cpp b/src/motif/wave.cpp
new file mode 100644 (file)
index 0000000..c51c675
--- /dev/null
+++ b/src/motif/wave.cpp
@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wave.cpp
+// Purpose:     wxWave class implementation: optional
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "wave.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/stubs/wave.h"
+
+wxWave::wxWave()
+  : m_waveLength(0), m_isResource(FALSE), m_waveData(NULL)
+{
+}
+
+wxWave::wxWave(const wxString& sFileName, bool isResource)
+  : m_waveLength(0), m_isResource(isResource), m_waveData(NULL)
+{
+    Create(sFileName, isResource);
+}
+
+
+wxWave::~wxWave()
+{
+    Free();
+}
+
+bool wxWave::Create(const wxString& fileName, bool isResource)
+{
+    Free();
+
+    // TODO
+
+    return FALSE;
+}
+
+bool wxWave::Play(bool async, bool looped) const
+{
+    if (!IsOk())
+        return FALSE;
+
+    // TODO
+    return FALSE;
+}
+
+bool wxWave::Free()
+{
+    // TODO
+    return FALSE;
+}
+
+

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
new file mode 100644 (file)
index 0000000..4287512
--- /dev/null
+++ b/src/motif/window.cpp
@@ -0,0 +1,1509 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        windows.cpp
+// Purpose:     wxWindow
+// Author:      Julian Smart
+// Modified by:
+// Created:     17/09/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:    wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "window.h"
+#endif
+
+#include "wx/setup.h"
+#include "wx/menu.h"
+#include "wx/dc.h"
+#include "wx/dcclient.h"
+#include "wx/utils.h"
+#include "wx/app.h"
+#include "wx/panel.h"
+#include "wx/layout.h"
+#include "wx/dialog.h"
+#include "wx/listbox.h"
+#include "wx/button.h"
+#include "wx/settings.h"
+#include "wx/msgdlg.h"
+#include "wx/frame.h"
+
+#include "wx/menuitem.h"
+#include "wx/log.h"
+
+#if  USE_DRAG_AND_DROP
+#include "wx/dnd.h"
+#endif
+
+#include <Xm/Xm.h>
+#include "wx/motif/private.h"
+
+#include <string.h>
+
+extern wxList wxPendingDelete;
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
+
+BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
+  EVT_CHAR(wxWindow::OnChar)
+  EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
+  EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
+  EVT_INIT_DIALOG(wxWindow::OnInitDialog)
+  EVT_IDLE(wxWindow::OnIdle)
+END_EVENT_TABLE()
+
+#endif
+
+
+// Constructor
+wxWindow::wxWindow()
+{
+    // Generic
+    m_windowId = 0;
+    m_windowStyle = 0;
+    m_windowParent = NULL;
+    m_windowEventHandler = this;
+    m_windowName = "";
+    m_windowCursor = *wxSTANDARD_CURSOR;
+    m_children = new wxList;
+    m_constraints = NULL;
+    m_constraintsInvolvedIn = NULL;
+    m_windowSizer = NULL;
+    m_sizerParent = NULL;
+    m_autoLayout = FALSE;
+    m_windowValidator = NULL;
+    m_defaultItem = NULL;
+    m_returnCode = 0;
+    m_caretWidth = 0; m_caretHeight = 0;
+    m_caretEnabled = FALSE;
+    m_caretShown = FALSE;
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    m_foregroundColour = *wxBLACK;
+    m_defaultForegroundColour = *wxBLACK ;
+    m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
+
+#if  USE_DRAG_AND_DROP
+    m_pDropTarget = NULL;
+#endif
+
+    /// MOTIF-specific
+    m_mainWidget = (WXWidget) 0;
+    m_button1Pressed = FALSE;
+    m_button2Pressed = FALSE;
+    m_button3Pressed = FALSE;
+    m_winCaptured = FALSE;
+    m_isShown = TRUE;
+}
+
+// Destructor
+wxWindow::~wxWindow()
+{
+       // Have to delete constraints/sizer FIRST otherwise
+       // sizers may try to look at deleted windows as they
+       // delete themselves.
+#if USE_CONSTRAINTS
+    DeleteRelatedConstraints();
+    if (m_constraints)
+    {
+        // This removes any dangling pointers to this window
+        // in other windows' constraintsInvolvedIn lists.
+        UnsetConstraints(m_constraints);
+        delete m_constraints;
+        m_constraints = NULL;
+    }
+    if (m_windowSizer)
+    {
+        delete m_windowSizer;
+        m_windowSizer = NULL;
+    }
+    // If this is a child of a sizer, remove self from parent
+    if (m_sizerParent)
+        m_sizerParent->RemoveChild((wxWindow *)this);
+#endif
+
+    if (m_windowParent)
+        m_windowParent->RemoveChild(this);
+
+    DestroyChildren();
+
+    // Destroy the window
+    if (GetMainWidget())
+    {
+      wxDeleteWindowFromTable((Widget) GetMainWidget());
+      XtDestroyWidget((Widget) GetMainWidget());
+      SetMainWidget((WXWidget) NULL);
+    }
+
+    delete m_children;
+    m_children = NULL;
+
+    // Just in case the window has been Closed, but
+    // we're then deleting immediately: don't leave
+    // dangling pointers.
+    wxPendingDelete.DeleteObject(this);
+
+    if ( m_windowValidator )
+           delete m_windowValidator;
+}
+
+// Destroy the window (delayed, if a managed window)
+bool wxWindow::Destroy()
+{
+    delete this;
+    return TRUE;
+}
+
+// Constructor
+bool wxWindow::Create(wxWindow *parent, wxWindowID id,
+           const wxPoint& pos,
+           const wxSize& size,
+           long style,
+           const wxString& name)
+{
+    // Generic
+    m_windowId = 0;
+    m_windowStyle = 0;
+    m_windowParent = NULL;
+    m_windowEventHandler = this;
+    m_windowName = "";
+    m_windowCursor = *wxSTANDARD_CURSOR;
+    m_constraints = NULL;
+    m_constraintsInvolvedIn = NULL;
+    m_windowSizer = NULL;
+    m_sizerParent = NULL;
+    m_autoLayout = FALSE;
+    m_windowValidator = NULL;
+
+#if USE_DRAG_AND_DROP
+    m_pDropTarget = NULL;
+#endif
+
+    m_caretWidth = 0; m_caretHeight = 0;
+    m_caretEnabled = FALSE;
+    m_caretShown = FALSE;
+    m_minSizeX = -1;
+    m_minSizeY = -1;
+    m_maxSizeX = -1;
+    m_maxSizeY = -1;
+    m_defaultItem = NULL;
+    m_windowParent = NULL;
+    if (!parent)
+        return FALSE;
+
+    if (parent) parent->AddChild(this);
+
+    m_returnCode = 0;
+
+    SetName(name);
+
+    if ( id == -1 )
+       m_windowId = (int)NewControlId();
+    else
+       m_windowId = id;
+
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+    m_foregroundColour = *wxBLACK;
+    m_defaultForegroundColour = *wxBLACK ;
+    m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
+
+    m_windowStyle = style;
+
+    if ( id == -1 )
+       m_windowId = (int)NewControlId();
+    else
+       m_windowId = id;
+
+    // TODO: create the window
+
+    return TRUE;
+}
+
+void wxWindow::SetFocus()
+{
+  XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
+  XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
+}
+
+void wxWindow::Enable(bool enable)
+{
+  if (GetMainWidget())
+  {
+    XtSetSensitive((Widget) GetMainWidget(), enable);
+    XmUpdateDisplay((Widget) GetMainWidget());
+  }
+}
+
+void wxWindow::CaptureMouse()
+{
+  if (m_winCaptured)
+    return;
+    
+  if (GetMainWidget())
+    XtAddGrab((Widget) GetMainWidget(), TRUE, FALSE);
+
+  m_winCaptured = TRUE;
+}
+
+void wxWindow::ReleaseMouse()
+{
+  if (!m_winCaptured)
+    return;
+    
+  if (GetMainWidget())
+    XtRemoveGrab((Widget) GetMainWidget());
+  m_winCaptured = FALSE;
+}
+
+// Push/pop event handler (i.e. allow a chain of event handlers
+// be searched)
+void wxWindow::PushEventHandler(wxEvtHandler *handler)
+{
+       handler->SetNextHandler(GetEventHandler());
+       SetEventHandler(handler);
+}
+
+wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
+{
+       if ( GetEventHandler() )
+       {
+               wxEvtHandler *handlerA = GetEventHandler();
+               wxEvtHandler *handlerB = handlerA->GetNextHandler();
+               handlerA->SetNextHandler(NULL);
+               SetEventHandler(handlerB);
+               if ( deleteHandler )
+               {
+                       delete handlerA;
+                       return NULL;
+               }
+               else
+                       return handlerA;
+       }
+       else
+               return NULL;
+}
+
+#if    USE_DRAG_AND_DROP
+
+void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
+{
+  if ( m_pDropTarget != 0 ) {
+    delete m_pDropTarget;
+  }
+
+  m_pDropTarget = pDropTarget;
+  if ( m_pDropTarget != 0 )
+  {
+    // TODO
+  }
+}
+
+#endif
+
+// Old style file-manager drag&drop
+void wxWindow::DragAcceptFiles(bool accept)
+{
+    // TODO
+}
+
+// Get total size
+void wxWindow::GetSize(int *x, int *y) const
+{
+  Widget widget = (Widget) GetMainWidget();
+  Dimension xx, yy;
+  XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
+  *x = xx; *y = yy;
+}
+
+void wxWindow::GetPosition(int *x, int *y) const
+{
+  Widget widget = (Widget) GetMainWidget();
+  Position xx, yy;
+  XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
+  *x = xx; *y = yy;
+}
+
+void wxWindow::ScreenToClient(int *x, int *y) const
+{
+    // TODO
+}
+
+void wxWindow::ClientToScreen(int *x, int *y) const
+{
+  Widget widget = (Widget) GetMainWidget();
+  Display *display = XtDisplay(widget);
+  Window rootWindow = RootWindowOfScreen(XtScreen(widget));
+  Window thisWindow;
+  if (this->IsKindOf(CLASSINFO(wxFrame)))
+  {
+    wxFrame *fr = (wxFrame *)this;
+    // TODO
+    //    thisWindow = XtWindow(fr->m_clientArea);
+  }
+  else
+    thisWindow = XtWindow((Widget)widget);
+
+  Window childWindow;
+  int xx = *x;
+  int yy = *y;
+  XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
+}
+
+void wxWindow::SetCursor(const wxCursor& cursor)
+{
+  m_windowCursor = cursor;
+  if (m_windowCursor.Ok())
+  {
+    /* TODO when wxCursor implemented
+    WXDisplay *dpy = GetXDisplay();
+    Cursor x_cursor = cursor.GetXCursor(dpy);
+
+    Widget w = (Widget) GetMainWidget();
+    Window win = XtWindow(w);
+    XDefineCursor((Display*) dpy, win, x_cursor);
+    */
+  }
+}
+
+
+// Get size *available for subwindows* i.e. excluding menu bar etc.
+void wxWindow::GetClientSize(int *x, int *y) const
+{
+  Widget widget = (Widget) GetMainWidget();
+  Dimension xx, yy;
+  XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
+  *x = xx; *y = yy;
+}
+
+void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+  Widget widget = (Widget) GetMainWidget();
+
+  if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+    XtVaSetValues(widget, XmNx, x, NULL);
+  if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+    XtVaSetValues(widget, XmNy, y, NULL);
+  if (width > -1)
+    XtVaSetValues(widget, XmNwidth, width, NULL);
+  if (height > -1)
+    XtVaSetValues(widget, XmNheight, height, NULL);
+
+  wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+  sizeEvent.SetEventObject(this);
+  
+  GetEventHandler()->ProcessEvent(sizeEvent);
+}
+
+void wxWindow::SetClientSize(int width, int height)
+{
+  Widget widget = (Widget) GetMainWidget();
+
+  if (width > -1)
+    XtVaSetValues(widget, XmNwidth, width, NULL);
+  if (height > -1)
+    XtVaSetValues(widget, XmNheight, height, NULL);
+
+  wxSizeEvent sizeEvent(wxSize(width, height), GetId());
+  sizeEvent.SetEventObject(this);
+  
+  GetEventHandler()->ProcessEvent(sizeEvent);
+}
+
+// For implementation purposes - sometimes decorations make the client area
+// smaller
+wxPoint wxWindow::GetClientAreaOrigin() const
+{
+    return wxPoint(0, 0);
+}
+
+// Makes an adjustment to the window position (for example, a frame that has
+// a toolbar that it manages itself).
+void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
+{
+    if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
+    {
+        wxPoint pt(GetParent()->GetClientAreaOrigin());
+        x += pt.x; y += pt.y;
+    }
+}
+
+bool wxWindow::Show(bool show)
+{
+    Window xwin = (Window) GetXWindow();
+    Display *xdisp = (Display*) GetXDisplay();
+    if (show)
+        XMapWindow(xdisp, xwin);
+    else
+        XUnmapWindow(xdisp, xwin);
+
+    m_isShown = show;
+
+    return TRUE;
+}
+
+bool wxWindow::IsShown() const
+{
+    return m_isShown;
+}
+
+int wxWindow::GetCharHeight() const
+{
+    // TODO
+    return 0;
+}
+
+int wxWindow::GetCharWidth() const
+{
+    // TODO
+    return 0;
+}
+
+void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
+                           int *descent, int *externalLeading, const wxFont *theFont, bool) const
+{
+  wxFont *fontToUse = (wxFont *)theFont;
+  if (!fontToUse)
+    fontToUse = (wxFont *) & m_windowFont;
+
+    // TODO
+}
+
+void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
+{
+    Display *display = XtDisplay((Widget) GetMainWidget());
+    Window thisWindow = XtWindow((Widget) GetMainWidget());
+
+    XExposeEvent dummyEvent;
+    int width, height;
+    GetSize(&width, &height);
+
+    dummyEvent.type = Expose;
+    dummyEvent.display = display;
+    dummyEvent.send_event = True;
+    dummyEvent.window = thisWindow;
+    if (rect)
+    {
+      dummyEvent.x = rect->x;
+      dummyEvent.y = rect->y;
+      dummyEvent.width = rect->width;
+      dummyEvent.height = rect->height;
+    }
+    else
+    {
+      dummyEvent.x = 0;
+      dummyEvent.y = 0;
+      dummyEvent.width = width;
+      dummyEvent.height = height;
+    }
+    dummyEvent.count = 0;
+
+    if (eraseBack)
+    {
+        wxClientDC dc(this);
+        dc.Clear();
+    }
+
+    XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
+}
+
+// Responds to colour changes: passes event on to children.
+void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
+{
+    wxNode *node = GetChildren()->First();
+    while ( node )
+    {
+        // Only propagate to non-top-level windows
+        wxWindow *win = (wxWindow *)node->Data();
+        if ( win->GetParent() )
+        {
+            wxSysColourChangedEvent event2;
+            event.m_eventObject = win;
+            win->GetEventHandler()->ProcessEvent(event2);
+        }
+
+        node = node->Next();
+    }
+}
+
+// This can be called by the app (or wxWindows) to do default processing for the current
+// event. Save message/event info in wxWindow so they can be used in this function.
+long wxWindow::Default()
+{
+    // TODO
+    return 0;
+}
+
+void wxWindow::InitDialog()
+{
+  wxInitDialogEvent event(GetId());
+  event.SetEventObject( this );
+  GetEventHandler()->ProcessEvent(event);
+}
+
+// Default init dialog behaviour is to transfer data to window
+void wxWindow::OnInitDialog(wxInitDialogEvent& event)
+{
+  TransferDataToWindow();
+}
+
+// Caret manipulation
+void wxWindow::CreateCaret(int w, int h)
+{
+  m_caretWidth = w;
+  m_caretHeight = h;
+  m_caretEnabled = TRUE;
+}
+
+void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
+{
+    // TODO
+}
+
+void wxWindow::ShowCaret(bool show)
+{
+    // TODO
+}
+
+void wxWindow::DestroyCaret()
+{
+    // TODO
+    m_caretEnabled = FALSE;
+}
+
+void wxWindow::SetCaretPos(int x, int y)
+{
+    // TODO
+}
+
+void wxWindow::GetCaretPos(int *x, int *y) const
+{
+    // TODO
+}
+
+wxWindow *wxGetActiveWindow()
+{
+    // TODO
+    return NULL;
+}
+
+void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
+{
+    m_minSizeX = minW;
+    m_minSizeY = minH;
+    m_maxSizeX = maxW;
+    m_maxSizeY = maxH;
+
+    if (!this->IsKindOf(CLASSINFO(wxFrame)))
+      return;
+
+    wxFrame *frame = (wxFrame *)this;
+
+    /* Uncomment when wxFrame implemented
+    if (minW > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNminWidth, minW, NULL);
+    if (minH > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNminHeight, minH, NULL);
+    if (maxW > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNmaxWidth, maxW, NULL);
+    if (maxH > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNmaxHeight, maxH, NULL);
+    if (incW > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNwidthInc, incW, NULL);
+    if (incH > -1)
+      XtVaSetValues((Widget) frame->m_frameShell, XmNheightInc, incH, NULL);
+      */
+}
+
+void wxWindow::Centre(int direction)
+{
+  int x, y, width, height, panel_width, panel_height, new_x, new_y;
+
+  wxWindow *father = (wxWindow *)GetParent();
+  if (!father)
+    return;
+
+  father->GetClientSize(&panel_width, &panel_height);
+  GetSize(&width, &height);
+  GetPosition(&x, &y);
+
+  new_x = -1;
+  new_y = -1;
+
+  if (direction & wxHORIZONTAL)
+    new_x = (int)((panel_width - width)/2);
+
+  if (direction & wxVERTICAL)
+    new_y = (int)((panel_height - height)/2);
+
+  SetSize(new_x, new_y, -1, -1);
+
+}
+
+// Coordinates relative to the window
+void wxWindow::WarpPointer (int x_pos, int y_pos)
+{
+    // TODO
+}
+
+void wxWindow::OnEraseBackground(wxEraseEvent& event)
+{
+    // TODO
+    Default();
+}
+
+int wxWindow::GetScrollPos(int orient) const
+{
+    // TODO
+    return 0;
+}
+
+// This now returns the whole range, not just the number
+// of positions that we can scroll.
+int wxWindow::GetScrollRange(int orient) const
+{
+    // TODO
+    return 0;
+}
+
+int wxWindow::GetScrollThumb(int orient) const
+{
+    // TODO
+    return 0;
+}
+
+void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
+{
+    // TODO
+    return;
+}
+
+// New function that will replace some of the above.
+void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
+    int range, bool refresh)
+{
+    // TODO
+}
+
+// Does a physical scroll
+void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect)
+{
+    // TODO
+    return;
+}
+
+void wxWindow::SetFont(const wxFont& font)
+{
+    m_windowFont = font;
+
+    if (!m_windowFont.Ok())
+           return;
+    // TODO
+}
+
+void wxWindow::OnChar(wxKeyEvent& event)
+{
+    if ( event.KeyCode() == WXK_TAB ) {
+        // propagate the TABs to the parent - it's up to it to decide what
+        // to do with it
+        if ( GetParent() ) {
+            if ( GetParent()->ProcessEvent(event) )
+                return;
+        }
+    }
+}
+
+void wxWindow::OnPaint(wxPaintEvent& event)
+{
+       Default();
+}
+
+bool wxWindow::IsEnabled() const
+{
+    // TODO
+    return FALSE;
+}
+
+// Dialog support: override these and call
+// base class members to add functionality
+// that can't be done using validators.
+// NOTE: these functions assume that controls
+// are direct children of this window, not grandchildren
+// or other levels of descendant.
+
+// Transfer values to controls. If returns FALSE,
+// it's an application error (pops up a dialog)
+bool wxWindow::TransferDataToWindow()
+{
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *child = (wxWindow *)node->Data();
+               if ( child->GetValidator() &&
+                    !child->GetValidator()->TransferToWindow() )
+               {
+                       wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
+                       return FALSE;
+               }
+
+               node = node->Next();
+       }
+       return TRUE;
+}
+
+// Transfer values from controls. If returns FALSE,
+// validation failed: don't quit
+bool wxWindow::TransferDataFromWindow()
+{
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *child = (wxWindow *)node->Data();
+               if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
+               {
+                       return FALSE;
+               }
+
+               node = node->Next();
+       }
+       return TRUE;
+}
+
+bool wxWindow::Validate()
+{
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *child = (wxWindow *)node->Data();
+               if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
+               {
+                       return FALSE;
+               }
+
+               node = node->Next();
+       }
+       return TRUE;
+}
+
+// Get the window with the focus
+wxWindow *wxWindow::FindFocus()
+{
+    // TODO
+    return NULL;
+}
+
+void wxWindow::AddChild(wxWindow *child)
+{
+    GetChildren()->Append(child);
+    child->m_windowParent = this;
+}
+
+void wxWindow::RemoveChild(wxWindow *child)
+{
+    if (GetChildren())
+        GetChildren()->DeleteObject(child);
+    child->m_windowParent = NULL;
+}
+
+void wxWindow::DestroyChildren()
+{
+  if (GetChildren()) {
+    wxNode *node;
+    while ((node = GetChildren()->First()) != (wxNode *)NULL) {
+      wxWindow *child;
+      if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
+        delete child;
+               if ( GetChildren()->Member(child) )
+                       delete node;
+      }
+    } /* while */
+  }
+}
+
+void wxWindow::MakeModal(bool modal)
+{
+  // Disable all other windows
+  if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
+  {
+    wxNode *node = wxTopLevelWindows.First();
+    while (node)
+    {
+      wxWindow *win = (wxWindow *)node->Data();
+      if (win != this)
+        win->Enable(!modal);
+
+      node = node->Next();
+    }
+  }
+}
+
+void wxWindow::SetConstraints(wxLayoutConstraints *c)
+{
+  if (m_constraints)
+  {
+    UnsetConstraints(m_constraints);
+    delete m_constraints;
+  }
+  m_constraints = c;
+  if (m_constraints)
+  {
+    // Make sure other windows know they're part of a 'meaningful relationship'
+    if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
+      m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
+      m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
+      m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
+      m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
+      m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
+      m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
+      m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+    if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
+      m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
+  }
+}
+
+// This removes any dangling pointers to this window
+// in other windows' constraintsInvolvedIn lists.
+void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
+{
+  if (c)
+  {
+    if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
+      c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
+      c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
+      c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
+      c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
+      c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
+      c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
+      c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+    if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
+      c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
+  }
+}
+
+// Back-pointer to other windows we're involved with, so if we delete
+// this window, we must delete any constraints we're involved with.
+void wxWindow::AddConstraintReference(wxWindow *otherWin)
+{
+  if (!m_constraintsInvolvedIn)
+    m_constraintsInvolvedIn = new wxList;
+  if (!m_constraintsInvolvedIn->Member(otherWin))
+    m_constraintsInvolvedIn->Append(otherWin);
+}
+
+// REMOVE back-pointer to other windows we're involved with.
+void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
+{
+  if (m_constraintsInvolvedIn)
+    m_constraintsInvolvedIn->DeleteObject(otherWin);
+}
+
+// Reset any constraints that mention this window
+void wxWindow::DeleteRelatedConstraints()
+{
+  if (m_constraintsInvolvedIn)
+  {
+    wxNode *node = m_constraintsInvolvedIn->First();
+    while (node)
+    {
+      wxWindow *win = (wxWindow *)node->Data();
+      wxNode *next = node->Next();
+      wxLayoutConstraints *constr = win->GetConstraints();
+
+      // Reset any constraints involving this window
+      if (constr)
+      {
+        constr->left.ResetIfWin((wxWindow *)this);
+        constr->top.ResetIfWin((wxWindow *)this);
+        constr->right.ResetIfWin((wxWindow *)this);
+        constr->bottom.ResetIfWin((wxWindow *)this);
+        constr->width.ResetIfWin((wxWindow *)this);
+        constr->height.ResetIfWin((wxWindow *)this);
+        constr->centreX.ResetIfWin((wxWindow *)this);
+        constr->centreY.ResetIfWin((wxWindow *)this);
+      }
+      delete node;
+      node = next;
+    }
+    delete m_constraintsInvolvedIn;
+    m_constraintsInvolvedIn = NULL;
+  }
+}
+
+void wxWindow::SetSizer(wxSizer *sizer)
+{
+  m_windowSizer = sizer;
+  if (sizer)
+    sizer->SetSizerParent((wxWindow *)this);
+}
+
+/*
+ * New version
+ */
+
+bool wxWindow::Layout()
+{
+  if (GetConstraints())
+  {
+    int w, h;
+    GetClientSize(&w, &h);
+    GetConstraints()->width.SetValue(w);
+    GetConstraints()->height.SetValue(h);
+  }
+  
+  // If top level (one sizer), evaluate the sizer's constraints.
+  if (GetSizer())
+  {
+    int noChanges;
+    GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
+    GetSizer()->LayoutPhase1(&noChanges);
+    GetSizer()->LayoutPhase2(&noChanges);
+    GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
+    return TRUE;
+  }
+  else
+  {
+    // Otherwise, evaluate child constraints
+    ResetConstraints();   // Mark all constraints as unevaluated
+    DoPhase(1);           // Just one phase need if no sizers involved
+    DoPhase(2);
+    SetConstraintSizes(); // Recursively set the real window sizes
+  }
+  return TRUE;
+}
+
+
+// Do a phase of evaluating constraints:
+// the default behaviour. wxSizers may do a similar
+// thing, but also impose their own 'constraints'
+// and order the evaluation differently.
+bool wxWindow::LayoutPhase1(int *noChanges)
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    return constr->SatisfyConstraints((wxWindow *)this, noChanges);
+  }
+  else
+    return TRUE;
+}
+
+bool wxWindow::LayoutPhase2(int *noChanges)
+{
+  *noChanges = 0;
+  
+  // Layout children
+  DoPhase(1);
+  DoPhase(2);
+  return TRUE;
+}
+
+// Do a phase of evaluating child constraints
+bool wxWindow::DoPhase(int phase)
+{
+  int noIterations = 0;
+  int maxIterations = 500;
+  int noChanges = 1;
+  int noFailures = 0;
+  wxList succeeded;
+  while ((noChanges > 0) && (noIterations < maxIterations))
+  {
+    noChanges = 0;
+    noFailures = 0;
+    wxNode *node = GetChildren()->First();
+    while (node)
+    {
+      wxWindow *child = (wxWindow *)node->Data();
+      if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
+      {
+        wxLayoutConstraints *constr = child->GetConstraints();
+        if (constr)
+        {
+          if (succeeded.Member(child))
+          {
+          }
+          else
+          {
+            int tempNoChanges = 0;
+            bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
+            noChanges += tempNoChanges;
+            if (success)
+            {
+              succeeded.Append(child);
+            }
+          }
+        }
+      }
+      node = node->Next();
+    }
+    noIterations ++;
+  }
+  return TRUE;
+}
+
+void wxWindow::ResetConstraints()
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    constr->left.SetDone(FALSE);
+    constr->top.SetDone(FALSE);
+    constr->right.SetDone(FALSE);
+    constr->bottom.SetDone(FALSE);
+    constr->width.SetDone(FALSE);
+    constr->height.SetDone(FALSE);
+    constr->centreX.SetDone(FALSE);
+    constr->centreY.SetDone(FALSE);
+  }
+  wxNode *node = GetChildren()->First();
+  while (node)
+  {
+    wxWindow *win = (wxWindow *)node->Data();
+    if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
+      win->ResetConstraints();
+    node = node->Next();
+  }
+}
+
+// Need to distinguish between setting the 'fake' size for
+// windows and sizers, and setting the real values.
+void wxWindow::SetConstraintSizes(bool recurse)
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr && constr->left.GetDone() && constr->right.GetDone() &&
+                constr->width.GetDone() && constr->height.GetDone())
+  {
+    int x = constr->left.GetValue();
+    int y = constr->top.GetValue();
+    int w = constr->width.GetValue();
+    int h = constr->height.GetValue();
+
+    // If we don't want to resize this window, just move it...
+    if ((constr->width.GetRelationship() != wxAsIs) ||
+        (constr->height.GetRelationship() != wxAsIs))
+    {
+      // Calls Layout() recursively. AAAGH. How can we stop that.
+      // Simply take Layout() out of non-top level OnSizes.
+      SizerSetSize(x, y, w, h);
+    }
+    else
+    {
+      SizerMove(x, y);
+    }
+  }
+  else if (constr)
+  {
+    char *windowClass = this->GetClassInfo()->GetClassName();
+
+    wxString winName;
+       if (GetName() == "")
+               winName = "unnamed";
+       else
+               winName = GetName();
+    wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
+    if (!constr->left.GetDone())
+      wxDebugMsg("  unsatisfied 'left' constraint.\n");
+    if (!constr->right.GetDone())
+      wxDebugMsg("  unsatisfied 'right' constraint.\n");
+    if (!constr->width.GetDone())
+      wxDebugMsg("  unsatisfied 'width' constraint.\n");
+    if (!constr->height.GetDone())
+      wxDebugMsg("  unsatisfied 'height' constraint.\n");
+    wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
+  }
+
+  if (recurse)
+  {
+    wxNode *node = GetChildren()->First();
+    while (node)
+    {
+      wxWindow *win = (wxWindow *)node->Data();
+      if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
+        win->SetConstraintSizes();
+      node = node->Next();
+    }
+  }
+}
+
+// This assumes that all sizers are 'on' the same
+// window, i.e. the parent of this window.
+void wxWindow::TransformSizerToActual(int *x, int *y) const
+{
+  if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
+                        m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
+    return;
+    
+  int xp, yp;
+  m_sizerParent->GetPosition(&xp, &yp);
+  m_sizerParent->TransformSizerToActual(&xp, &yp);
+  *x += xp;
+  *y += yp;
+}
+
+void wxWindow::SizerSetSize(int x, int y, int w, int h)
+{
+       int xx = x;
+       int yy = y;
+  TransformSizerToActual(&xx, &yy);
+  SetSize(xx, yy, w, h);
+}
+
+void wxWindow::SizerMove(int x, int y)
+{
+       int xx = x;
+       int yy = y;
+  TransformSizerToActual(&xx, &yy);
+  Move(xx, yy);
+}
+
+// Only set the size/position of the constraint (if any)
+void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    if (x != -1)
+    {
+      constr->left.SetValue(x);
+      constr->left.SetDone(TRUE);
+    }
+    if (y != -1)
+    {
+      constr->top.SetValue(y);
+      constr->top.SetDone(TRUE);
+    }
+    if (w != -1)
+    {
+      constr->width.SetValue(w);
+      constr->width.SetDone(TRUE);
+    }
+    if (h != -1)
+    {
+      constr->height.SetValue(h);
+      constr->height.SetDone(TRUE);
+    }
+  }
+}
+
+void wxWindow::MoveConstraint(int x, int y)
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    if (x != -1)
+    {
+      constr->left.SetValue(x);
+      constr->left.SetDone(TRUE);
+    }
+    if (y != -1)
+    {
+      constr->top.SetValue(y);
+      constr->top.SetDone(TRUE);
+    }
+  }
+}
+
+void wxWindow::GetSizeConstraint(int *w, int *h) const
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    *w = constr->width.GetValue();
+    *h = constr->height.GetValue();
+  }
+  else
+    GetSize(w, h);
+}
+
+void wxWindow::GetClientSizeConstraint(int *w, int *h) const
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    *w = constr->width.GetValue();
+    *h = constr->height.GetValue();
+  }
+  else
+    GetClientSize(w, h);
+}
+
+void wxWindow::GetPositionConstraint(int *x, int *y) const
+{
+  wxLayoutConstraints *constr = GetConstraints();
+  if (constr)
+  {
+    *x = constr->left.GetValue();
+    *y = constr->top.GetValue();
+  }
+  else
+    GetPosition(x, y);
+}
+
+bool wxWindow::Close(bool force)
+{
+  wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
+  event.SetEventObject(this);
+  event.SetForce(force);
+
+  return GetEventHandler()->ProcessEvent(event);
+}
+
+wxObject* wxWindow::GetChild(int number) const
+{
+  // Return a pointer to the Nth object in the window
+  if (!GetChildren())
+    return(NULL) ;
+  wxNode *node = GetChildren()->First();
+  int n = number;
+  while (node && n--)
+    node = node->Next() ;
+  if (node)
+  {
+    wxObject *obj = (wxObject *)node->Data();
+    return(obj) ;
+  }
+  else
+    return NULL ;
+}
+
+void wxWindow::OnDefaultAction(wxControl *initiatingItem)
+{
+    // Obsolete function
+}
+
+void wxWindow::Clear()
+{
+       wxClientDC dc(this);
+    wxBrush brush(GetBackgroundColour(), wxSOLID);
+    dc.SetBackground(brush);
+    dc.Clear();
+}
+
+// Fits the panel around the items
+void wxWindow::Fit()
+{
+       int maxX = 0;
+       int maxY = 0;
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *win = (wxWindow *)node->Data();
+               int wx, wy, ww, wh;
+               win->GetPosition(&wx, &wy);
+               win->GetSize(&ww, &wh);
+               if ( wx + ww > maxX )
+                       maxX = wx + ww;
+               if ( wy + wh > maxY )
+                       maxY = wy + wh;
+
+               node = node->Next();
+       }
+       SetClientSize(maxX + 5, maxY + 5);
+}
+
+void wxWindow::SetValidator(const wxValidator& validator)
+{
+       if ( m_windowValidator )
+               delete m_windowValidator;
+       m_windowValidator = validator.Clone();
+
+       if ( m_windowValidator )
+               m_windowValidator->SetWindow(this) ;
+}
+
+// Find a window by id or name
+wxWindow *wxWindow::FindWindow(long id)
+{
+       if ( GetId() == id)
+               return this;
+
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *child = (wxWindow *)node->Data();
+               wxWindow *found = child->FindWindow(id);
+               if ( found )
+                       return found;
+               node = node->Next();
+       }
+       return NULL;
+}
+
+wxWindow *wxWindow::FindWindow(const wxString& name)
+{
+       if ( GetName() == name)
+               return this;
+
+       wxNode *node = GetChildren()->First();
+       while ( node )
+       {
+               wxWindow *child = (wxWindow *)node->Data();
+               wxWindow *found = child->FindWindow(name);
+               if ( found )
+                       return found;
+               node = node->Next();
+       }
+       return NULL;
+}
+
+void wxWindow::OnIdle(wxIdleEvent& event)
+{
+/* TODO: you may need to do something like this
+ * if your GUI doesn't generate enter/leave events
+
+    // Check if we need to send a LEAVE event
+    if (m_mouseInWindow)
+    {
+        POINT pt;
+        ::GetCursorPos(&pt);
+        if (::WindowFromPoint(pt) != (HWND) GetHWND())
+        {
+            // Generate a LEAVE event
+            m_mouseInWindow = FALSE;
+            MSWOnMouseLeave(pt.x, pt.y, 0);
+        }
+    }
+*/
+
+    // This calls the UI-update mechanism (querying windows for
+    // menu/toolbar/control state information)
+       UpdateWindowUI();
+}
+
+// Raise the window to the top of the Z order
+void wxWindow::Raise()
+{
+    Window window = XtWindow((Widget) GetMainWidget());
+    XRaiseWindow(XtDisplay((Widget) GetMainWidget()), window);
+}
+
+// Lower the window to the bottom of the Z order
+void wxWindow::Lower()
+{
+    Window window = XtWindow((Widget) GetMainWidget());
+    XLowerWindow(XtDisplay((Widget) GetMainWidget()), window);
+}
+
+bool wxWindow::AcceptsFocus() const
+{
+  return IsShown() && IsEnabled();
+}
+
+// Update region access
+wxRegion wxWindow::GetUpdateRegion() const
+{
+    return m_updateRegion;
+}
+
+bool wxWindow::IsExposed(int x, int y, int w, int h) const
+{
+    return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
+}
+
+bool wxWindow::IsExposed(const wxPoint& pt) const
+{
+    return (m_updateRegion.Contains(pt) != wxOutRegion);
+}
+
+bool wxWindow::IsExposed(const wxRect& rect) const
+{
+    return (m_updateRegion.Contains(rect) != wxOutRegion);
+}
+
+/*
+ * Allocates control IDs
+ */
+
+int wxWindow::NewControlId()
+{
+    static int s_controlId = 0;
+    s_controlId ++;
+    return s_controlId;
+}
+
+void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel)
+{
+    m_acceleratorTable = accel;
+}
+
+// All widgets should have this as their resize proc.
+// OnSize sent to wxWindow via client data.
+void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
+{
+    wxWindow *win = (wxWindow *)wxWidgetHashTable->Get((long)w);
+    if (!win)
+        return;
+
+    if (win->PreResize())
+    {
+        int width, height;
+        win->GetSize(&width, &height);
+        wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
+        sizeEvent.SetEventObject(win);
+        win->GetEventHandler()->ProcessEvent(sizeEvent);
+    }
+}
+
+bool wxAddWindowToTable(Widget w, wxWindow *win)
+{
+  wxWindow *oldItem = NULL;
+#if DEBUG
+//  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
+#endif
+  if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
+  {
+    char buf[300];
+    sprintf(buf, "Widget table clash: new widget is %ld, %s", (long)w, win->GetClassInfo()->GetClassName());
+    wxError (buf);
+    fflush(stderr);
+    sprintf(buf, "Old widget was %s", oldItem->GetClassInfo()->GetClassName());
+    wxError (buf);
+    return FALSE;
+  }
+
+  wxWidgetHashTable->Put ((long) w, win);
+  return TRUE;
+}
+
+wxWindow *wxGetWindowFromTable(Widget w)
+{
+  return (wxWindow *)wxWidgetHashTable->Get ((long) w);
+}
+
+void wxDeleteWindowFromTable(Widget w)
+{
+#if DEBUG
+//  printf("Deleting widget %ld\n", w);
+#endif
+//  wxWindow *win = (wxWindow *)wxWidgetHashTable->Get ((long) w);
+
+  wxWidgetHashTable->Delete((long)w);
+}
+  
+// Get the underlying X window and display
+WXWindow wxWindow::GetXWindow() const
+{
+  return (WXWindow) XtWindow((Widget) GetMainWidget());
+}
+
+WXDisplay *wxWindow::GetXDisplay() const
+{
+  return (WXDisplay*) XtDisplay((Widget) GetMainWidget());
+}
+
+WXWidget wxWindow::GetMainWidget() const
+{
+  return m_mainWidget;
+}
+
+