]> git.saurik.com Git - wxWidgets.git/blobdiff - src/palmos/window.cpp
initialize GdkColor so code which incorrectly accesses it will work as well as it...
[wxWidgets.git] / src / palmos / window.cpp
index 95afadc87e3b27dcfeaa375056be247b09ea1fb6..26f50b413504880adaff58b58d97cf422f4d2e05 100644 (file)
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/palmos/windows.cpp
 // Purpose:     wxWindow
-// Author:      William Osborne
-// Modified by:
+// Author:      William Osborne - minimal working wxPalmOS port
+// Modified by: Wlodzimierz ABX Skiba - more than minimal functionality
 // Created:     10/13/04
-// RCS-ID:      $Id:
-// Copyright:   (c) William Osborne
+// RCS-ID:      $Id$
+// Copyright:   (c) William Osborne, Wlodzimierz Skiba
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // headers
 // ---------------------------------------------------------------------------
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "window.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
     #pragma hdrstop
 #endif
 
+#include "wx/window.h"
+
 #ifndef WX_PRECOMP
-    #include "wx/window.h"
     #include "wx/accel.h"
-    #include "wx/setup.h"
     #include "wx/menu.h"
     #include "wx/dc.h"
     #include "wx/dcclient.h"
@@ -46,6 +42,9 @@
     #include "wx/msgdlg.h"
     #include "wx/settings.h"
     #include "wx/statbox.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/textctrl.h"
 #endif
 
 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
@@ -63,7 +62,6 @@
 #endif
 
 #include "wx/menuitem.h"
-#include "wx/log.h"
 
 #if wxUSE_TOOLTIPS
     #include "wx/tooltip.h"
     #include "wx/spinctrl.h"
 #endif // wxUSE_SPINCTRL
 
-#include "wx/intl.h"
-#include "wx/log.h"
-
-#include "wx/textctrl.h"
 #include "wx/notebook.h"
 #include "wx/listctrl.h"
 
-#include <string.h>
-
-#include "wx/palmos/window.h"
+#include <Window.h>
 
 // ---------------------------------------------------------------------------
 // global variables
 wxMenu *wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
-#ifdef __WXWINCE__
-extern       wxChar *wxCanvasClassName;
-#else
-extern const wxChar *wxCanvasClassName;
-#endif
-
-// true if we had already created the std colour map, used by
-// wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
-static bool gs_hasStdCmap = false;
-
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
@@ -227,7 +209,6 @@ wxCONSTRUCTOR_DUMMY(wxWindow)
 
 BEGIN_EVENT_TABLE(wxWindowPalm, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindowPalm::OnEraseBackground)
-    EVT_SYS_COLOUR_CHANGED(wxWindowPalm::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindowPalm::OnInitDialog)
 END_EVENT_TABLE()
 
@@ -246,14 +227,19 @@ wxWindow *wxWindowPalm::FindItem(long id) const
 }
 
 // Find an item given the MS Windows handle
-wxWindow *wxWindowPalm::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
+wxWindow *wxWindowPalm::FindItemByWinHandle(WXWINHANDLE handle, bool controlOnly) const
 {
+    // TODO
     return NULL;
 }
 
-// Default command handler
-bool wxWindowPalm::PalmCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
+bool wxGetKeyState(wxKeyCode key)
 {
+    wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
+        WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
+
+    // TODO
+
     return false;
 }
 
@@ -263,6 +249,7 @@ bool wxWindowPalm::PalmCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 
 void wxWindowPalm::Init()
 {
+    m_handle = 0;
 }
 
 // Destructor
@@ -272,22 +259,31 @@ wxWindowPalm::~wxWindowPalm()
 
 // real construction (Init() must have been called before!)
 bool wxWindowPalm::Create(wxWindow *parent,
-                         wxWindowID id,
-                         const wxPoint& pos,
-                         const wxSize& size,
-                         long style,
-                         const wxString& name)
+                          wxWindowID id,
+                          const wxPoint& pos,
+                          const wxSize& size,
+                          long style,
+                          const wxString& name)
 {
-    return false;
+    wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
+
+    if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
+        return false;
+
+    parent->AddChild(this);
+
+    InheritAttributes();
+
+    return true;
 }
 
-FormType *wxWindowPalm::GetFormPtr()
+WXFORMPTR wxWindowPalm::GetFormPtr()
 {
     return FrameForm;
 }
-void wxWindowPalm::SetFormPtr(FormType *FormPtr)
+void wxWindowPalm::SetFormPtr(WXFORMPTR FormPtr)
 {
-    FrameForm=FormPtr;
+    FrameForm = FormPtr;
 }
 
 // ---------------------------------------------------------------------------
@@ -328,13 +324,13 @@ void wxWindowPalm::Lower()
 {
 }
 
-void wxWindowPalm::SetTitle( const wxString& title)
+void wxWindowPalm::SetLabel( const wxString& WXUNUSED(label))
 {
 }
 
-wxString wxWindowPalm::GetTitle() const
+wxString wxWindowPalm::GetLabel() const
 {
-    return wxString("");
+    return wxEmptyString;
 }
 
 void wxWindowPalm::DoCaptureMouse()
@@ -417,31 +413,10 @@ bool wxWindowPalm::ScrollPages(int pages)
     return false;
 }
 
-// ---------------------------------------------------------------------------
-// subclassing
-// ---------------------------------------------------------------------------
-
-void wxWindowPalm::SubclassWin(WXHWND hWnd)
-{
-}
-
-void wxWindowPalm::UnsubclassWin()
-{
-}
-
-bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
-{
-    return false;
-}
-
 // ----------------------------------------------------------------------------
 // Style handling
 // ----------------------------------------------------------------------------
 
-void wxWindowPalm::SetWindowStyleFlag(long flags)
-{
-}
-
 WXDWORD wxWindowPalm::PalmGetStyle(long flags, WXDWORD *exstyle) const
 {
     return 0;
@@ -452,11 +427,6 @@ void wxWindowPalm::SetupColours()
 {
 }
 
-bool wxWindowPalm::IsMouseInWindow() const
-{
-    return false;
-}
-
 void wxWindowPalm::OnInternalIdle()
 {
 }
@@ -477,6 +447,23 @@ void wxWindowPalm::Thaw()
 
 void wxWindowPalm::Refresh(bool eraseBack, const wxRect *rect)
 {
+    WinHandle handle = (WinHandle)GetWinHandle();
+    if(handle)
+    {
+        if(rect)
+        {
+            RectangleType dirtyRect;
+            dirtyRect.topLeft.x = rect->GetX() - 1;
+            dirtyRect.topLeft.y = rect->GetY() - 1;
+            dirtyRect.extent.x = rect->GetWidth() + 1;
+            dirtyRect.extent.y = rect->GetHeight() + 1;
+            WinInvalidateRect(handle, &dirtyRect);
+        }
+        else
+        {
+            WinInvalidateWindow(handle);
+        }
+    }
 }
 
 void wxWindowPalm::Update()
@@ -528,6 +515,10 @@ void wxWindowPalm::DoGetClientSize(int *x, int *y) const
 
 void wxWindowPalm::DoGetPosition(int *x, int *y) const
 {
+    if(x)
+        *x = 0;
+    if(y)
+        *y = 0;
 }
 
 void wxWindowPalm::DoScreenToClient(int *x, int *y) const
@@ -552,19 +543,67 @@ void wxWindowPalm::DoMoveWindow(int x, int y, int width, int height)
 // width/height
 void wxWindowPalm::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 {
+    // get the current size and position...
+    int currentX, currentY;
+    GetPosition(&currentX, &currentY);
+    int currentW,currentH;
+    GetSize(&currentW, &currentH);
+
+    // ... and don't do anything (avoiding flicker) if it's already ok
+    if ( x == currentX && y == currentY &&
+         width == currentW && height == currentH )
+    {
+        return;
+    }
+
+    if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+        x = currentX;
+    if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+        y = currentY;
+
+    AdjustForParentClientOrigin(x, y, sizeFlags);
+
+    wxSize size = wxDefaultSize;
+    if ( width == wxDefaultCoord )
+    {
+        if ( sizeFlags & wxSIZE_AUTO_WIDTH )
+        {
+            size = DoGetBestSize();
+            width = size.x;
+        }
+        else
+        {
+            // just take the current one
+            width = currentW;
+        }
+    }
+
+    if ( height == wxDefaultCoord )
+    {
+        if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
+        {
+            if ( size.x == wxDefaultCoord )
+            {
+                size = DoGetBestSize();
+            }
+            //else: already called DoGetBestSize() above
+
+            height = size.y;
+        }
+        else
+        {
+            // just take the current one
+            height = currentH;
+        }
+    }
+
+    DoMoveWindow(x, y, width, height);
 }
 
 void wxWindowPalm::DoSetClientSize(int width, int height)
 {
 }
 
-// For implementation purposes - sometimes decorations make the client area
-// smaller
-wxPoint wxWindowPalm::GetClientAreaOrigin() const
-{
-    return wxPoint(0, 0);
-}
-
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
@@ -608,60 +647,15 @@ bool wxWindowPalm::DoPopupMenu(wxMenu *menu, int x, int y)
 
 #endif // wxUSE_MENUS_NATIVE
 
-// ===========================================================================
-// pre/post message processing
-// ===========================================================================
-
-WXLRESULT wxWindowPalm::PalmDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
-bool wxWindowPalm::PalmProcessMessage(WXMSG* pMsg)
-{
-    return false;
-}
-
-bool wxWindowPalm::PalmTranslateMessage(WXMSG* pMsg)
-{
-    return false;
-}
-
-bool wxWindowPalm::PalmShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// Main wxWidgets window proc and the window proc for wxWindow
-// ---------------------------------------------------------------------------
-
-// Hook for new window just as it's being created, when the window isn't yet
-// associated with the handle
-
-// implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
-// window being created and insures that it's always unset back later
-wxWindowCreationHook::wxWindowCreationHook(wxWindowPalm *winBeingCreated)
-{
-}
-
-wxWindowCreationHook::~wxWindowCreationHook()
-{
-}
-
-WXLRESULT wxWindowPalm::PalmWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
 // ----------------------------------------------------------------------------
 // wxWindow <-> HWND map
 // ----------------------------------------------------------------------------
 
 wxWinHashTable *wxWinHandleHash = NULL;
 
-wxWindow *wxFindWinFromHandle(WXHWND hWnd)
+wxWindow *wxFindWinFromWinHandle(WXWINHANDLE handle)
 {
+    // TODO
     return NULL;
 }
 
@@ -670,34 +664,23 @@ void wxRemoveHandleAssociation(wxWindowPalm *win)
 }
 
 // ----------------------------------------------------------------------------
-// various Palm speciic class dependent functions
+// various Palm specific class dependent functions
 // ----------------------------------------------------------------------------
 
-// Default destroyer - override if you destroy it in some other way
-// (e.g. with MDI child windows)
-void wxWindowPalm::PalmDestroyWindow()
-{
-}
-
 bool wxWindowPalm::PalmGetCreateWindowCoords(const wxPoint& pos,
-                                           const wxSize& size,
-                                           int& x, int& y,
-                                           int& w, int& h) const
+                                             const wxSize& size,
+                                             int& x, int& y,
+                                             int& w, int& h) const
 {
     return false;
 }
 
-WXHWND wxWindowPalm::PalmGetParent() const
-{
-    return NULL;
-}
-
 bool wxWindowPalm::PalmCreate(const wxChar *wclass,
-                            const wxChar *title,
-                            const wxPoint& pos,
-                            const wxSize& size,
-                            WXDWORD style,
-                            WXDWORD extendedStyle)
+                              const wxChar *title,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              WXDWORD style,
+                              WXDWORD extendedStyle)
 {
     return false;
 }
@@ -706,214 +689,15 @@ bool wxWindowPalm::PalmCreate(const wxChar *wclass,
 // Palm message handlers
 // ===========================================================================
 
-// ---------------------------------------------------------------------------
-// WM_NOTIFY
-// ---------------------------------------------------------------------------
-
-#ifdef __WIN95__
-
-bool wxWindowPalm::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
-{
-    return false;
-}
-
-#if wxUSE_TOOLTIPS
-
-bool wxWindowPalm::HandleTooltipNotify(WXUINT code,
-                                      WXLPARAM lParam,
-                                      const wxString& ttip)
-{
-    return false;
-}
-
-#endif // wxUSE_TOOLTIPS
-
-bool wxWindowPalm::PalmOnNotify(int WXUNUSED(idCtrl),
-                              WXLPARAM lParam,
-                              WXLPARAM* WXUNUSED(result))
-{
-    return false;
-}
-
-#endif // __WIN95__
-
-// ---------------------------------------------------------------------------
-// end session messages
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleQueryEndSession(long logOff, bool *mayEnd)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleEndSession(bool endSession, long logOff)
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// window creation/destruction
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleDestroy()
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// activation/focus
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleActivate(int state,
-                              bool WXUNUSED(minimized),
-                              WXHWND WXUNUSED(activate))
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleSetFocus(WXHWND hwnd)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleKillFocus(WXHWND hwnd)
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// miscellaneous
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleShow(bool show, int WXUNUSED(status))
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleDropFiles(WXWPARAM wParam)
-{
-    return false;
-}
-
-
-bool wxWindowPalm::HandleSetCursor(WXHWND WXUNUSED(hWnd),
-                                  short nHitTest,
-                                  int WXUNUSED(mouseMsg))
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// owner drawn stuff
-// ---------------------------------------------------------------------------
-
-#if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
-        (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
-    #define WXUNUSED_UNLESS_ODRAWN(param) param
-#else
-    #define WXUNUSED_UNLESS_ODRAWN(param)
-#endif
-
-bool
-wxWindowPalm::PalmOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
-                           WXDRAWITEMSTRUCT * WXUNUSED_UNLESS_ODRAWN(itemStruct))
-{
-    return false;
-}
-
-bool
-wxWindowPalm::PalmOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
-                              WXMEASUREITEMSTRUCT *
-                                  WXUNUSED_UNLESS_ODRAWN(itemStruct))
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// colours and palettes
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleSysColorChange()
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleDisplayChange()
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleCtlColor(WXHBRUSH *brush,
-                              WXHDC pDC,
-                              WXHWND pWnd,
-                              WXUINT nCtlColor,
-                              WXUINT message,
-                              WXWPARAM wParam,
-                              WXLPARAM lParam)
-{
-    return false;
-}
-
-// Define for each class of dialog and control
-WXHBRUSH wxWindowPalm::OnCtlColor(WXHDC WXUNUSED(hDC),
-                                 WXHWND WXUNUSED(hWnd),
-                                 WXUINT WXUNUSED(nCtlColor),
-                                 WXUINT WXUNUSED(message),
-                                 WXWPARAM WXUNUSED(wParam),
-                                 WXLPARAM WXUNUSED(lParam))
-{
-    return (WXHBRUSH)0;
-}
-
-bool wxWindowPalm::HandlePaletteChanged(WXHWND hWndPalChange)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleCaptureChanged(WXHWND hWndGainedCapture)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleQueryNewPalette()
-{
-    return false;
-}
-
-// Responds to colour changes: passes event on to children.
-void wxWindowPalm::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
-{
-}
-
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 
-bool wxWindowPalm::HandlePaint()
-{
-    return false;
-}
-
 // Can be called from an application's OnPaint handler
 void wxWindowPalm::OnPaint(wxPaintEvent& event)
 {
 }
 
-bool wxWindowPalm::HandleEraseBkgnd(WXHDC hdc)
-{
-    return false;
-}
-
 void wxWindowPalm::OnEraseBackground(wxEraseEvent& event)
 {
 }
@@ -922,16 +706,6 @@ void wxWindowPalm::OnEraseBackground(wxEraseEvent& event)
 // moving and resizing
 // ---------------------------------------------------------------------------
 
-bool wxWindowPalm::HandleMinimize()
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleMaximize()
-{
-    return false;
-}
-
 bool wxWindowPalm::HandleMove(int x, int y)
 {
     return false;
@@ -942,106 +716,6 @@ bool wxWindowPalm::HandleMoving(wxRect& rect)
     return false;
 }
 
-bool wxWindowPalm::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
-                             WXUINT WXUNUSED(flag))
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleSizing(wxRect& rect)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleGetMinMaxInfo(void *mmInfo)
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// command messages
-// ---------------------------------------------------------------------------
-
-bool wxWindowPalm::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
-{
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// mouse events
-// ---------------------------------------------------------------------------
-
-void wxWindowPalm::InitMouseEvent(wxMouseEvent& event,
-                                 int x, int y,
-                                 WXUINT flags)
-{
-}
-
-// Windows doesn't send the mouse events to the static controls (which are
-// transparent in the sense that their WM_NCHITTEST handler returns
-// HTTRANSPARENT) at all but we want all controls to receive the mouse events
-// and so we manually check if we don't have a child window under mouse and if
-// we do, send the event to it instead of the window Windows had sent WM_XXX
-// to.
-//
-// Notice that this is not done for the mouse move events because this could
-// (would?) be too slow, but only for clicks which means that the static texts
-// still don't get move, enter nor leave events.
-static wxWindowPalm *FindWindowForMouseEvent(wxWindowPalm *win, int *x, int *y) //TW:REQ:Univ
-{
-    return NULL;
-}
-
-bool wxWindowPalm::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleMouseMove(int x, int y, WXUINT flags)
-{
-    return false;
-}
-
-
-bool wxWindowPalm::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
-
-// ---------------------------------------------------------------------------
-// keyboard handling
-// ---------------------------------------------------------------------------
-
-// create the key event of the given type for the given key - used by
-// HandleChar and HandleKeyDown/Up
-wxKeyEvent wxWindowPalm::CreateKeyEvent(wxEventType evType,
-                                       int id,
-                                       WXLPARAM lParam,
-                                       WXWPARAM wParam) const
-{
-    wxKeyEvent event(evType);
-
-    return event;
-}
-
-// isASCII is true only when we're called from WM_CHAR handler and not from
-// WM_KEYDOWN one
-bool wxWindowPalm::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
-bool wxWindowPalm::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
 // ---------------------------------------------------------------------------
 // joystick
 // ---------------------------------------------------------------------------
@@ -1056,8 +730,9 @@ bool wxWindowPalm::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
 // ---------------------------------------------------------------------------
 
 bool wxWindowPalm::PalmOnScroll(int orientation, WXWORD wParam,
-                              WXWORD pos, WXHWND control)
+                                WXWORD pos, WXWINHANDLE control)
 {
+    // TODO
     return false;
 }
 
@@ -1065,68 +740,9 @@ bool wxWindowPalm::PalmOnScroll(int orientation, WXWORD wParam,
 // global functions
 // ===========================================================================
 
-void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
-{
-}
-
-// Returns 0 if was a normal ASCII value, not a special key. This indicates that
-// the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
-int wxCharCodePalmToWX(int keySym, WXLPARAM lParam)
+void wxGetCharSize(WXWINHANDLE wnd, int *x, int *y, const wxFont *the_font)
 {
-    return 0;
-}
-
-int wxCharCodeWXToPalm(int id, bool *isVirtual)
-{
-    return 0;
-}
-
-bool wxGetKeyState(wxKeyCode key)
-{
-    return false;
-}
-
-wxWindow *wxGetActiveWindow()
-{
-    return NULL;
-}
-
-extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
-{
-    return NULL;
-}
-
-#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
-
-void wxSetKeyboardHook(bool doIt)
-{
-}
-
-#endif // !__WXMICROWIN__
-
-#ifdef __WXDEBUG__
-const char *wxGetMessageName(int message)
-{
-    return "";
-}
-#endif //__WXDEBUG__
-
-// Find the wxWindow at the current mouse position, returning the mouse
-// position.
-wxWindow* wxFindWindowAtPointer(wxPoint& pt)
-{
-    return NULL;
-}
-
-wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
-{
-    return NULL;
-}
-
-// Get the current mouse position.
-wxPoint wxGetMousePosition()
-{
-    return wxPoint(0, 0);
+    // TODO
 }
 
 #if wxUSE_HOTKEY
@@ -1141,15 +757,4 @@ bool wxWindowPalm::UnregisterHotKey(int hotkeyId)
     return false;
 }
 
-#if wxUSE_ACCEL
-
-bool wxWindowPalm::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
-{
-    return false;
-}
-
-#endif // wxUSE_ACCEL
-
 #endif // wxUSE_HOTKEY
-
-