src/palmos/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/palmos/window.cpp
   3 // Purpose:     wxWindow
   4 // Author:      William Osborne - minimal working wxPalmOS port
   5 // Modified by: Wlodzimierz ABX Skiba - more than minimal functionality
   6 // Created:     10/13/04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) William Osborne, Wlodzimierz Skiba
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/window.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/accel.h"
  31     #include "wx/menu.h"
  32     #include "wx/dc.h"
  33     #include "wx/dcclient.h"
  34     #include "wx/dcmemory.h"
  35     #include "wx/utils.h"
  36     #include "wx/app.h"
  37     #include "wx/layout.h"
  38     #include "wx/dialog.h"
  39     #include "wx/frame.h"
  40     #include "wx/listbox.h"
  41     #include "wx/button.h"
  42     #include "wx/msgdlg.h"
  43     #include "wx/settings.h"
  44     #include "wx/statbox.h"
  45     #include "wx/intl.h"
  46     #include "wx/log.h"
  47     #include "wx/textctrl.h"
  48     #include "wx/menuitem.h"
  49     #include "wx/module.h"
  50 #endif
  51
  52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
  53     #include "wx/ownerdrw.h"
  54 #endif
  55
  56 #if wxUSE_DRAG_AND_DROP
  57     #include "wx/dnd.h"
  58 #endif
  59
  60 #if wxUSE_ACCESSIBILITY
  61     #include "wx/access.h"
  62 #endif
  63
  64 #if wxUSE_TOOLTIPS
  65     #include "wx/tooltip.h"
  66 #endif
  67
  68 #if wxUSE_CARET
  69     #include "wx/caret.h"
  70 #endif // wxUSE_CARET
  71
  72 #if wxUSE_SPINCTRL
  73     #include "wx/spinctrl.h"
  74 #endif // wxUSE_SPINCTRL
  75
  76 #include "wx/notebook.h"
  77 #include "wx/listctrl.h"
  78
  79 #ifndef __WXUNIVERSAL__
  80 #include <Window.h>
  81
  82 // ---------------------------------------------------------------------------
  83 // global variables
  84 // ---------------------------------------------------------------------------
  85
  86 #if wxUSE_MENUS_NATIVE
  87 wxMenu *wxCurrentPopupMenu = NULL;
  88 #endif // wxUSE_MENUS_NATIVE
  89
  90 // ---------------------------------------------------------------------------
  91 // private functions
  92 // ---------------------------------------------------------------------------
  93
  94 // ---------------------------------------------------------------------------
  95 // event tables
  96 // ---------------------------------------------------------------------------
  97
  98 // in wxUniv/Palm this class is abstract because it doesn't have DoPopupMenu()
  99 // method
 100 #ifdef __WXUNIVERSAL__
 101     IMPLEMENT_ABSTRACT_CLASS(wxWindowPalm, wxWindowBase)
 102 #else // __WXPalm__
 103 #if wxUSE_EXTENDED_RTTI
 104
 105 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
 106 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
 107 // windows with negative ids never can be recreated anyway
 108
 109 bool wxWindowStreamingCallback( const wxObject *object, wxWriter * , wxPersister * , wxxVariantArray & )
 110 {
 111     return false;
 112 }
 113
 114 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow, wxWindowBase,"wx/window.h", wxWindowStreamingCallback)
 115
 116 // make wxWindowList known before the property is used
 117
 118 wxCOLLECTION_TYPE_INFO( wxWindow* , wxWindowList ) ;
 119
 120 template<> void wxCollectionToVariantArray( wxWindowList const &theList, wxxVariantArray &value)
 121 {
 122     wxListCollectionToVariantArray<wxWindowList::compatibility_iterator>( theList , value ) ;
 123 }
 124
 125 WX_DEFINE_FLAGS( wxWindowStyle )
 126
 127 wxBEGIN_FLAGS( wxWindowStyle )
 128     // new style border flags, we put them first to
 129     // use them for streaming out
 130
 131     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 132     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 133     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 134     wxFLAGS_MEMBER(wxBORDER_RAISED)
 135     wxFLAGS_MEMBER(wxBORDER_STATIC)
 136     wxFLAGS_MEMBER(wxBORDER_NONE)
 137
 138     // old style border flags
 139     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 140     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 141     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 142     wxFLAGS_MEMBER(wxRAISED_BORDER)
 143     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 144     wxFLAGS_MEMBER(wxBORDER)
 145
 146     // standard window styles
 147     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 148     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 149     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 150     wxFLAGS_MEMBER(wxWANTS_CHARS)
 151     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 152     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 153     wxFLAGS_MEMBER(wxVSCROLL)
 154     wxFLAGS_MEMBER(wxHSCROLL)
 155
 156 wxEND_FLAGS( wxWindowStyle )
 157
 158 wxBEGIN_PROPERTIES_TABLE(wxWindow)
 159     wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
 160     wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
 161     wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
 162     // Always constructor Properties first
 163
 164     wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 165     wxPROPERTY( Id,wxWindowID, SetId, GetId, wxID_ANY, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 166     wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxDefaultPosition , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
 167     wxPROPERTY( Size,wxSize, SetSize, GetSize, wxDefaultSize , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
 168     wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 169
 170     // Then all relations of the object graph
 171
 172     wxREADONLY_PROPERTY_COLLECTION( Children , wxWindowList , wxWindowBase* , GetWindowChildren , wxPROP_OBJECT_GRAPH /*flags*/ , wxT("Helpstring") , wxT("group"))
 173
 174    // and finally all other properties
 175
 176     wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
 177     wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
 178     wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
 179     wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 180     wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 181 #if 0
 182     // possible property candidates (not in xrc) or not valid in all subclasses
 183     wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
 184     wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
 185     wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
 186     // MaxHeight, Width , MinHeight , Width
 187     // TODO switch label to control and title to toplevels
 188
 189     wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
 190     //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
 191     // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
 192     wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
 193
 194
 195
 196 #endif
 197 wxEND_PROPERTIES_TABLE()
 198
 199 wxBEGIN_HANDLERS_TABLE(wxWindow)
 200 wxEND_HANDLERS_TABLE()
 201
 202 wxCONSTRUCTOR_DUMMY(wxWindow)
 203
 204 #else
 205     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 206 #endif
 207 #endif // __WXUNIVERSAL__/__WXPalm__
 208
 209 BEGIN_EVENT_TABLE(wxWindowPalm, wxWindowBase)
 210     EVT_ERASE_BACKGROUND(wxWindowPalm::OnEraseBackground)
 211     EVT_INIT_DIALOG(wxWindowPalm::OnInitDialog)
 212 END_EVENT_TABLE()
 213
 214 // ===========================================================================
 215 // implementation
 216 // ===========================================================================
 217
 218 // ---------------------------------------------------------------------------
 219 // wxWindow utility functions
 220 // ---------------------------------------------------------------------------
 221
 222 // Find an item given the MS Windows id
 223 wxWindow *wxWindowPalm::FindItem(long id) const
 224 {
 225     return NULL;
 226 }
 227
 228 // Find an item given the MS Windows handle
 229 wxWindow *wxWindowPalm::FindItemByWinHandle(WXWINHANDLE handle, bool controlOnly) const
 230 {
 231     // TODO
 232     return NULL;
 233 }
 234
 235 bool wxGetKeyState(wxKeyCode key)
 236 {
 237     wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
 238         WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
 239
 240     // TODO
 241
 242     return false;
 243 }
 244
 245 // ----------------------------------------------------------------------------
 246 // constructors and such
 247 // ----------------------------------------------------------------------------
 248
 249 void wxWindowPalm::Init()
 250 {
 251     m_hWnd = 0;
 252 }
 253
 254 // Destructor
 255 wxWindowPalm::~wxWindowPalm()
 256 {
 257 }
 258
 259 // real construction (Init() must have been called before!)
 260 bool wxWindowPalm::Create(wxWindow *parent,
 261                           wxWindowID id,
 262                           const wxPoint& pos,
 263                           const wxSize& size,
 264                           long style,
 265                           const wxString& name)
 266 {
 267     wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 268
 269     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 270         return false;
 271
 272     parent->AddChild(this);
 273
 274     InheritAttributes();
 275
 276     return true;
 277 }
 278
 279 WXFORMPTR wxWindowPalm::GetFormPtr()
 280 {
 281     return FrameForm;
 282 }
 283 void wxWindowPalm::SetFormPtr(WXFORMPTR FormPtr)
 284 {
 285     FrameForm = FormPtr;
 286 }
 287
 288 // ---------------------------------------------------------------------------
 289 // basic operations
 290 // ---------------------------------------------------------------------------
 291
 292 void wxWindowPalm::SetFocus()
 293 {
 294 }
 295
 296 void wxWindowPalm::SetFocusFromKbd()
 297 {
 298 }
 299
 300 // Get the window with the focus
 301 wxWindow *wxWindowBase::DoFindFocus()
 302 {
 303     return NULL;
 304 }
 305
 306 bool wxWindowPalm::Enable(bool enable)
 307 {
 308     return false;
 309 }
 310
 311 bool wxWindowPalm::Show(bool show)
 312 {
 313     return false;
 314 }
 315
 316 // Raise the window to the top of the Z order
 317 void wxWindowPalm::Raise()
 318 {
 319 }
 320
 321 // Lower the window to the bottom of the Z order
 322 void wxWindowPalm::Lower()
 323 {
 324 }
 325
 326 void wxWindowPalm::SetLabel( const wxString& WXUNUSED(label))
 327 {
 328 }
 329
 330 wxString wxWindowPalm::GetLabel() const
 331 {
 332     return wxEmptyString;
 333 }
 334
 335 void wxWindowPalm::DoCaptureMouse()
 336 {
 337 }
 338
 339 void wxWindowPalm::DoReleaseMouse()
 340 {
 341 }
 342
 343 /* static */ wxWindow *wxWindowBase::GetCapture()
 344 {
 345     return NULL;
 346 }
 347
 348 bool wxWindowPalm::SetFont(const wxFont& font)
 349 {
 350     return false;
 351 }
 352 bool wxWindowPalm::SetCursor(const wxCursor& cursor)
 353 {
 354     return false;
 355 }
 356
 357 void wxWindowPalm::WarpPointer (int x, int y)
 358 {
 359 }
 360
 361 // ---------------------------------------------------------------------------
 362 // scrolling stuff
 363 // ---------------------------------------------------------------------------
 364
 365 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
 366 static inline int wxDirToWinStyle(int orient)
 367 {
 368     return 0;
 369 }
 370
 371 int wxWindowPalm::GetScrollPos(int orient) const
 372 {
 373     return 0;
 374 }
 375
 376 // This now returns the whole range, not just the number
 377 // of positions that we can scroll.
 378 int wxWindowPalm::GetScrollRange(int orient) const
 379 {
 380     return 0;
 381 }
 382
 383 int wxWindowPalm::GetScrollThumb(int orient) const
 384 {
 385     return 0;
 386 }
 387
 388 void wxWindowPalm::SetScrollPos(int orient, int pos, bool refresh)
 389 {
 390 }
 391
 392 // New function that will replace some of the above.
 393 void wxWindowPalm::SetScrollbar(int orient,
 394                                int pos,
 395                                int pageSize,
 396                                int range,
 397                                bool refresh)
 398 {
 399 }
 400
 401 void wxWindowPalm::ScrollWindow(int dx, int dy, const wxRect *prect)
 402 {
 403 }
 404
 405 bool wxWindowPalm::ScrollLines(int lines)
 406 {
 407     return false;
 408 }
 409
 410 bool wxWindowPalm::ScrollPages(int pages)
 411 {
 412     return false;
 413 }
 414
 415 // ----------------------------------------------------------------------------
 416 // Style handling
 417 // ----------------------------------------------------------------------------
 418
 419 WXDWORD wxWindowPalm::PalmGetStyle(long flags, WXDWORD *exstyle) const
 420 {
 421     return 0;
 422 }
 423
 424 // Setup background and foreground colours correctly
 425 void wxWindowPalm::SetupColours()
 426 {
 427 }
 428
 429 void wxWindowPalm::OnInternalIdle()
 430 {
 431 }
 432
 433 // Set this window to be the child of 'parent'.
 434 bool wxWindowPalm::Reparent(wxWindowBase *parent)
 435 {
 436     return false;
 437 }
 438
 439 void wxWindowPalm::Freeze()
 440 {
 441 }
 442
 443 void wxWindowPalm::Thaw()
 444 {
 445 }
 446
 447 void wxWindowPalm::Refresh(bool eraseBack, const wxRect *rect)
 448 {
 449     WinHandle handle = (WinHandle)GetHWND();
 450     if(handle)
 451     {
 452         if(rect)
 453         {
 454             RectangleType dirtyRect;
 455             dirtyRect.topLeft.x = rect->GetX() - 1;
 456             dirtyRect.topLeft.y = rect->GetY() - 1;
 457             dirtyRect.extent.x = rect->GetWidth() + 1;
 458             dirtyRect.extent.y = rect->GetHeight() + 1;
 459             WinInvalidateRect(handle, &dirtyRect);
 460         }
 461         else
 462         {
 463             WinInvalidateWindow(handle);
 464         }
 465     }
 466 }
 467
 468 void wxWindowPalm::Update()
 469 {
 470 }
 471
 472 // ---------------------------------------------------------------------------
 473 // drag and drop
 474 // ---------------------------------------------------------------------------
 475
 476
 477 #if wxUSE_DRAG_AND_DROP
 478 void wxWindowPalm::SetDropTarget(wxDropTarget *pDropTarget)
 479 {
 480 }
 481 #endif // wxUSE_DRAG_AND_DROP
 482
 483 // old style file-manager drag&drop support: we retain the old-style
 484 // DragAcceptFiles in parallel with SetDropTarget.
 485 void wxWindowPalm::DragAcceptFiles(bool accept)
 486 {
 487 }
 488
 489 // ----------------------------------------------------------------------------
 490 // tooltips
 491 // ----------------------------------------------------------------------------
 492
 493 #if wxUSE_TOOLTIPS
 494
 495 void wxWindowPalm::DoSetToolTip(wxToolTip *tooltip)
 496 {
 497 }
 498
 499 #endif // wxUSE_TOOLTIPS
 500
 501 // ---------------------------------------------------------------------------
 502 // moving and resizing
 503 // ---------------------------------------------------------------------------
 504
 505 // Get total size
 506 void wxWindowPalm::DoGetSize(int *x, int *y) const
 507 {
 508 }
 509
 510 // Get size *available for subwindows* i.e. excluding menu bar etc.
 511 void wxWindowPalm::DoGetClientSize(int *x, int *y) const
 512 {
 513 }
 514
 515 void wxWindowPalm::DoGetPosition(int *x, int *y) const
 516 {
 517     if(x)
 518         *x = 0;
 519     if(y)
 520         *y = 0;
 521 }
 522
 523 void wxWindowPalm::DoScreenToClient(int *x, int *y) const
 524 {
 525 }
 526
 527 void wxWindowPalm::DoClientToScreen(int *x, int *y) const
 528 {
 529 }
 530
 531 void wxWindowPalm::DoMoveWindow(int x, int y, int width, int height)
 532 {
 533 }
 534
 535 // set the size of the window: if the dimensions are positive, just use them,
 536 // but if any of them is equal to -1, it means that we must find the value for
 537 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
 538 // which case -1 is a valid value for x and y)
 539 //
 540 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 541 // the width/height to best suit our contents, otherwise we reuse the current
 542 // width/height
 543 void wxWindowPalm::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 544 {
 545     // get the current size and position...
 546     int currentX, currentY;
 547     GetPosition(&currentX, &currentY);
 548     int currentW,currentH;
 549     GetSize(&currentW, &currentH);
 550
 551     // ... and don't do anything (avoiding flicker) if it's already ok
 552     if ( x == currentX && y == currentY &&
 553          width == currentW && height == currentH )
 554     {
 555         return;
 556     }
 557
 558     if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 559         x = currentX;
 560     if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 561         y = currentY;
 562
 563     AdjustForParentClientOrigin(x, y, sizeFlags);
 564
 565     wxSize size = wxDefaultSize;
 566     if ( width == wxDefaultCoord )
 567     {
 568         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
 569         {
 570             size = DoGetBestSize();
 571             width = size.x;
 572         }
 573         else
 574         {
 575             // just take the current one
 576             width = currentW;
 577         }
 578     }
 579
 580     if ( height == wxDefaultCoord )
 581     {
 582         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
 583         {
 584             if ( size.x == wxDefaultCoord )
 585             {
 586                 size = DoGetBestSize();
 587             }
 588             //else: already called DoGetBestSize() above
 589
 590             height = size.y;
 591         }
 592         else
 593         {
 594             // just take the current one
 595             height = currentH;
 596         }
 597     }
 598
 599     DoMoveWindow(x, y, width, height);
 600 }
 601
 602 void wxWindowPalm::DoSetClientSize(int width, int height)
 603 {
 604 }
 605
 606 // ---------------------------------------------------------------------------
 607 // text metrics
 608 // ---------------------------------------------------------------------------
 609
 610 int wxWindowPalm::GetCharHeight() const
 611 {
 612     return 0;
 613 }
 614
 615 int wxWindowPalm::GetCharWidth() const
 616 {
 617     return 0;
 618 }
 619
 620 void wxWindowPalm::GetTextExtent(const wxString& string,
 621                              int *x, int *y,
 622                              int *descent, int *externalLeading,
 623                              const wxFont *theFont) const
 624 {
 625 }
 626
 627 // ---------------------------------------------------------------------------
 628 // popup menu
 629 // ---------------------------------------------------------------------------
 630
 631 #if wxUSE_MENUS_NATIVE
 632
 633 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
 634 // immediately, without waiting for the next event loop iteration
 635 //
 636 // NB: this function should probably be made public later as it can almost
 637 //     surely replace wxYield() elsewhere as well
 638 static void wxYieldForCommandsOnly()
 639 {
 640 }
 641
 642 bool wxWindowPalm::DoPopupMenu(wxMenu *menu, int x, int y)
 643 {
 644     return false;
 645 }
 646
 647 #endif // wxUSE_MENUS_NATIVE
 648
 649 // ----------------------------------------------------------------------------
 650 // wxWindow <-> HWND map
 651 // ----------------------------------------------------------------------------
 652
 653 wxWinHashTable *wxWinHandleHash = NULL;
 654
 655 wxWindow *wxFindWinFromWinHandle(WXWINHANDLE handle)
 656 {
 657     // TODO
 658     return NULL;
 659 }
 660
 661 void wxRemoveHandleAssociation(wxWindowPalm *win)
 662 {
 663 }
 664
 665 // ----------------------------------------------------------------------------
 666 // various Palm specific class dependent functions
 667 // ----------------------------------------------------------------------------
 668
 669 bool wxWindowPalm::PalmGetCreateWindowCoords(const wxPoint& pos,
 670                                              const wxSize& size,
 671                                              int& x, int& y,
 672                                              int& w, int& h) const
 673 {
 674     return false;
 675 }
 676
 677 bool wxWindowPalm::PalmCreate(const wxChar *wclass,
 678                               const wxChar *title,
 679                               const wxPoint& pos,
 680                               const wxSize& size,
 681                               WXDWORD style,
 682                               WXDWORD extendedStyle)
 683 {
 684     return false;
 685 }
 686
 687 // ===========================================================================
 688 // Palm message handlers
 689 // ===========================================================================
 690
 691 // ---------------------------------------------------------------------------
 692 // painting
 693 // ---------------------------------------------------------------------------
 694
 695 // Can be called from an application's OnPaint handler
 696 void wxWindowPalm::OnPaint(wxPaintEvent& event)
 697 {
 698 }
 699
 700 void wxWindowPalm::OnEraseBackground(wxEraseEvent& event)
 701 {
 702 }
 703
 704 // ---------------------------------------------------------------------------
 705 // moving and resizing
 706 // ---------------------------------------------------------------------------
 707
 708 bool wxWindowPalm::HandleMove(int x, int y)
 709 {
 710     return false;
 711 }
 712
 713 bool wxWindowPalm::HandleMoving(wxRect& rect)
 714 {
 715     return false;
 716 }
 717
 718 // ---------------------------------------------------------------------------
 719 // joystick
 720 // ---------------------------------------------------------------------------
 721
 722 bool wxWindowPalm::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
 723 {
 724     return false;
 725 }
 726
 727 // ---------------------------------------------------------------------------
 728 // scrolling
 729 // ---------------------------------------------------------------------------
 730
 731 bool wxWindowPalm::PalmOnScroll(int orientation, WXWORD wParam,
 732                                 WXWORD pos, WXWINHANDLE control)
 733 {
 734     // TODO
 735     return false;
 736 }
 737
 738 // ===========================================================================
 739 // global functions
 740 // ===========================================================================
 741
 742 void wxGetCharSize(WXWINHANDLE wnd, int *x, int *y, const wxFont *the_font)
 743 {
 744     // TODO
 745 }
 746
 747 #if wxUSE_HOTKEY
 748
 749 bool wxWindowPalm::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
 750 {
 751     return false;
 752 }
 753
 754 bool wxWindowPalm::UnregisterHotKey(int hotkeyId)
 755 {
 756     return false;
 757 }
 758 #endif // # __WXUNIVERSAL__
 759 #endif // wxUSE_HOTKEY